From 5cfbb59e306f28fc708c16182f12f8e7ab0297d5 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Fri, 9 Jan 2026 13:37:08 +0000 Subject: [PATCH 01/17] Create performance test harness for runs replication service --- .gitignore | 5 + apps/webapp/package.json | 4 + .../scripts/profile-runs-replication.ts | 172 + apps/webapp/test/performance/README.md | 435 +++ .../test/performance/clickhouse-mock.ts | 53 + apps/webapp/test/performance/config.ts | 154 + .../test/performance/consumer-runner.ts | 134 + apps/webapp/test/performance/consumer.ts | 280 ++ .../webapp/test/performance/data-generator.ts | 142 + apps/webapp/test/performance/harness.ts | 516 +++ .../test/performance/metrics-collector.ts | 198 ++ .../test/performance/producer-runner.ts | 115 + apps/webapp/test/performance/producer.ts | 189 + pnpm-lock.yaml | 3069 ++++++++++++++++- 14 files changed, 5412 insertions(+), 54 deletions(-) create mode 100644 apps/webapp/scripts/profile-runs-replication.ts create mode 100644 apps/webapp/test/performance/README.md create mode 100644 apps/webapp/test/performance/clickhouse-mock.ts create mode 100644 apps/webapp/test/performance/config.ts create mode 100644 apps/webapp/test/performance/consumer-runner.ts create mode 100644 apps/webapp/test/performance/consumer.ts create mode 100644 apps/webapp/test/performance/data-generator.ts create mode 100644 apps/webapp/test/performance/harness.ts create mode 100644 apps/webapp/test/performance/metrics-collector.ts create mode 100644 apps/webapp/test/performance/producer-runner.ts create mode 100644 apps/webapp/test/performance/producer.ts diff --git a/.gitignore b/.gitignore index 8267c9fbab..b1ac3dbdcb 100644 --- a/.gitignore +++ b/.gitignore @@ -50,6 +50,11 @@ apps/**/public/build /playwright-report/ /playwright/.cache/ +# profiling outputs +profiling-results/ +*.clinic-* +*-v8.log + .cosine .trigger .tshy* diff --git a/apps/webapp/package.json b/apps/webapp/package.json index d7ac3a5003..ffdd9658ed 100644 --- a/apps/webapp/package.json +++ b/apps/webapp/package.json @@ -221,6 +221,8 @@ "zod-validation-error": "^1.5.0" }, "devDependencies": { + "@clinic/doctor": "^11.0.0", + "@clinic/flame": "^13.0.0", "@internal/clickhouse": "workspace:*", "@internal/replication": "workspace:*", "@internal/testcontainers": "workspace:*", @@ -263,6 +265,8 @@ "@typescript-eslint/parser": "^5.59.6", "autoevals": "^0.0.130", "autoprefixer": "^10.4.13", + "clinic": "^13.0.0", + "commander": "^11.0.0", "css-loader": "^6.10.0", "datepicker": "link:@types/@react-aria/datepicker", "engine.io": "^6.5.4", diff --git a/apps/webapp/scripts/profile-runs-replication.ts b/apps/webapp/scripts/profile-runs-replication.ts new file mode 100644 index 0000000000..b29b177f1e --- /dev/null +++ b/apps/webapp/scripts/profile-runs-replication.ts @@ -0,0 +1,172 @@ +#!/usr/bin/env tsx + +import { program } from "commander"; +import path from "path"; +import fs from "fs/promises"; +import { RunsReplicationHarness } from "../test/performance/harness"; +import { getDefaultConfig, type HarnessConfig } from "../test/performance/config"; + +program + .name("profile-runs-replication") + .description("Profile RunsReplicationService performance and identify bottlenecks") + .option("-c, --config ", "Config file path (JSON)") + .option("-t, --throughput ", "Target throughput (records/sec)", "5000") + .option("-d, --duration ", "Test duration per phase (seconds)", "60") + .option("--mock-clickhouse", "Use mock ClickHouse (CPU-only profiling)") + .option( + "--profile ", + "Profiling tool: doctor, flame, both, none", + "none" + ) + .option("--output ", "Output directory", "./profiling-results") + .option("-v, --verbose", "Verbose logging") + .parse(); + +async function loadConfig(options: any): Promise { + let config: HarnessConfig = getDefaultConfig() as HarnessConfig; + + // Load from config file if provided + if (options.config) { + console.log(`Loading config from: ${options.config}`); + const configFile = await fs.readFile(options.config, "utf-8"); + const fileConfig = JSON.parse(configFile); + config = { ...config, ...fileConfig }; + } + + // Override with CLI arguments + if (options.throughput) { + const throughput = parseInt(options.throughput, 10); + config.producer.targetThroughput = throughput; + + // Update all phases if no config file was provided + if (!options.config) { + config.phases = config.phases.map((phase) => ({ + ...phase, + targetThroughput: throughput, + })); + } + } + + if (options.duration) { + const duration = parseInt(options.duration, 10); + + // Update all phases if no config file was provided + if (!options.config) { + config.phases = config.phases.map((phase) => ({ + ...phase, + durationSec: duration, + })); + } + } + + if (options.mockClickhouse) { + config.consumer.useMockClickhouse = true; + } + + if (options.profile) { + config.profiling.enabled = options.profile !== "none"; + config.profiling.tool = options.profile; + } + + if (options.output) { + config.profiling.outputDir = options.output; + } + + if (options.verbose) { + config.output.verbose = true; + } + + // Ensure output directory exists + const timestamp = new Date().toISOString().replace(/[:.]/g, "-").split("T")[0]; + const outputDir = path.join(config.profiling.outputDir, timestamp); + config.profiling.outputDir = outputDir; + config.output.metricsFile = path.join(outputDir, "metrics.json"); + + return config; +} + +function printConfig(config: HarnessConfig): void { + console.log("\n" + "=".repeat(60)); + console.log("RunsReplicationService Performance Test Harness"); + console.log("=".repeat(60)); + console.log("\n๐Ÿ“‹ Configuration:"); + console.log(` Profiling DB: ${config.infrastructure.profilingDatabaseName}`); + console.log(` Output Dir: ${config.profiling.outputDir}`); + console.log(` Mock ClickHouse: ${config.consumer.useMockClickhouse ? "Yes (CPU-only)" : "No (full stack)"}`); + console.log(` Profiling Tool: ${config.profiling.tool}`); + console.log(` Verbose: ${config.output.verbose}`); + + console.log("\n๐Ÿ“Š Test Phases:"); + for (const phase of config.phases) { + console.log(` - ${phase.name.padEnd(15)} ${phase.durationSec}s @ ${phase.targetThroughput} rec/sec`); + } + + console.log("\nโš™๏ธ Producer Config:"); + console.log(` Insert/Update: ${(config.producer.insertUpdateRatio * 100).toFixed(0)}% inserts`); + console.log(` Batch Size: ${config.producer.batchSize}`); + console.log(` Payload Size: ${config.producer.payloadSizeKB} KB`); + + console.log("\nโš™๏ธ Consumer Config:"); + console.log(` Flush Batch Size: ${config.consumer.flushBatchSize}`); + console.log(` Flush Interval: ${config.consumer.flushIntervalMs} ms`); + console.log(` Max Concurrency: ${config.consumer.maxFlushConcurrency}`); + + console.log("\n" + "=".repeat(60) + "\n"); +} + +function printSummary(phases: any[]): void { + console.log("\n" + "=".repeat(60)); + console.log("๐Ÿ“ˆ Summary"); + console.log("=".repeat(60) + "\n"); + + for (const phase of phases) { + console.log(`${phase.phase}:`); + console.log(` Duration: ${(phase.durationMs / 1000).toFixed(1)}s`); + console.log(` Producer Throughput: ${phase.producerThroughput.toFixed(1)} rec/sec`); + console.log(` Consumer Throughput: ${phase.consumerThroughput.toFixed(1)} rec/sec`); + console.log(` Event Loop Util: ${(phase.eventLoopUtilization * 100).toFixed(1)}%`); + console.log(` Heap Used: ${phase.heapUsedMB.toFixed(1)} MB`); + console.log(` Replication Lag P95: ${phase.replicationLagP95.toFixed(1)} ms`); + console.log(); + } + + console.log("=".repeat(60) + "\n"); +} + +async function main() { + const options = program.opts(); + const config = await loadConfig(options); + + printConfig(config); + + const harness = new RunsReplicationHarness(config); + + try { + await harness.setup(); + const phases = await harness.run(); + await harness.teardown(); + + // Export metrics + await harness.exportMetrics(config.output.metricsFile); + + // Print summary + printSummary(phases); + + console.log("\nโœ… Profiling complete!"); + console.log(`๐Ÿ“Š Results saved to: ${config.profiling.outputDir}\n`); + + if (config.profiling.enabled && config.profiling.tool !== "none") { + console.log("๐Ÿ”ฅ Profiling data:"); + console.log(` View flamegraph/analysis in: ${config.profiling.outputDir}\n`); + } + + process.exit(0); + } catch (error) { + console.error("\nโŒ Profiling failed:"); + console.error(error); + await harness.teardown().catch(() => {}); + process.exit(1); + } +} + +main(); diff --git a/apps/webapp/test/performance/README.md b/apps/webapp/test/performance/README.md new file mode 100644 index 0000000000..3eebbe5d9b --- /dev/null +++ b/apps/webapp/test/performance/README.md @@ -0,0 +1,435 @@ +# RunsReplicationService Performance Test Harness + +A comprehensive test harness for profiling the `RunsReplicationService` to identify CPU and event loop bottlenecks during high-throughput replication from PostgreSQL to ClickHouse. + +## Overview + +This harness helps you: + +- **Profile CPU usage** and identify hot code paths with Clinic.js flamegraphs +- **Measure event loop utilization** to find bottlenecks +- **Test at scale** from 1k to 20k+ records/second +- **Isolate bottlenecks** by testing with real or mocked ClickHouse +- **Track metrics** across multiple test phases + +## Architecture + +The harness uses a **multi-process architecture** to prevent CPU interference: + +``` +Main Orchestrator Process +โ”œโ”€โ”€ Producer Process (writes to PostgreSQL) +โ”‚ โ””โ”€โ”€ Reports metrics via IPC +โ”œโ”€โ”€ Consumer Process (RunsReplicationService) +โ”‚ โ””โ”€โ”€ Optional: Wrapped by Clinic.js for profiling +โ”‚ โ””โ”€โ”€ Reports metrics via IPC +โ””โ”€โ”€ Metrics Collector (aggregates data) +``` + +**Key Features:** + +- Producer and consumer run in **separate Node.js processes** +- Real PostgreSQL writes trigger actual WAL-based logical replication +- Configurable ClickHouse mode: real writes or mocked (CPU-only profiling) +- Clinic.js integration for Doctor (event loop) and Flame (flamegraph) profiling +- Phase-based testing with detailed metrics per phase + +## Quick Start + +### 1. Configure Local Credentials + +The harness uses `test/performance/.env.local` (git-ignored) for credentials: + +```bash +# PostgreSQL (local instance) +DATABASE_URL=postgresql://postgres:postgres@localhost:5432/postgres?schema=public + +# Redis (local instance) +REDIS_URL=redis://localhost:6379 + +# ClickHouse Cloud +CLICKHOUSE_URL=https://your-instance.clickhouse.cloud:8443?username=default&password=YOUR_PASSWORD +``` + +**Note:** `.env.local` is automatically created with current credentials. Edit if you need to change them. + +### 2. Basic CPU Profiling (Mock ClickHouse) + +Profile at 10k records/sec with mocked ClickHouse to isolate CPU bottlenecks: + +```bash +pnpm tsx scripts/profile-runs-replication.ts \ + --mock-clickhouse \ + --throughput 10000 \ + --duration 60 \ + --profile flame +``` + +### 3. Full Stack Profiling (Real ClickHouse) + +Test the complete stack including real ClickHouse Cloud writes: + +```bash +pnpm tsx scripts/profile-runs-replication.ts \ + --throughput 5000 \ + --duration 60 +``` + +**Note:** The harness automatically runs ClickHouse migrations from `internal-packages/clickhouse/schema/` when using real ClickHouse. + +### Multi-Phase Testing + +Create a config file for complex test scenarios: + +```json +{ + "phases": [ + { "name": "warmup", "durationSec": 30, "targetThroughput": 1000 }, + { "name": "baseline", "durationSec": 60, "targetThroughput": 5000 }, + { "name": "stress", "durationSec": 120, "targetThroughput": 10000 }, + { "name": "peak", "durationSec": 60, "targetThroughput": 15000 } + ], + "profiling": { "enabled": true, "tool": "flame" }, + "consumer": { + "useMockClickhouse": true, + "flushBatchSize": 50, + "flushIntervalMs": 100, + "maxFlushConcurrency": 100 + } +} +``` + +Run with config file: + +```bash +pnpm tsx scripts/profile-runs-replication.ts --config config.json +``` + +## CLI Options + +``` +Usage: profile-runs-replication [options] + +Options: + -c, --config Config file path (JSON) + -t, --throughput Target throughput (records/sec) (default: 5000) + -d, --duration Test duration per phase (seconds) (default: 60) + --mock-clickhouse Use mock ClickHouse (CPU-only profiling) + --profile Profiling tool: doctor, flame, both, none (default: none) + --output Output directory (default: ./profiling-results) + -v, --verbose Verbose logging + -h, --help Display help +``` + +### Database Setup + +The harness creates a **separate database** (`trigger_profiling`) on your local PostgreSQL server: + +- โœ… Isolated from your main development database +- โœ… Schema copied from main database using `pg_dump` +- โœ… Preserved after tests for inspection +- โœ… Reuses existing org/project/environment records +- โš ๏ธ Requires local PostgreSQL with logical replication enabled (`wal_level = logical`) + +To clean up: `DROP DATABASE trigger_profiling;` + +## Configuration + +### Test Phases + +Define multiple test phases with different throughput targets: + +```typescript +{ + "phases": [ + { + "name": "warmup", + "durationSec": 30, + "targetThroughput": 1000 + }, + { + "name": "sustained", + "durationSec": 120, + "targetThroughput": 10000 + } + ] +} +``` + +### Producer Configuration + +```typescript +{ + "producer": { + "targetThroughput": 5000, // records/sec + "insertUpdateRatio": 0.8, // 80% inserts, 20% updates + "batchSize": 100, // records per batch write + "payloadSizeKB": 1 // average payload size + } +} +``` + +### Consumer Configuration + +```typescript +{ + "consumer": { + "flushBatchSize": 50, // batch size for ClickHouse writes + "flushIntervalMs": 100, // flush interval + "maxFlushConcurrency": 100, // concurrent flush operations + "useMockClickhouse": false, // true for CPU-only profiling + "mockClickhouseDelay": 0 // simulated network delay (ms) + } +} +``` + +### Profiling Configuration + +```typescript +{ + "profiling": { + "enabled": true, + "tool": "flame", // doctor, flame, both, none + "outputDir": "./profiling-results" + } +} +``` + +## Output and Metrics + +### Metrics Collected + +For each test phase: + +- **Producer Metrics:** + - Total inserts and updates + - Actual throughput (records/sec) + - Write latency (p50, p95, p99) + - Error count + +- **Consumer Metrics:** + - Batches flushed + - Records consumed + - Consumer throughput + - Replication lag (p50, p95, p99) + - Event loop utilization + - Heap memory usage + +### Output Files + +``` +profiling-results/ +โ””โ”€โ”€ 2026-01-09/ + โ”œโ”€โ”€ metrics.json # Detailed metrics for all phases + โ”œโ”€โ”€ .clinic-flame/ # Flamegraph (if enabled) + โ”‚ โ””โ”€โ”€ index.html + โ””โ”€โ”€ .clinic-doctor/ # Event loop analysis (if enabled) + โ””โ”€โ”€ index.html +``` + +### Viewing Profiling Results + +**Flamegraph (CPU hotspots):** +```bash +open profiling-results/2026-01-09/.clinic-flame/index.html +``` + +**Doctor (Event loop analysis):** +```bash +open profiling-results/2026-01-09/.clinic-doctor/index.html +``` + +## Common Use Cases + +### 1. Identify CPU Bottlenecks + +Use mocked ClickHouse to eliminate I/O overhead: + +```bash +pnpm tsx scripts/profile-runs-replication.ts \ + --mock-clickhouse \ + --throughput 10000 \ + --profile flame +``` + +**What to look for in flamegraph:** +- Hot functions consuming most CPU time +- JSON parsing overhead +- LSN conversion operations +- Array sorting/merging operations + +### 2. Measure Event Loop Saturation + +Use Clinic.js Doctor to analyze event loop health: + +```bash +pnpm tsx scripts/profile-runs-replication.ts \ + --mock-clickhouse \ + --throughput 15000 \ + --profile doctor +``` + +**What to look for in Doctor analysis:** +- Event loop delay spikes +- I/O vs CPU time breakdown +- Event loop utilization percentage + +### 3. Compare Configuration Changes + +Test different batch sizes to find optimal configuration: + +```bash +# Test with batch size 50 +pnpm tsx scripts/profile-runs-replication.ts \ + --throughput 8000 -d 60 --output ./results/batch-50 + +# Edit config and test with batch size 100 +pnpm tsx scripts/profile-runs-replication.ts \ + --throughput 8000 -d 60 --output ./results/batch-100 +``` + +### 4. Stress Test to Find Breaking Point + +Incrementally increase throughput to find maximum capacity: + +```json +{ + "phases": [ + { "name": "5k", "durationSec": 60, "targetThroughput": 5000 }, + { "name": "10k", "durationSec": 60, "targetThroughput": 10000 }, + { "name": "15k", "durationSec": 60, "targetThroughput": 15000 }, + { "name": "20k", "durationSec": 60, "targetThroughput": 20000 } + ] +} +``` + +### 5. Compare I/O vs CPU Overhead + +Run twice - once with real ClickHouse, once with mock: + +```bash +# With mock (CPU-only) +pnpm tsx scripts/profile-runs-replication.ts \ + --mock-clickhouse --throughput 8000 -d 60 \ + --output ./results/cpu-only + +# With real ClickHouse Cloud (requires CLICKHOUSE_URL in .env.local) +pnpm tsx scripts/profile-runs-replication.ts \ + --throughput 8000 -d 60 \ + --output ./results/full-stack +``` + +Compare event loop utilization to understand I/O impact. + +## Prerequisites + +### PostgreSQL Setup + +Ensure your local PostgreSQL has logical replication enabled: + +**1. Check your postgresql.conf:** +```ini +wal_level = logical +``` + +**2. Restart PostgreSQL if you changed the config:** +```bash +# macOS (Homebrew) +brew services restart postgresql + +# Linux +sudo systemctl restart postgresql +``` + +**3. Verify .env.local is configured:** +The harness loads credentials from `test/performance/.env.local`: +```bash +DATABASE_URL=postgresql://postgres:postgres@localhost:5432/postgres?schema=public +REDIS_URL=redis://localhost:6379 +CLICKHOUSE_URL=https://your-instance.clickhouse.cloud:8443?username=default&password=YOUR_PASSWORD +``` + +**4. The harness will automatically:** +- Create `trigger_profiling` database (separate from main DB) +- Copy schema from main database using `pg_dump` +- Configure REPLICA IDENTITY FULL on TaskRun table +- Create replication slot (`profiling_slot`) +- Create publication (`profiling_publication`) +- Run ClickHouse migrations (when using real ClickHouse) +- Reuse or create test org/project/environment + +## Troubleshooting + +### Producer/Consumer Out of Sync + +If consumer can't keep up with producer: + +1. Increase `flushBatchSize` for better throughput +2. Increase `maxFlushConcurrency` if ClickHouse can handle it +3. Reduce `targetThroughput` to sustainable level + +### Docker Container Startup Failures + +Ensure Docker is running and has sufficient resources: + +```bash +docker info # Check Docker status +``` + +Increase Docker memory/CPU limits if needed. + +### Process Not Exiting Cleanly + +If processes hang during shutdown: + +1. Check for unhandled promises +2. Ensure all intervals/timeouts are cleared +3. Force kill with Ctrl+C (process will be killed automatically after 30s) + +### High Memory Usage + +If heap usage grows excessively: + +1. Reduce payload size: `payloadSizeKB: 0.5` +2. Reduce batch sizes +3. Check for memory leaks in flamegraph (repeated allocations) + +## Architecture Details + +### Producer Process + +- Runs in isolated Node.js process +- Writes TaskRun records to PostgreSQL using Prisma +- Throttles to maintain exact target throughput +- Tracks insert/update latencies +- Reports metrics to orchestrator via IPC + +### Consumer Process + +- Runs in isolated Node.js process (optionally wrapped by Clinic.js) +- Executes RunsReplicationService +- Consumes PostgreSQL logical replication stream +- Writes to ClickHouse (real or mocked) +- Reports batch flush events and metrics via IPC + +### Orchestrator Process + +- Manages Docker containers (PostgreSQL, Redis, ClickHouse) +- Spawns producer and consumer processes +- Coordinates test phases +- Aggregates metrics +- Generates reports + +## Next Steps + +After running profiling: + +1. **Analyze flamegraphs** to identify top CPU consumers +2. **Check event loop utilization** - target <80% for headroom +3. **Optimize identified bottlenecks** in the code +4. **Re-run harness** to validate improvements +5. **Document findings** and optimal configuration + +## Examples from Plan + +See `/Users/eric/.claude/plans/elegant-humming-moler.md` for the complete implementation plan and additional context. diff --git a/apps/webapp/test/performance/clickhouse-mock.ts b/apps/webapp/test/performance/clickhouse-mock.ts new file mode 100644 index 0000000000..53a2e010a3 --- /dev/null +++ b/apps/webapp/test/performance/clickhouse-mock.ts @@ -0,0 +1,53 @@ +import type { RawTaskRunPayloadV1, TaskRunV2 } from "@internal/clickhouse"; + +/** + * Mock ClickHouse client for CPU-only profiling. + * Implements the minimal interface needed by RunsReplicationService + * without actually writing to ClickHouse. + */ +export class MockClickHouse { + private insertCount = 0; + private payloadInsertCount = 0; + + constructor(private readonly insertDelayMs: number = 0) {} + + taskRuns = { + insert: async ( + runs: TaskRunV2[], + options?: any + ): Promise<[Error | null, { rows: number } | null]> => { + if (this.insertDelayMs > 0) { + await new Promise((resolve) => setTimeout(resolve, this.insertDelayMs)); + } + + this.insertCount += runs.length; + + return [null, { rows: runs.length }]; + }, + + insertPayloads: async ( + payloads: RawTaskRunPayloadV1[], + options?: any + ): Promise<[Error | null, { rows: number } | null]> => { + if (this.insertDelayMs > 0) { + await new Promise((resolve) => setTimeout(resolve, this.insertDelayMs)); + } + + this.payloadInsertCount += payloads.length; + + return [null, { rows: payloads.length }]; + }, + }; + + getStats() { + return { + totalInserts: this.insertCount, + totalPayloadInserts: this.payloadInsertCount, + }; + } + + reset() { + this.insertCount = 0; + this.payloadInsertCount = 0; + } +} diff --git a/apps/webapp/test/performance/config.ts b/apps/webapp/test/performance/config.ts new file mode 100644 index 0000000000..929e5dbf12 --- /dev/null +++ b/apps/webapp/test/performance/config.ts @@ -0,0 +1,154 @@ +import { RedisOptions } from "ioredis"; +import { RuntimeEnvironmentType } from "~/database-types"; +import { config as loadEnv } from "dotenv"; +import path from "path"; + +// Load local environment variables for profiling (override existing vars) +loadEnv({ path: path.join(__dirname, ".env.local"), override: true }); + +export interface TestPhase { + name: string; + durationSec: number; + targetThroughput: number; // records/sec +} + +export interface ProducerConfig { + enabled: boolean; + targetThroughput: number; + insertUpdateRatio: number; // 0.0-1.0, e.g. 0.8 = 80% inserts, 20% updates + batchSize: number; + payloadSizeKB: number; + databaseUrl: string; + organizationId: string; + projectId: string; + runtimeEnvironmentId: string; + environmentType: RuntimeEnvironmentType; +} + +export interface ConsumerConfig { + flushBatchSize: number; + flushIntervalMs: number; + maxFlushConcurrency: number; + useMockClickhouse: boolean; + mockClickhouseDelay: number; // milliseconds + pgConnectionUrl: string; + clickhouseUrl?: string; + redisOptions: RedisOptions; + slotName: string; + publicationName: string; +} + +export interface ProfilingConfig { + enabled: boolean; + tool: "doctor" | "flame" | "both" | "none"; + outputDir: string; +} + +export interface OutputConfig { + metricsFile: string; + verbose: boolean; +} + +export interface InfrastructureConfig { + databaseUrl: string; + profilingDatabaseName?: string; // Defaults to "trigger_profiling" + redisUrl?: string; + clickhouseUrl?: string; +} + +export interface HarnessConfig { + phases: TestPhase[]; + producer: ProducerConfig; + consumer: ConsumerConfig; + profiling: ProfilingConfig; + output: OutputConfig; + infrastructure: InfrastructureConfig; +} + +export function getDefaultConfig(): Partial { + return { + phases: [ + { + name: "warmup", + durationSec: 30, + targetThroughput: 1000, + }, + { + name: "baseline", + durationSec: 60, + targetThroughput: 5000, + }, + ], + producer: { + enabled: true, + targetThroughput: 5000, + insertUpdateRatio: 0.8, + batchSize: 500, + payloadSizeKB: 1, + databaseUrl: "", + organizationId: "", + projectId: "", + runtimeEnvironmentId: "", + environmentType: "DEVELOPMENT", + }, + consumer: { + flushBatchSize: 50, + flushIntervalMs: 100, + maxFlushConcurrency: 100, + useMockClickhouse: false, + mockClickhouseDelay: 0, + pgConnectionUrl: "", + slotName: "profiling_slot", + publicationName: "profiling_publication", + redisOptions: {}, + }, + profiling: { + enabled: false, + tool: "none", + outputDir: "./profiling-results", + }, + output: { + metricsFile: "metrics.json", + verbose: false, + }, + infrastructure: { + databaseUrl: process.env.DATABASE_URL || "postgresql://postgres:postgres@localhost:5432/postgres", + profilingDatabaseName: "trigger_profiling", + redisUrl: process.env.REDIS_URL || "redis://localhost:6379", + clickhouseUrl: process.env.CLICKHOUSE_URL, + }, + }; +} + +export interface ProducerMetrics { + totalInserts: number; + totalUpdates: number; + actualThroughput: number; + errors: number; + latencies: number[]; // for calculating percentiles +} + +export interface PhaseMetrics { + phase: string; + durationMs: number; + + // Producer + recordsProduced: number; + producerThroughput: number; + + // Consumer + batchesFlushed: number; + recordsConsumed: number; + consumerThroughput: number; + replicationLagP50: number; + replicationLagP95: number; + replicationLagP99: number; + + // Performance + eventLoopUtilization: number; + flushDurationP50: number; + + // Memory + heapUsedMB: number; + heapTotalMB: number; +} diff --git a/apps/webapp/test/performance/consumer-runner.ts b/apps/webapp/test/performance/consumer-runner.ts new file mode 100644 index 0000000000..7908dd797e --- /dev/null +++ b/apps/webapp/test/performance/consumer-runner.ts @@ -0,0 +1,134 @@ +#!/usr/bin/env tsx + +import { RunsReplicationService } from "~/services/runsReplicationService.server"; +import { MockClickHouse } from "./clickhouse-mock"; +import type { ConsumerConfig } from "./config"; + +async function main() { + const hasIPC = !!process.send; + + if (!hasIPC) { + console.log("Warning: IPC not available (likely running under profiler) - metrics will not be sent to parent"); + } + + // Parse configuration from environment variable + const config: ConsumerConfig = JSON.parse(process.env.CONSUMER_CONFIG!); + + console.log("Consumer process starting with config:", { + useMockClickhouse: config.useMockClickhouse, + flushBatchSize: config.flushBatchSize, + flushIntervalMs: config.flushIntervalMs, + maxFlushConcurrency: config.maxFlushConcurrency, + }); + + // Create ClickHouse client (real or mocked) + let clickhouse; + if (config.useMockClickhouse) { + clickhouse = new MockClickHouse(config.mockClickhouseDelay); + } else { + // Use dynamic import to avoid module resolution issues with tsx + const { ClickHouse } = await import("@internal/clickhouse"); + clickhouse = new ClickHouse({ + url: config.clickhouseUrl!, + name: "runs-replication-profiling", + compression: { + request: true, + }, + }); + } + + // Create replication service + const service = new RunsReplicationService({ + clickhouse, + pgConnectionUrl: config.pgConnectionUrl, + serviceName: "runs-replication-profiling", + slotName: config.slotName, + publicationName: config.publicationName, + redisOptions: config.redisOptions, + flushBatchSize: config.flushBatchSize, + flushIntervalMs: config.flushIntervalMs, + maxFlushConcurrency: config.maxFlushConcurrency, + logLevel: "error", // Only log errors to reduce CPU overhead + }); + + console.log("Consumer: Starting RunsReplicationService"); + await service.start(); + + // Send batch flush events to parent via IPC (if available) + if (hasIPC) { + service.events.on("batchFlushed", (data) => { + process.send!({ + type: "batchFlushed", + data, + }); + }); + } + + // Send periodic metrics to parent (if IPC available) + const metricsInterval = setInterval(() => { + const memUsage = process.memoryUsage(); + const elu = performance.eventLoopUtilization(); + + if (hasIPC) { + process.send!({ + type: "metrics", + data: { + heapUsed: memUsage.heapUsed, + heapTotal: memUsage.heapTotal, + rss: memUsage.rss, + eventLoopUtilization: elu.utilization, + }, + }); + } + }, 1000); + + // Listen for shutdown signal from parent (if IPC available) + if (hasIPC) { + process.on("message", async (msg: any) => { + if (msg.type === "shutdown") { + console.log("Consumer: Received shutdown signal"); + clearInterval(metricsInterval); + await service.shutdown(); + await service.stop(); + process.exit(0); + } + }); + } + + // Handle uncaught errors + process.on("uncaughtException", (error) => { + console.error("Uncaught exception in consumer:", error); + if (hasIPC) { + process.send!({ + type: "error", + error: error.message, + }); + } + process.exit(1); + }); + + process.on("unhandledRejection", (reason) => { + console.error("Unhandled rejection in consumer:", reason); + if (hasIPC) { + process.send!({ + type: "error", + error: String(reason), + }); + } + process.exit(1); + }); + + // Signal ready to parent (if IPC available) + console.log("Consumer process ready"); + if (hasIPC) { + process.send!({ type: "ready" }); + } else { + // When profiling without IPC, just run indefinitely + console.log("Running in profiling mode - press Ctrl+C to stop"); + } +} + +main().catch((error) => { + console.error("Fatal error in consumer process:", error); + process.exit(1); +}); diff --git a/apps/webapp/test/performance/consumer.ts b/apps/webapp/test/performance/consumer.ts new file mode 100644 index 0000000000..972b5062db --- /dev/null +++ b/apps/webapp/test/performance/consumer.ts @@ -0,0 +1,280 @@ +import { ChildProcess, spawn } from "child_process"; +import path from "path"; +import type { ConsumerConfig, ProfilingConfig } from "./config"; + +interface ConsumerMetrics { + heapUsed: number; + heapTotal: number; + rss: number; + eventLoopUtilization: number; +} + +interface BatchFlushedEvent { + flushId: string; + taskRunInserts: any[]; + payloadInserts: any[]; +} + +export class ConsumerProcessManager { + private process: ChildProcess | null = null; + private ready = false; + private onMetrics?: (metrics: ConsumerMetrics) => void; + private onBatchFlushed?: (event: BatchFlushedEvent) => void; + private onError?: (error: string) => void; + + constructor( + private readonly config: ConsumerConfig, + private readonly profiling: ProfilingConfig + ) {} + + async start(): Promise { + const args = this.profiling.enabled && this.profiling.tool !== "none" + ? this.buildClinicArgs() + : this.buildDirectArgs(); + + console.log("Starting consumer process:", args.join(" ")); + + const isProfiling = this.profiling.enabled && this.profiling.tool !== "none"; + + this.process = spawn(args[0], args.slice(1), { + env: { + ...process.env, + CONSUMER_CONFIG: JSON.stringify(this.config), + }, + stdio: isProfiling + ? ["ignore", "pipe", "pipe", "ipc"] // Capture stdout/stderr when profiling to detect readiness + : ["ignore", "inherit", "inherit", "ipc"], + }); + + // When profiling, watch stdout for readiness message since IPC might not work + if (isProfiling && this.process.stdout) { + this.process.stdout.on("data", (data: Buffer) => { + const output = data.toString(); + process.stdout.write(data); // Still show output + if (output.includes("Consumer process ready")) { + this.ready = true; + console.log("Consumer process is ready (detected from stdout)"); + } + }); + } + + if (isProfiling && this.process.stderr) { + this.process.stderr.on("data", (data: Buffer) => { + process.stderr.write(data); // Show stderr + }); + } + + // Handle messages from child process (works when IPC is available) + this.process.on("message", (msg: any) => { + if (msg.type === "ready") { + this.ready = true; + console.log("Consumer process is ready"); + } else if (msg.type === "metrics" && this.onMetrics) { + this.onMetrics(msg.data); + } else if (msg.type === "batchFlushed" && this.onBatchFlushed) { + this.onBatchFlushed(msg.data); + } else if (msg.type === "error" && this.onError) { + this.onError(msg.error); + } + }); + + this.process.on("error", (error) => { + console.error("Consumer process error:", error); + if (this.onError) { + this.onError(error.message); + } + }); + + this.process.on("exit", (code, signal) => { + console.log(`Consumer process exited with code ${code}, signal ${signal}`); + }); + + // Wait for ready signal + await this.waitForReady(); + } + + async stop(): Promise { + if (!this.process) { + return; + } + + console.log("Stopping consumer process"); + this.process.send({ type: "shutdown" }); + + // Wait for process to exit + await new Promise((resolve) => { + const timeout = setTimeout(() => { + console.warn("Consumer process did not exit gracefully, killing"); + this.process?.kill("SIGKILL"); + resolve(); + }, 30000); // 30 second timeout + + this.process?.on("exit", () => { + clearTimeout(timeout); + resolve(); + }); + }); + + this.process = null; + this.ready = false; + } + + setOnMetrics(callback: (metrics: ConsumerMetrics) => void): void { + this.onMetrics = callback; + } + + setOnBatchFlushed(callback: (event: BatchFlushedEvent) => void): void { + this.onBatchFlushed = callback; + } + + setOnError(callback: (error: string) => void): void { + this.onError = callback; + } + + isReady(): boolean { + return this.ready; + } + + private buildDirectArgs(): string[] { + const runnerPath = path.join(__dirname, "consumer-runner.ts"); + return ["tsx", runnerPath]; + } + + private buildClinicArgs(): string[] { + const tool = this.profiling.tool === "both" ? "doctor" : this.profiling.tool; + const runnerPath = path.join(__dirname, "consumer-runner.ts"); + + // Clinic.js requires node, so use node with tsx/register loader + const args = [ + "pnpm", + "exec", + "clinic", + tool, + "--dest", + this.profiling.outputDir, + "--", + "node", + "--import", + "tsx", + runnerPath, + ]; + + return args; + } + + private async waitForReady(timeoutMs: number = 30000): Promise { + const start = Date.now(); + while (!this.ready) { + if (Date.now() - start > timeoutMs) { + throw new Error("Consumer process did not become ready within timeout"); + } + await new Promise((resolve) => setTimeout(resolve, 100)); + } + } +} + +export class ProducerProcessManager { + private process: ChildProcess | null = null; + private ready = false; + private onMetrics?: (metrics: any) => void; + private onError?: (error: string) => void; + + constructor(private readonly config: any) {} + + async start(): Promise { + const runnerPath = path.join(__dirname, "producer-runner.ts"); + const args = ["tsx", runnerPath]; + + console.log("Starting producer process:", args.join(" ")); + + this.process = spawn(args[0], args.slice(1), { + env: { + ...process.env, + PRODUCER_CONFIG: JSON.stringify(this.config), + }, + stdio: ["ignore", "inherit", "inherit", "ipc"], + }); + + this.process.on("message", (msg: any) => { + if (msg.type === "ready") { + this.ready = true; + console.log("Producer process is ready"); + } else if (msg.type === "metrics" && this.onMetrics) { + this.onMetrics(msg.data); + } else if (msg.type === "started") { + console.log("Producer has started production"); + } else if (msg.type === "stopped") { + console.log("Producer has stopped production"); + } else if (msg.type === "error" && this.onError) { + this.onError(msg.error); + } + }); + + this.process.on("error", (error) => { + console.error("Producer process error:", error); + if (this.onError) { + this.onError(error.message); + } + }); + + this.process.on("exit", (code, signal) => { + console.log(`Producer process exited with code ${code}, signal ${signal}`); + }); + + await this.waitForReady(); + } + + async stop(): Promise { + if (!this.process) { + return; + } + + console.log("Stopping producer process"); + this.process.send({ type: "shutdown" }); + + await new Promise((resolve) => { + const timeout = setTimeout(() => { + console.warn("Producer process did not exit gracefully, killing"); + this.process?.kill("SIGKILL"); + resolve(); + }, 10000); + + this.process?.on("exit", () => { + clearTimeout(timeout); + resolve(); + }); + }); + + this.process = null; + this.ready = false; + } + + send(message: any): void { + if (!this.process) { + throw new Error("Producer process not started"); + } + this.process.send(message); + } + + setOnMetrics(callback: (metrics: any) => void): void { + this.onMetrics = callback; + } + + setOnError(callback: (error: string) => void): void { + this.onError = callback; + } + + isReady(): boolean { + return this.ready; + } + + private async waitForReady(timeoutMs: number = 30000): Promise { + const start = Date.now(); + while (!this.ready) { + if (Date.now() - start > timeoutMs) { + throw new Error("Producer process did not become ready within timeout"); + } + await new Promise((resolve) => setTimeout(resolve, 100)); + } + } +} diff --git a/apps/webapp/test/performance/data-generator.ts b/apps/webapp/test/performance/data-generator.ts new file mode 100644 index 0000000000..c46df1c157 --- /dev/null +++ b/apps/webapp/test/performance/data-generator.ts @@ -0,0 +1,142 @@ +import { Prisma } from "@trigger.dev/database"; +import { nanoid } from "nanoid"; +import { RuntimeEnvironmentType, TaskRunStatus } from "~/database-types"; +import superjson from "superjson"; + +export interface DataGeneratorOptions { + organizationId: string; + projectId: string; + runtimeEnvironmentId: string; + environmentType: RuntimeEnvironmentType; + payloadSizeKB: number; + includeComplexPayloads?: boolean; +} + +export class TaskRunDataGenerator { + private readonly taskIdentifiers = [ + "send-email", + "process-payment", + "generate-report", + "sync-data", + "backup-database", + "send-notification", + "process-image", + "validate-user", + "cleanup-temp-files", + "update-analytics", + ]; + + private readonly queues = ["default", "high-priority", "low-priority", "background"]; + + private readonly workerQueues = ["main", "worker-1", "worker-2", "worker-3"]; + + private readonly statuses: TaskRunStatus[] = [ + "PENDING", + "EXECUTING", + "COMPLETED_SUCCESSFULLY", + "COMPLETED_WITH_ERRORS", + ]; + + private counter = 0; + + constructor(private readonly options: DataGeneratorOptions) {} + + generateBatch(count: number): Prisma.TaskRunCreateInput[] { + const batch: Prisma.TaskRunCreateInput[] = []; + for (let i = 0; i < count; i++) { + batch.push(this.generateInsert()); + } + return batch; + } + + generateInsert(): Prisma.TaskRunCreateInput { + this.counter++; + const id = nanoid(); + const friendlyId = `run_${this.counter}_${nanoid(8)}`; + const taskIdentifier = + this.taskIdentifiers[Math.floor(Math.random() * this.taskIdentifiers.length)]; + const queue = this.queues[Math.floor(Math.random() * this.queues.length)]; + const workerQueue = this.workerQueues[Math.floor(Math.random() * this.workerQueues.length)]; + + const payload = this.generatePayload(); + const payloadType = this.options.includeComplexPayloads && Math.random() > 0.7 + ? "application/super+json" + : "application/json"; + + return { + id, + friendlyId, + taskIdentifier, + payload: payloadType === "application/super+json" + ? superjson.stringify(payload) + : JSON.stringify(payload), + payloadType, + traceId: nanoid(), + spanId: nanoid(), + queue, + workerQueue, + runtimeEnvironmentId: this.options.runtimeEnvironmentId, + projectId: this.options.projectId, + organizationId: this.options.organizationId, + environmentType: this.options.environmentType, + status: "PENDING", + engine: "V2", + }; + } + + generateUpdate(runId: string): Prisma.TaskRunUpdateInput { + const status = this.statuses[Math.floor(Math.random() * this.statuses.length)]; + + const update: Prisma.TaskRunUpdateInput = { + status, + updatedAt: new Date(), + }; + + // Add timestamps based on status + if (status === "EXECUTING") { + update.startedAt = new Date(); + update.executedAt = new Date(); + } else if (status === "COMPLETED_SUCCESSFULLY") { + update.completedAt = new Date(); + update.usageDurationMs = Math.floor(Math.random() * 10000) + 1000; + } else if (status === "COMPLETED_WITH_ERRORS") { + update.completedAt = new Date(); + update.usageDurationMs = Math.floor(Math.random() * 10000) + 1000; + } + + return update; + } + + private generatePayload(): any { + const targetBytes = this.options.payloadSizeKB * 1024; + const basePayload: any = { + taskId: nanoid(), + timestamp: new Date().toISOString(), + userId: `user_${Math.floor(Math.random() * 10000)}`, + }; + + // Pad the payload to reach target size (do this before adding complex types that can't be JSON.stringified) + const currentSize = JSON.stringify(basePayload).length; + if (currentSize < targetBytes) { + const paddingSize = targetBytes - currentSize; + basePayload.padding = "x".repeat(paddingSize); + } + + if (this.options.includeComplexPayloads && Math.random() > 0.5) { + // Add complex types for superjson (after padding calculation) + basePayload.bigint = BigInt(Math.floor(Math.random() * 1000000)); + basePayload.date = new Date(); + basePayload.map = new Map([ + ["key1", "value1"], + ["key2", "value2"], + ]); + basePayload.set = new Set([1, 2, 3, 4, 5]); + } + + return basePayload; + } + + reset(): void { + this.counter = 0; + } +} diff --git a/apps/webapp/test/performance/harness.ts b/apps/webapp/test/performance/harness.ts new file mode 100644 index 0000000000..d59a110a36 --- /dev/null +++ b/apps/webapp/test/performance/harness.ts @@ -0,0 +1,516 @@ +import { PrismaClient } from "@trigger.dev/database"; +import { ConsumerProcessManager, ProducerProcessManager } from "./consumer"; +import { MetricsCollector } from "./metrics-collector"; +import type { HarnessConfig, PhaseMetrics } from "./config"; +import { execSync } from "child_process"; +import fs from "fs/promises"; +import path from "path"; + +export class RunsReplicationHarness { + private prisma: PrismaClient | null = null; + private adminPrisma: PrismaClient | null = null; + private producerProcess: ProducerProcessManager | null = null; + private consumerProcess: ConsumerProcessManager | null = null; + private metricsCollector: MetricsCollector; + + private organizationId: string = ""; + private projectId: string = ""; + private runtimeEnvironmentId: string = ""; + private profilingDatabaseUrl: string = ""; + + constructor(private readonly config: HarnessConfig) { + this.metricsCollector = new MetricsCollector(); + } + + async setup(): Promise { + console.log("\n๐Ÿš€ Setting up profiling database...\n"); + + const dbName = this.config.infrastructure.profilingDatabaseName || "trigger_profiling"; + + // 1. Create profiling database + console.log(`Creating database: ${dbName}...`); + await this.createProfilingDatabase(dbName); + + // 2. Build profiling database URL + this.profilingDatabaseUrl = this.buildProfilingDatabaseUrl( + this.config.infrastructure.databaseUrl, + dbName + ); + console.log(`Profiling database URL: ${this.maskPassword(this.profilingDatabaseUrl)}`); + + // 3. Initialize Prisma for profiling database + console.log("Initializing Prisma..."); + this.prisma = new PrismaClient({ + datasources: { + db: { + url: this.profilingDatabaseUrl, + }, + }, + }); + + // 4. Run migrations + console.log("Running database migrations..."); + await this.runMigrations(); + + // 5. Configure replication + console.log("Configuring logical replication..."); + await this.setupReplication(); + + // 6. Set up test fixtures + console.log("Setting up test fixtures..."); + await this.setupTestFixtures(); + + // 7. Parse Redis URL + const redisUrl = this.config.infrastructure.redisUrl || "redis://localhost:6379"; + const parsedRedis = this.parseRedisUrl(redisUrl); + + // 8. Update config + this.config.producer.databaseUrl = this.profilingDatabaseUrl; + this.config.producer.organizationId = this.organizationId; + this.config.producer.projectId = this.projectId; + this.config.producer.runtimeEnvironmentId = this.runtimeEnvironmentId; + + this.config.consumer.pgConnectionUrl = this.profilingDatabaseUrl; + this.config.consumer.redisOptions = parsedRedis; + + if (!this.config.consumer.useMockClickhouse) { + if (!this.config.infrastructure.clickhouseUrl) { + throw new Error( + "Real ClickHouse mode requires clickhouseUrl in config or CLICKHOUSE_URL env var" + ); + } + this.config.consumer.clickhouseUrl = this.config.infrastructure.clickhouseUrl; + console.log("ClickHouse URL:", this.maskPassword(this.config.consumer.clickhouseUrl)); + + // Run ClickHouse migrations + console.log("Running ClickHouse migrations..."); + await this.runClickHouseMigrations(); + console.log("โœ… ClickHouse migrations completed"); + } else { + console.log("Using mock ClickHouse (CPU-only profiling)"); + } + + // 9. Start consumer process + console.log("\nStarting consumer process..."); + this.consumerProcess = new ConsumerProcessManager( + this.config.consumer, + this.config.profiling + ); + + this.consumerProcess.setOnMetrics((metrics) => { + this.metricsCollector.recordConsumerMetrics(metrics); + }); + + this.consumerProcess.setOnBatchFlushed((event) => { + this.metricsCollector.recordBatchFlushed(event); + }); + + this.consumerProcess.setOnError((error) => { + console.error("Consumer error:", error); + }); + + await this.consumerProcess.start(); + + // 10. Start producer process + console.log("Starting producer process..."); + this.producerProcess = new ProducerProcessManager(this.config.producer); + + this.producerProcess.setOnMetrics((metrics) => { + this.metricsCollector.recordProducerMetrics(metrics); + }); + + this.producerProcess.setOnError((error) => { + console.error("Producer error:", error); + }); + + await this.producerProcess.start(); + + console.log("\nโœ… Profiling environment ready!\n"); + } + + async run(): Promise { + console.log("\nโ–ถ๏ธ Starting test phases...\n"); + + for (const phase of this.config.phases) { + console.log(`\n${"=".repeat(60)}`); + console.log(`Phase: ${phase.name}`); + console.log(`Duration: ${phase.durationSec}s | Target: ${phase.targetThroughput} rec/sec`); + console.log(`${"=".repeat(60)}\n`); + + this.metricsCollector.startPhase(phase.name); + + // Start producer + this.producerProcess!.send({ + type: "start", + throughput: phase.targetThroughput, + }); + + // Wait for phase duration + await this.waitWithProgress(phase.durationSec * 1000); + + // Stop producer + this.producerProcess!.send({ type: "stop" }); + console.log("\nProducer stopped, waiting for consumer to catch up..."); + + // Wait for consumer to catch up + await this.waitForReplicationLag(100, 60000); + + this.metricsCollector.endPhase(phase.name); + + // Small pause between phases + await new Promise((resolve) => setTimeout(resolve, 2000)); + } + + console.log("\nโœ… All phases completed!\n"); + return this.metricsCollector.getAllPhases(); + } + + async teardown(): Promise { + console.log("\n๐Ÿงน Tearing down...\n"); + + if (this.producerProcess) { + console.log("Stopping producer process..."); + await this.producerProcess.stop(); + } + + if (this.consumerProcess) { + console.log("Stopping consumer process..."); + await this.consumerProcess.stop(); + } + + if (this.prisma) { + console.log("Disconnecting Prisma..."); + await this.prisma.$disconnect(); + } + + if (this.adminPrisma) { + await this.adminPrisma.$disconnect(); + } + + console.log("\nโœ… Teardown complete!\n"); + console.log(`๐Ÿ’ก Profiling database '${this.config.infrastructure.profilingDatabaseName}' is preserved for inspection.`); + console.log(` To clean up: DROP DATABASE ${this.config.infrastructure.profilingDatabaseName};`); + } + + async exportMetrics(filePath: string): Promise { + await this.metricsCollector.exportToJSON(filePath); + } + + private async createProfilingDatabase(dbName: string): Promise { + // Connect to default database to create profiling database + const baseUrl = this.config.infrastructure.databaseUrl; + + this.adminPrisma = new PrismaClient({ + datasources: { + db: { + url: baseUrl, + }, + }, + }); + + // Check if database exists + const exists = await this.adminPrisma.$queryRaw>` + SELECT datname FROM pg_database WHERE datname = ${dbName}; + `; + + if (exists.length === 0) { + // Create database + await this.adminPrisma.$executeRawUnsafe(`CREATE DATABASE ${dbName};`); + console.log(`โœ… Created database: ${dbName}`); + } else { + console.log(`โœ… Database already exists: ${dbName}`); + } + } + + private buildProfilingDatabaseUrl(baseUrl: string, dbName: string): string { + // Parse the base URL and replace the database name + const url = new URL(baseUrl); + url.pathname = `/${dbName}`; + return url.toString(); + } + + private async runMigrations(): Promise { + try { + // Use pg_dump to copy schema from main database to profiling database + const baseUrl = this.config.infrastructure.databaseUrl; + const dbName = this.config.infrastructure.profilingDatabaseName || "trigger_profiling"; + + console.log("Copying schema from main database to profiling database..."); + + // Strip query parameters from URLs (pg_dump doesn't support them) + const cleanBaseUrl = baseUrl.split("?")[0]; + const cleanProfilingUrl = this.profilingDatabaseUrl.split("?")[0]; + + // Dump schema only (no data) from main database + execSync(`pg_dump "${cleanBaseUrl}" --schema-only --no-owner --no-acl | psql "${cleanProfilingUrl}" > /dev/null 2>&1`, { + shell: true, + }); + + console.log("โœ… Schema copied successfully"); + } catch (error) { + console.error("โŒ Schema copy failed:", error); + throw error; + } + } + + private async setupReplication(): Promise { + // Set REPLICA IDENTITY FULL + await this.prisma!.$executeRawUnsafe( + `ALTER TABLE public."TaskRun" REPLICA IDENTITY FULL;` + ); + + // Check if slot exists + const slotExists = await this.prisma!.$queryRaw>` + SELECT slot_name FROM pg_replication_slots WHERE slot_name = ${this.config.consumer.slotName}; + `; + + if (slotExists.length === 0) { + await this.prisma!.$executeRawUnsafe( + `SELECT pg_create_logical_replication_slot('${this.config.consumer.slotName}', 'pgoutput');` + ); + console.log(`โœ… Created replication slot: ${this.config.consumer.slotName}`); + } else { + console.log(`โœ… Replication slot exists: ${this.config.consumer.slotName}`); + } + + // Check if publication exists + const pubExists = await this.prisma!.$queryRaw>` + SELECT pubname FROM pg_publication WHERE pubname = ${this.config.consumer.publicationName}; + `; + + if (pubExists.length === 0) { + await this.prisma!.$executeRawUnsafe( + `CREATE PUBLICATION ${this.config.consumer.publicationName} FOR TABLE "TaskRun";` + ); + console.log(`โœ… Created publication: ${this.config.consumer.publicationName}`); + } else { + console.log(`โœ… Publication exists: ${this.config.consumer.publicationName}`); + } + } + + private async setupTestFixtures(): Promise { + // Try to find existing profiling fixtures + let org = await this.prisma!.organization.findFirst({ + where: { + slug: { + startsWith: "perf-test-", + }, + }, + orderBy: { + createdAt: "desc", + }, + }); + + if (!org) { + org = await this.prisma!.organization.create({ + data: { + title: "Performance Test Org", + slug: `perf-test-${Date.now()}`, + }, + }); + console.log(`Created organization: ${org.id}`); + } else { + console.log(`Using existing organization: ${org.id}`); + } + + this.organizationId = org.id; + + // Find or create project + let project = await this.prisma!.project.findFirst({ + where: { + organizationId: org.id, + }, + orderBy: { + createdAt: "desc", + }, + }); + + if (!project) { + project = await this.prisma!.project.create({ + data: { + name: "Performance Test Project", + slug: `perf-test-${Date.now()}`, + organizationId: org.id, + externalRef: `perf-test-${Date.now()}`, + }, + }); + console.log(`Created project: ${project.id}`); + } else { + console.log(`Using existing project: ${project.id}`); + } + + this.projectId = project.id; + + // Find or create runtime environment + let env = await this.prisma!.runtimeEnvironment.findFirst({ + where: { + projectId: project.id, + type: "DEVELOPMENT", + }, + orderBy: { + createdAt: "desc", + }, + }); + + if (!env) { + env = await this.prisma!.runtimeEnvironment.create({ + data: { + slug: "dev", + type: "DEVELOPMENT", + projectId: project.id, + organizationId: org.id, + apiKey: `test-key-${Date.now()}`, + pkApiKey: `pk-test-${Date.now()}`, + shortcode: `dev-${Date.now()}`, + }, + }); + console.log(`Created environment: ${env.id}`); + } else { + console.log(`Using existing environment: ${env.id}`); + } + + this.runtimeEnvironmentId = env.id; + + console.log(`\nโœ… Test fixtures ready:`); + console.log(` Organization: ${this.organizationId}`); + console.log(` Project: ${this.projectId}`); + console.log(` Environment: ${this.runtimeEnvironmentId}`); + } + + private parseRedisUrl(url: string): any { + const match = url.match(/^redis:\/\/(?::([^@]+)@)?([^:]+):(\d+)/); + if (!match) { + return { + host: "localhost", + port: 6379, + }; + } + + return { + host: match[2], + port: parseInt(match[3], 10), + password: match[1] || undefined, + }; + } + + private async waitForReplicationLag(maxLagMs: number, timeoutMs: number): Promise { + const start = Date.now(); + + while (Date.now() - start < timeoutMs) { + await new Promise((resolve) => setTimeout(resolve, 1000)); + + if (Date.now() - start > 5000) { + console.log("โœ… Consumer caught up (approximated)"); + return; + } + } + + console.warn("โš ๏ธ Timeout waiting for replication to catch up"); + } + + private async waitWithProgress(durationMs: number): Promise { + const start = Date.now(); + const interval = 5000; + + while (Date.now() - start < durationMs) { + const elapsed = Date.now() - start; + const remaining = durationMs - elapsed; + const progress = (elapsed / durationMs) * 100; + + process.stdout.write( + `\rProgress: ${progress.toFixed(1)}% | Remaining: ${(remaining / 1000).toFixed(0)}s` + ); + + await new Promise((resolve) => setTimeout(resolve, Math.min(interval, remaining))); + } + + process.stdout.write("\n"); + } + + private async runClickHouseMigrations(): Promise { + // Use dynamic import to avoid module resolution issues with tsx + const { ClickHouse } = await import("@internal/clickhouse"); + + const clickhouse = new ClickHouse({ + url: this.config.infrastructure.clickhouseUrl!, + name: "profiling-migrator", + }); + + try { + // Path to migration files (relative to apps/webapp/test/performance) + const migrationsPath = path.join(__dirname, "../../../../internal-packages/clickhouse/schema"); + + // Read all SQL files in order + const files = await fs.readdir(migrationsPath); + const sqlFiles = files + .filter((f) => f.endsWith(".sql")) + .sort(); // Ensure numeric ordering + + console.log(`Found ${sqlFiles.length} migration files`); + + for (const file of sqlFiles) { + console.log(` Running migration: ${file}`); + const sql = await fs.readFile(path.join(migrationsPath, file), "utf-8"); + + // Parse goose migration file - only execute "up" section + const lines = sql.split("\n"); + let inUpSection = false; + const upSql: string[] = []; + + for (const line of lines) { + const trimmed = line.trim(); + const lowerTrimmed = trimmed.toLowerCase(); + + // Check for section markers (case-insensitive) + if (lowerTrimmed.includes("+goose up")) { + inUpSection = true; + continue; + } + if (lowerTrimmed.includes("+goose down")) { + inUpSection = false; + break; // Stop processing, we only want the "up" section + } + + // Add lines from the "up" section + if (inUpSection && trimmed) { + // Skip standalone comment lines (but keep inline comments and /* */ blocks) + if (trimmed.startsWith("--")) { + continue; + } + upSql.push(line); + } + } + + // Join and split by semicolons + const statements = upSql + .join("\n") + .split(";") + .map((s) => s.trim()) + .filter((s) => s.length > 0); + + for (const statement of statements) { + try { + console.log(` Executing: ${statement.substring(0, 80)}...`); + // Use the underlying client's command method + await (clickhouse.writer as any).client.command({ query: statement }); + console.log(` โœ“ Success`); + } catch (error: any) { + // Ignore "already exists" errors + if (error.message?.includes("already exists") || error.message?.includes("ALREADY_EXISTS")) { + console.log(` โŠ˜ Skipped (already exists)`); + } else { + console.log(` โœ— Error: ${error.message}`); + throw error; + } + } + } + } + } finally { + await clickhouse.close(); + } + } + + private maskPassword(url: string): string { + return url.replace(/\/\/.*@/, "//***:***@"); + } +} diff --git a/apps/webapp/test/performance/metrics-collector.ts b/apps/webapp/test/performance/metrics-collector.ts new file mode 100644 index 0000000000..37dbc83ff8 --- /dev/null +++ b/apps/webapp/test/performance/metrics-collector.ts @@ -0,0 +1,198 @@ +import type { PhaseMetrics, ProducerMetrics } from "./config"; +import fs from "fs/promises"; +import path from "path"; + +interface ConsumerMetrics { + heapUsed: number; + heapTotal: number; + rss: number; + eventLoopUtilization: number; +} + +interface BatchFlushedEvent { + flushId: string; + taskRunInserts: any[]; + payloadInserts: any[]; +} + +export class MetricsCollector { + private phases: Map = new Map(); + private currentPhase: PhaseData | null = null; + + startPhase(name: string): void { + const phase: PhaseData = { + name, + startTime: Date.now(), + endTime: null, + producerMetrics: [], + consumerMetrics: [], + batchesFlushed: [], + replicationLags: [], + }; + + this.phases.set(name, phase); + this.currentPhase = phase; + + console.log(`\n๐Ÿ“Š Phase started: ${name}`); + } + + endPhase(name: string): PhaseMetrics { + const phase = this.phases.get(name); + if (!phase) { + throw new Error(`Phase ${name} not found`); + } + + phase.endTime = Date.now(); + this.currentPhase = null; + + const metrics = this.calculatePhaseMetrics(phase); + console.log(`โœ… Phase completed: ${name}`); + this.printPhaseMetrics(metrics); + + return metrics; + } + + recordProducerMetrics(metrics: ProducerMetrics): void { + if (this.currentPhase) { + this.currentPhase.producerMetrics.push({ + timestamp: Date.now(), + ...metrics, + }); + } + } + + recordConsumerMetrics(metrics: ConsumerMetrics): void { + if (this.currentPhase) { + this.currentPhase.consumerMetrics.push({ + timestamp: Date.now(), + ...metrics, + }); + } + } + + recordBatchFlushed(event: BatchFlushedEvent): void { + if (this.currentPhase) { + this.currentPhase.batchesFlushed.push({ + timestamp: Date.now(), + ...event, + }); + } + } + + recordReplicationLag(lagMs: number): void { + if (this.currentPhase) { + this.currentPhase.replicationLags.push(lagMs); + } + } + + async exportToJSON(filePath: string): Promise { + const report = { + timestamp: new Date().toISOString(), + phases: Array.from(this.phases.values()).map((phase) => + this.calculatePhaseMetrics(phase) + ), + }; + + const dir = path.dirname(filePath); + await fs.mkdir(dir, { recursive: true }); + await fs.writeFile(filePath, JSON.stringify(report, null, 2)); + + console.log(`\n๐Ÿ“„ Metrics exported to: ${filePath}`); + } + + private calculatePhaseMetrics(phase: PhaseData): PhaseMetrics { + const durationMs = phase.endTime ? phase.endTime - phase.startTime : Date.now() - phase.startTime; + const durationSec = durationMs / 1000; + + // Producer metrics + const lastProducerMetric = phase.producerMetrics[phase.producerMetrics.length - 1]; + const recordsProduced = lastProducerMetric + ? lastProducerMetric.totalInserts + lastProducerMetric.totalUpdates + : 0; + const producerThroughput = durationSec > 0 ? recordsProduced / durationSec : 0; + + // Consumer metrics + const totalBatches = phase.batchesFlushed.length; + const recordsConsumed = phase.batchesFlushed.reduce( + (sum, batch) => sum + batch.taskRunInserts.length, + 0 + ); + const consumerThroughput = durationSec > 0 ? recordsConsumed / durationSec : 0; + + // Replication lag + const sortedLags = [...phase.replicationLags].sort((a, b) => a - b); + const replicationLagP50 = this.percentile(sortedLags, 0.5); + const replicationLagP95 = this.percentile(sortedLags, 0.95); + const replicationLagP99 = this.percentile(sortedLags, 0.99); + + // Event loop utilization (average of samples) + const eventLoopUtilization = + phase.consumerMetrics.length > 0 + ? phase.consumerMetrics.reduce((sum, m) => sum + m.eventLoopUtilization, 0) / + phase.consumerMetrics.length + : 0; + + // Memory (last sample) + const lastConsumerMetric = phase.consumerMetrics[phase.consumerMetrics.length - 1]; + const heapUsedMB = lastConsumerMetric ? lastConsumerMetric.heapUsed / 1024 / 1024 : 0; + const heapTotalMB = lastConsumerMetric ? lastConsumerMetric.heapTotal / 1024 / 1024 : 0; + + // Flush duration (not directly available, use placeholder) + const flushDurationP50 = 0; // Would need to extract from OpenTelemetry metrics + + return { + phase: phase.name, + durationMs, + recordsProduced, + producerThroughput, + batchesFlushed: totalBatches, + recordsConsumed, + consumerThroughput, + replicationLagP50, + replicationLagP95, + replicationLagP99, + eventLoopUtilization, + flushDurationP50, + heapUsedMB, + heapTotalMB, + }; + } + + private percentile(sorted: number[], p: number): number { + if (sorted.length === 0) return 0; + const index = Math.ceil(sorted.length * p) - 1; + return sorted[Math.max(0, index)]; + } + + private printPhaseMetrics(metrics: PhaseMetrics): void { + console.log("\n" + "=".repeat(60)); + console.log(`Phase: ${metrics.phase}`); + console.log("=".repeat(60)); + console.log(`Duration: ${(metrics.durationMs / 1000).toFixed(1)}s`); + console.log(`Records Produced: ${metrics.recordsProduced}`); + console.log(`Producer Throughput: ${metrics.producerThroughput.toFixed(1)} rec/sec`); + console.log(`Records Consumed: ${metrics.recordsConsumed}`); + console.log(`Consumer Throughput: ${metrics.consumerThroughput.toFixed(1)} rec/sec`); + console.log(`Batches Flushed: ${metrics.batchesFlushed}`); + console.log(`Event Loop Util: ${(metrics.eventLoopUtilization * 100).toFixed(1)}%`); + console.log(`Heap Used: ${metrics.heapUsedMB.toFixed(1)} MB`); + console.log(`Replication Lag P50: ${metrics.replicationLagP50.toFixed(1)} ms`); + console.log(`Replication Lag P95: ${metrics.replicationLagP95.toFixed(1)} ms`); + console.log(`Replication Lag P99: ${metrics.replicationLagP99.toFixed(1)} ms`); + console.log("=".repeat(60) + "\n"); + } + + getAllPhases(): PhaseMetrics[] { + return Array.from(this.phases.values()).map((phase) => this.calculatePhaseMetrics(phase)); + } +} + +interface PhaseData { + name: string; + startTime: number; + endTime: number | null; + producerMetrics: Array<{ timestamp: number } & ProducerMetrics>; + consumerMetrics: Array<{ timestamp: number } & ConsumerMetrics>; + batchesFlushed: Array<{ timestamp: number } & BatchFlushedEvent>; + replicationLags: number[]; +} diff --git a/apps/webapp/test/performance/producer-runner.ts b/apps/webapp/test/performance/producer-runner.ts new file mode 100644 index 0000000000..1b4124e24c --- /dev/null +++ b/apps/webapp/test/performance/producer-runner.ts @@ -0,0 +1,115 @@ +#!/usr/bin/env tsx + +import { PrismaClient } from "@trigger.dev/database"; +import { TaskRunDataGenerator } from "./data-generator"; +import { TaskRunProducer } from "./producer"; +import type { ProducerConfig } from "./config"; + +async function main() { + if (!process.send) { + throw new Error("This script must be run as a child process with IPC enabled"); + } + + // Parse configuration from environment variable + const config: ProducerConfig = JSON.parse(process.env.PRODUCER_CONFIG!); + + console.log("Producer process starting with config:", { + targetThroughput: config.targetThroughput, + batchSize: config.batchSize, + insertUpdateRatio: config.insertUpdateRatio, + }); + + // Connect to PostgreSQL + const prisma = new PrismaClient({ + datasources: { + db: { + url: config.databaseUrl, + }, + }, + }); + + // Create data generator + const dataGenerator = new TaskRunDataGenerator({ + organizationId: config.organizationId, + projectId: config.projectId, + runtimeEnvironmentId: config.runtimeEnvironmentId, + environmentType: config.environmentType, + payloadSizeKB: config.payloadSizeKB, + includeComplexPayloads: false, // Disabled to avoid BigInt serialization issues + }); + + // Create producer + const producer = new TaskRunProducer({ + prisma, + dataGenerator, + targetThroughput: config.targetThroughput, + insertUpdateRatio: config.insertUpdateRatio, + batchSize: config.batchSize, + }); + + // Send metrics to parent every second + const metricsInterval = setInterval(() => { + const metrics = producer.getMetrics(); + process.send!({ + type: "metrics", + data: metrics, + }); + }, 1000); + + // Listen for commands from parent process + process.on("message", async (msg: any) => { + try { + if (msg.type === "start") { + console.log("Producer: Starting production at", msg.throughput || config.targetThroughput, "records/sec"); + await producer.start(); + process.send!({ type: "started" }); + } else if (msg.type === "stop") { + console.log("Producer: Stopping production"); + await producer.stop(); + process.send!({ type: "stopped" }); + // Don't exit - wait for restart or shutdown command + } else if (msg.type === "shutdown") { + console.log("Producer: Shutting down"); + await producer.stop(); + clearInterval(metricsInterval); + await prisma.$disconnect(); + process.send!({ type: "shutdown_complete" }); + process.exit(0); + } + } catch (error) { + console.error("Producer process error:", error); + process.send!({ + type: "error", + error: error instanceof Error ? error.message : String(error), + }); + } + }); + + // Handle uncaught errors (log but don't exit - producer loop handles errors gracefully) + process.on("uncaughtException", (error) => { + console.error("Uncaught exception in producer:", error); + process.send!({ + type: "error", + error: error.message, + }); + // Don't exit - let the producer loop continue + }); + + process.on("unhandledRejection", (reason) => { + console.error("Unhandled rejection in producer:", reason); + process.send!({ + type: "error", + error: String(reason), + }); + // Don't exit - let the producer loop continue + }); + + // Signal ready to parent + console.log("Producer process ready"); + process.send!({ type: "ready" }); +} + +main().catch((error) => { + console.error("Fatal error in producer process:", error); + process.exit(1); +}); diff --git a/apps/webapp/test/performance/producer.ts b/apps/webapp/test/performance/producer.ts new file mode 100644 index 0000000000..86c407ad93 --- /dev/null +++ b/apps/webapp/test/performance/producer.ts @@ -0,0 +1,189 @@ +import { PrismaClient } from "@trigger.dev/database"; +import { TaskRunDataGenerator } from "./data-generator"; +import type { ProducerMetrics } from "./config"; + +export interface TaskRunProducerOptions { + prisma: PrismaClient; + dataGenerator: TaskRunDataGenerator; + targetThroughput: number; + insertUpdateRatio: number; + batchSize: number; +} + +export class TaskRunProducer { + private running = false; + private totalInserts = 0; + private totalUpdates = 0; + private errors = 0; + private latencies: number[] = []; + private createdRunIds: string[] = []; + private timer: NodeJS.Timeout | null = null; + private startTime: number = 0; + + constructor(private readonly options: TaskRunProducerOptions) {} + + async start(): Promise { + if (this.running) { + throw new Error("Producer is already running"); + } + + this.running = true; + this.startTime = Date.now(); + this.resetMetrics(); + + await this.runProducerLoop(); + } + + async stop(): Promise { + this.running = false; + if (this.timer) { + clearTimeout(this.timer); + this.timer = null; + } + } + + getMetrics(): ProducerMetrics { + const elapsed = (Date.now() - this.startTime) / 1000; // seconds + const actualThroughput = elapsed > 0 ? (this.totalInserts + this.totalUpdates) / elapsed : 0; + + return { + totalInserts: this.totalInserts, + totalUpdates: this.totalUpdates, + actualThroughput, + errors: this.errors, + latencies: [...this.latencies], + }; + } + + private async runProducerLoop(): Promise { + while (this.running) { + const loopStart = Date.now(); + + try { + // Determine insert vs update ratio for this batch + const insertCount = Math.floor(this.options.batchSize * this.options.insertUpdateRatio); + const updateCount = this.options.batchSize - insertCount; + + // Perform inserts + if (insertCount > 0) { + await this.performInserts(insertCount); + } + + // Perform updates (only if we have created runs to update) + if (updateCount > 0 && this.createdRunIds.length > 0) { + await this.performUpdates(updateCount); + } + + // Calculate delay to maintain target throughput + const elapsed = Date.now() - loopStart; + const targetDuration = (this.options.batchSize / this.options.targetThroughput) * 1000; + const delay = Math.max(0, targetDuration - elapsed); + + if (this.running && delay > 0) { + await new Promise((resolve) => { + this.timer = setTimeout(resolve, delay); + }); + } + } catch (error) { + console.error("Producer loop error:", error); + this.errors++; + + // Small delay on error to prevent tight error loops + if (this.running) { + await new Promise((resolve) => { + this.timer = setTimeout(resolve, 1000); + }); + } + } + } + } + + private async performInserts(count: number): Promise { + const start = performance.now(); + + const records = this.options.dataGenerator.generateBatch(count); + + // Extract IDs for future updates + const ids = records.map((r) => r.id as string); + + try { + await this.options.prisma.taskRun.createMany({ + data: records, + skipDuplicates: true, + }); + + this.totalInserts += count; + this.createdRunIds.push(...ids); + + // Keep pool size manageable (max 10000 runs) + if (this.createdRunIds.length > 10000) { + this.createdRunIds = this.createdRunIds.slice(-10000); + } + + const duration = performance.now() - start; + this.latencies.push(duration); + + // Keep latencies array from growing too large + if (this.latencies.length > 1000) { + this.latencies = this.latencies.slice(-1000); + } + } catch (error) { + console.error("Insert error:", error); + this.errors++; + throw error; + } + } + + private async performUpdates(count: number): Promise { + // Skip updates if no runs have been created yet + if (this.createdRunIds.length === 0) { + return; + } + + const start = performance.now(); + + // Select random runs to update + const runIdsToUpdate = new Set(); + while (runIdsToUpdate.size < count && runIdsToUpdate.size < this.createdRunIds.length) { + const randomIndex = Math.floor(Math.random() * this.createdRunIds.length); + runIdsToUpdate.add(this.createdRunIds[randomIndex]); + } + + try { + // Use a single updateMany for all updates with the same data + // This is a simplification - in reality each update might have different data + // but for performance testing, updating them all the same way is fine + const updateData = this.options.dataGenerator.generateUpdate(""); + + await this.options.prisma.taskRun.updateMany({ + where: { + id: { + in: Array.from(runIdsToUpdate), + }, + }, + data: updateData, + }); + + this.totalUpdates += runIdsToUpdate.size; + + const duration = performance.now() - start; + this.latencies.push(duration); + + if (this.latencies.length > 1000) { + this.latencies = this.latencies.slice(-1000); + } + } catch (error) { + console.error("Update error:", error); + this.errors++; + throw error; + } + } + + private resetMetrics(): void { + this.totalInserts = 0; + this.totalUpdates = 0; + this.errors = 0; + this.latencies = []; + this.createdRunIds = []; + } +} diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 8202f55d87..aaf883a4da 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -787,6 +787,12 @@ importers: specifier: ^1.5.0 version: 1.5.0(zod@3.25.76) devDependencies: + '@clinic/doctor': + specifier: ^11.0.0 + version: 11.0.0(encoding@0.1.13) + '@clinic/flame': + specifier: ^13.0.0 + version: 13.0.0 '@internal/clickhouse': specifier: workspace:* version: link:../../internal-packages/clickhouse @@ -913,6 +919,12 @@ importers: autoprefixer: specifier: ^10.4.13 version: 10.4.13(postcss@8.5.6) + clinic: + specifier: ^13.0.0 + version: 13.0.0(encoding@0.1.13) + commander: + specifier: ^11.0.0 + version: 11.1.0 css-loader: specifier: ^6.10.0 version: 6.10.0(webpack@5.102.1(@swc/core@1.3.26)(esbuild@0.15.18)) @@ -1072,7 +1084,7 @@ importers: version: 18.3.1 react-email: specifier: ^2.1.1 - version: 2.1.2(@opentelemetry/api@1.9.0)(@swc/helpers@0.5.15)(bufferutil@4.0.9)(eslint@8.31.0) + version: 2.1.2(@opentelemetry/api@1.9.0)(@swc/helpers@0.5.15)(eslint@8.31.0) resend: specifier: ^3.2.0 version: 3.2.0 @@ -2749,6 +2761,11 @@ importers: packages: + 0x@5.8.0: + resolution: {integrity: sha512-d07ToyEoxGz/u8JbaqeivEr3b2X6sPil6IDBINrXKBkgveiTW30EfjwDtHmE0TvP5Y4p5vE7ErbK3p68kYE0aw==} + engines: {node: '>=8.5.0'} + hasBin: true + '@adobe/css-tools@4.4.0': resolution: {integrity: sha512-Ff9+ksdQQB3rMncgqDK78uLznstjyfIf2Arnh22pW8kBpLs6rpKDwgnZT46hin5Hl1WzazzK64DOrhSwYpS7bQ==} @@ -3014,6 +3031,9 @@ packages: resolution: {integrity: sha512-UQFQ6SgyJ6LX42W8rHCs8KVc0JS0tzVL9ct4XYedJukskYVWTo49tNiMEK9C2HTyarbNiT/RVIRSY82vH+6sTg==} engines: {node: '>=4'} + '@assemblyscript/loader@0.19.23': + resolution: {integrity: sha512-ulkCYfFbYj01ie1MDOyxv2F6SpRN1TOj7fQxbP07D6HmeR+gr2JLSmINKjga2emB+b1L2KGrFKBTc+e00p54nw==} + '@aws-crypto/crc32@3.0.0': resolution: {integrity: sha512-IzSgsrxUcsrejQbPVilIKy16kAT52EwB6zSaI+M3xxIhKh5+aldEyvI+z6erM7TCLB2BJsFrtHjp6/4/sr+3dA==} @@ -3998,6 +4018,32 @@ packages: resolution: {integrity: sha512-7ORY85rphRazqHzImNXMrh4vsaPrpetFoTWpZYueCO2bbO6PXYDXp/GQ4DgxnGIqbWB/Di1Ai+Xuwq2o7DJ36A==} engines: {node: '>=16'} + '@clinic/bubbleprof@10.0.0': + resolution: {integrity: sha512-7Y0uYO4cz7+Y1advV891uMJLXbZMIriLsV1IHSSVJxmf8tEFm8vogKi/GdYyi4CY0D5heuqOFze/WNrv+U3LRw==} + + '@clinic/clinic-common@7.1.0': + resolution: {integrity: sha512-+e/g1foFFtBqHKc0A9mZkFgH+DiijCT3ZojALGLOgdkzBY3Pun+Oj/FET5xvQWDtJ4RiXWAq4J+odza0NK0aWQ==} + engines: {node: '>= 12.13.0'} + + '@clinic/doctor@11.0.0': + resolution: {integrity: sha512-sfi3etIHDdrziWcG1fOB2XSNIbA+jwnoFNcCwYQxkYG3vh1QUajTur4lZ27YfV1ZsjzLNZAYxV0fOdUin/NJAg==} + + '@clinic/flame@13.0.0': + resolution: {integrity: sha512-3e//olko8YNl0aEUlzVJZybvmIXsmGuwMDxUlF7MKifCes8PICCusTHvuQ1AEIBvP73czbSLrE0xM4lUTWMYpg==} + + '@clinic/heap-profiler@5.0.0': + resolution: {integrity: sha512-1sAU3GuLk6mXGzMn6JGou6bMzP5vTpieZRgk0LVlauVDxq1+vxgiDrSO9Rn0IxHS7spMnHhOB/DigKFY6oci7Q==} + + '@clinic/node-trace-log-join@2.0.0': + resolution: {integrity: sha512-oOXf4Qavmawsg3YCRiGiAwnn8ENItMvfCiXS9sgEk8Iox5pToNRE1hwLwCfn/x2VL8FzJUiJtIcgGA6fJST91Q==} + hasBin: true + + '@clinic/trace-events-parser@2.0.0': + resolution: {integrity: sha512-hXpT4xJED7kW0+BNCSNSFNlYZO0xMYIBbx/lM8kbyW50SemOCk7JP0wEbmYpHNiW1wKT6ICuFaOK742R/w0vTQ==} + + '@codemirror/autocomplete@6.19.1': + resolution: {integrity: sha512-q6NenYkEy2fn9+JyjIxMWcNjzTL/IhwqfzOut1/G3PrIFkrbl4AL7Wkse5tLrQUUyqGoAKU5+Pi5jnnXxH5HGw==} + '@codemirror/autocomplete@6.4.0': resolution: {integrity: sha512-HLF2PnZAm1s4kGs30EiqKMgD7XsYaQ0XJnMR0rofEWQ5t5D60SfqpDIkIh1ze5tiEbyUWm8+VJ6W1/erVvBMIA==} peerDependencies: @@ -5585,9 +5631,6 @@ packages: resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==} engines: {node: '>=6.0.0'} - '@jridgewell/source-map@0.3.11': - resolution: {integrity: sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==} - '@jridgewell/source-map@0.3.3': resolution: {integrity: sha512-b+fsZXeLYi9fEULmfBrhxn4IrPlINf8fiNarzTof004v3lFdntdwa9PF7vFJqm3mg7s+ScJMxXaE3Acp1irZcg==} @@ -5698,6 +5741,10 @@ packages: engines: {node: '>= 14'} deprecated: too old + '@nearform/heap-profiler@2.0.0': + resolution: {integrity: sha512-846CWyq3Ky5rzcl8Z3S+VT3z6GQSlYD1G/dqbtANu29NUHoCO+W7tOZRK6eA6FjLHnNX0DvP1Mrt2oFBPnkxLw==} + engines: {node: '>= 12.13.0'} + '@neondatabase/serverless@0.9.5': resolution: {integrity: sha512-siFas6gItqv6wD/pZnvdu34wEqgG3nSE6zWZdq5j2DEsa+VvX8i/5HXJOo06qrw5axPXn+lGCxeR+NLaSPIXug==} @@ -10250,6 +10297,16 @@ packages: '@team-plain/typescript-sdk@3.5.0': resolution: {integrity: sha512-9kweiSlYAN31VI7yzILGxdlZqsGJ+FmCEfXyEZ/0/i3r6vOwq45FDqtjadnQJVtFm+rf/8vCFRN+wEYMIEv6Aw==} + '@tensorflow/tfjs-backend-cpu@3.21.0': + resolution: {integrity: sha512-88S21UAdzyK0CsLUrH17GPTD+26E85OP9CqmLZslaWjWUmBkeTQ5Zqyp6iK+gELnLxPx6q7JsNEeFuPv4254lQ==} + engines: {yarn: '>= 1.3.2'} + peerDependencies: + '@tensorflow/tfjs-core': 3.21.0 + + '@tensorflow/tfjs-core@3.21.0': + resolution: {integrity: sha512-YSfsswOqWfd+M4bXIhT3hwtAb+IV8+ODwIxwdFR/7jTAPZP1wMVnSlpKnXHAN64HFOiP+Tm3HmKusEZ0+09A0w==} + engines: {yarn: '>= 1.3.2'} + '@testcontainers/postgresql@10.28.0': resolution: {integrity: sha512-NN25rruG5D4Q7pCNIJuHwB+G85OSeJ3xHZ2fWx0O6sPoPEfCYwvpj8mq99cyn68nxFkFYZeyrZJtSFO+FnydiA==} @@ -10551,6 +10608,9 @@ packages: '@types/lodash@4.14.191': resolution: {integrity: sha512-BdZ5BCCvho3EIXw6wUCXHe7rS53AIDPLE+JzwgT+OsJk53oBfbSmZZ7CX4VaRoN78N+TJpFi9QPlfIVNmJYWxQ==} + '@types/long@4.0.2': + resolution: {integrity: sha512-MqTGEo5bj5t157U6fA/BiDynNkn0YknVdh48CMPkTSpFTVmvao5UQmm7uEF6xBEo7qIMAlY/JSleYaE6VOdpaA==} + '@types/marked@4.0.8': resolution: {integrity: sha512-HVNzMT5QlWCOdeuBsgXP8EZzKUf0+AXzN+sLmjvaB3ZlLqO+e4u0uXrdw9ub69wBKFs+c6/pA4r9sy6cCDvImw==} @@ -10617,6 +10677,9 @@ packages: '@types/object-hash@3.0.6': resolution: {integrity: sha512-fOBV8C1FIu2ELinoILQ+ApxcUKz4ngq+IWUYrxSGjXzzjUALijilampwkMgEtJ+h2njAW3pi853QpzNVCHB73w==} + '@types/offscreencanvas@2019.3.0': + resolution: {integrity: sha512-esIJx9bQg+QYF0ra8GnvfianIY8qWB0GBx54PK5Eps6m+xTj86KLavHv6qDhzKcu5UUOgNfJ2pWaIIV7TRUd9Q==} + '@types/pg-pool@2.0.6': resolution: {integrity: sha512-TaAUE5rq2VQYxab5Ts7WZhKNmuN78Q6PiFonTDdpbx8a1H0M1vhy3rhiMjl+e2iHmogyMw7jZF4FrE6eJUy5HQ==} @@ -10698,6 +10761,9 @@ packages: '@types/scheduler@0.16.2': resolution: {integrity: sha512-hppQEBDmlwhFAXKJX2KnWLYu5yMfi91yazPb2l+lbJiwW+wdo1gNeRA+3RgNSO39WYX2euey41KEwnqesU2Jew==} + '@types/seedrandom@2.4.34': + resolution: {integrity: sha512-ytDiArvrn/3Xk6/vtylys5tlY6eo7Ane0hvcx++TKo6RxQXuVfW0AF/oeWqAj9dN29SyhtawuXstgmPlwNcv/A==} + '@types/seedrandom@3.0.8': resolution: {integrity: sha512-TY1eezMU2zH2ozQoAFAQFOPpvP15g+ZgSfTZt31AUUH/Rxtnz3H+A/Sv1Snw2/amp//omibc+AEkTaA8KUeOLQ==} @@ -10770,6 +10836,9 @@ packages: '@types/uuid@9.0.0': resolution: {integrity: sha512-kr90f+ERiQtKWMz5rP32ltJ/BtULDI5RVO0uavn1HQUOwjx0R1h0rnDYNL0CepF1zL5bSY6FISAfd9tOdDhU5Q==} + '@types/webgl-ext@0.0.30': + resolution: {integrity: sha512-LKVgNmBxN0BbljJrVUwkxwRYqzsAEPcZOe6S2T6ZaBDIrFp0qu4FNlpc5sM1tGbXUYFgdVQIoeLk1Y1UoblyEg==} + '@types/webpack@5.28.5': resolution: {integrity: sha512-wR87cgvxj3p6D0Crt1r5avwqffqPXUkNlnQ1mjU93G7gCuFjufZR4I6j8cz5g1F1tTYpfOOFvly+cmIQwL9wvw==} @@ -11101,6 +11170,9 @@ packages: '@webassemblyjs/wast-printer@1.14.1': resolution: {integrity: sha512-kPSSXE6De1XOR820C90RIo2ogvZG+c3KiHzqUoO/F34Y2shGzesfqv7o57xrxovZJH/MetF5UjroJ/R/3isoiw==} + '@webgpu/types@0.1.16': + resolution: {integrity: sha512-9E61voMP4+Rze02jlTXud++Htpjyyk8vw5Hyw9FGRrmhHQg2GqbuOfwf5Klrb8vTxc2XWI3EfO7RUHMpxTj26A==} + '@whatwg-node/events@0.1.1': resolution: {integrity: sha512-AyQEn5hIPV7Ze+xFoXVU3QTHXVbWPrzaOkxtENMPMuNL6VVHrp4hHfDt9nrQpjO7BgvuM95dMtkycX5M/DZR3w==} engines: {node: '>=16.0.0'} @@ -11142,6 +11214,10 @@ packages: '@zxing/text-encoding@0.9.0': resolution: {integrity: sha512-U/4aVJ2mxI0aDNI8Uq0wEhMgY+u4CNtEb0om3+y3+niDAsoTCOB33UF0sxpzqzdqXLqmvc+vZyAt4O8pPdfkwA==} + JSONStream@1.3.5: + resolution: {integrity: sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==} + hasBin: true + abbrev@2.0.0: resolution: {integrity: sha512-6/mh1E2u2YgEsCHdY0Yx5oW+61gZU+1vXaoiHHrpKeuRNNgFvS+/jrwHiQhB5apAf5oB7UB7E19ol2R2LKH8hQ==} engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} @@ -11334,14 +11410,33 @@ packages: ajv@8.17.1: resolution: {integrity: sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==} + ansi-align@3.0.1: + resolution: {integrity: sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==} + ansi-colors@4.1.3: resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==} engines: {node: '>=6'} + ansi-escapes@3.2.0: + resolution: {integrity: sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==} + engines: {node: '>=4'} + ansi-escapes@7.0.0: resolution: {integrity: sha512-GdYO7a61mR0fOlAsvC9/rIHf7L96sBc6dEWzeOu+KAea5bZyQRPIpojrVoI4AXGJS/ycu/fBTdLrUkA4ODrvjw==} engines: {node: '>=18'} + ansi-regex@2.1.1: + resolution: {integrity: sha512-TIGnTpdo+E3+pCyAluZvtED5p5wCqLdezCyhPZzKPcxvFplEt4i+W7OONCKgeZFT3+y5NZZfOOS/Bdcanm1MYA==} + engines: {node: '>=0.10.0'} + + ansi-regex@3.0.1: + resolution: {integrity: sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==} + engines: {node: '>=4'} + + ansi-regex@4.1.1: + resolution: {integrity: sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==} + engines: {node: '>=6'} + ansi-regex@5.0.1: resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==} engines: {node: '>=8'} @@ -11350,6 +11445,10 @@ packages: resolution: {integrity: sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==} engines: {node: '>=12'} + ansi-styles@2.2.1: + resolution: {integrity: sha512-kmCevFghRiWM7HB5zTPULl4r9bVFSWjz62MhqizDGUrq2NWuNMQyuv4tHHoKJHs69M/MF64lEcHdYIocrdWQYA==} + engines: {node: '>=0.10.0'} + ansi-styles@3.2.1: resolution: {integrity: sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==} engines: {node: '>=4'} @@ -11376,6 +11475,9 @@ packages: any-promise@1.3.0: resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==} + any-shell-escape@0.1.1: + resolution: {integrity: sha512-36j4l5HVkboyRhIWgtMh1I9i8LTdFqVwDEHy1cp+QioJyKgAUG40X0W8s7jakWRta/Sjvm8mUG1fU6Tj8mWagQ==} + anymatch@3.1.3: resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==} engines: {node: '>= 8'} @@ -11422,6 +11524,12 @@ packages: array-flatten@1.1.1: resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==} + array-flatten@3.0.0: + resolution: {integrity: sha512-zPMVc3ZYlGLNk4mpK1NzP2wg0ml9t7fUgDsayR5Y5rSzxQilzR9FGu/EH2jQOcKSAeAfWeylyW8juy3OkWRvNA==} + + array-from@2.1.1: + resolution: {integrity: sha512-GQTc6Uupx1FCavi5mPzBvVT7nEOeWMmUA9P95wpfpW1XwMSKs+KaymD5C2Up7KAUKg/mYwbsUYzdZWcoajlNZg==} + array-includes@3.1.6: resolution: {integrity: sha512-sgTbLvL6cNnw24FnbaDyjmvddQ2ML8arZsgaJhoABMoplz/4QRhtrYS+alr1BUM1Bwp6dhx8vVCBSLG+StwOFw==} engines: {node: '>= 0.4'} @@ -11472,6 +11580,9 @@ packages: asap@2.0.6: resolution: {integrity: sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==} + asn1.js@4.10.1: + resolution: {integrity: sha512-p32cOF5q0Zqs9uBiONKYLm6BClCoBCM5O9JfeUSlnQLBTxYdTK+pW+nXflm8UkKd2UYlEbYz5qEi0JuZR9ckSw==} + asn1@0.2.6: resolution: {integrity: sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==} @@ -11482,6 +11593,9 @@ packages: resolution: {integrity: sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==} engines: {node: '>=0.8'} + assert@1.5.1: + resolution: {integrity: sha512-zzw1uCAgLbsKwBfFc8CX78DDg+xZeBksSO3vwVIDDN5i94eOrPsSSyiVhmsSABFDM/OcpE2aagCat9dnWQLG1A==} + assertion-error@2.0.1: resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==} engines: {node: '>=12'} @@ -11504,6 +11618,9 @@ packages: async-lock@1.4.1: resolution: {integrity: sha512-Az2ZTpuytrtqENulXwO3GGv1Bztugx6TT37NIo7imr/Qo0gsYiGtSdBa2B6fsXhTpVZDNfu1Qn3pk531e3q+nQ==} + async@2.6.4: + resolution: {integrity: sha512-mzo5dfJYwAn29PeiJ0zvwTo04zj8HDJj0Mn8TD7sno7q12prdbnasKJHhkm2c1LgrhlJ0teaea8860oxi51mGA==} + async@3.2.6: resolution: {integrity: sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==} @@ -11514,6 +11631,14 @@ packages: resolution: {integrity: sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==} engines: {node: '>=8.0.0'} + atomically@1.7.0: + resolution: {integrity: sha512-Xcz9l0z7y9yQ9rdDaxlmaI4uJHf/T8g9hOEzJcsEqX2SjCj4J20uK7+ldkDHMbpJDK76wF7xEIgxc/vSlsfw5w==} + engines: {node: '>=10.12.0'} + + autocannon@7.15.0: + resolution: {integrity: sha512-NaP2rQyA+tcubOJMFv2+oeW9jv2pq/t+LM6BL3cfJic0HEfscEcnWgAyU5YovE/oTHUzAgTliGdLPR+RQAWUbg==} + hasBin: true + autoevals@0.0.130: resolution: {integrity: sha512-JS0T/YCEH13AAOGiWWGJDkIPP8LsDmRBYr3EazTukHxvd0nidOW7fGj0qVPFx2bARrSNO9AfCR6xoTP/5m3Bmw==} @@ -11667,9 +11792,18 @@ packages: bintrees@1.0.2: resolution: {integrity: sha512-VOMgTMwjAaUG580SXn3LacVgjurrbMme7ZZNYGSSV7mmtY6QQRh0Eg3pwIcntQ77DErK1L0NxkbetjcoXzVwKw==} + bit-twiddle@1.0.2: + resolution: {integrity: sha512-B9UhK0DKFZhoTFcfvAzhqsjStvGJp9vYWf3+6SNTtdSQnvIgfkHbgHrg/e4+TH71N2GDu8tpmCVoyfrL1d7ntA==} + bl@4.1.0: resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==} + bn.js@4.12.2: + resolution: {integrity: sha512-n4DSx829VRTRByMRGdjQ9iqsN0Bh4OolPsFnaZBLcbi8iXcB+kJ9s7EnRt4wILZNV3kPLHkRVfOc/HvhC3ovDw==} + + bn.js@5.2.2: + resolution: {integrity: sha512-v2YAxEmKaBLahNwE1mjp4WON6huMNeuDvagFZW+ASCuA/ku0bXR9hSMw0XpiqMoA3+rmnyck/tPRSFQkoC9Cuw==} + body-parser@1.20.3: resolution: {integrity: sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==} engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} @@ -11687,6 +11821,10 @@ packages: bowser@2.12.1: resolution: {integrity: sha512-z4rE2Gxh7tvshQ4hluIT7XcFrgLIQaw9X3A+kTTRdovCz5PMukm/0QC/BKSYPj3omF5Qfypn9O/c5kgpmvYUCw==} + boxen@5.1.2: + resolution: {integrity: sha512-9gYgQKXx+1nP8mP7CzFyaUARhg7D3n1dF/FnErWmu9l6JvGpNUN278h0aSb+QjoiKSWG+iZ3uHrcqk0qrY9RQQ==} + engines: {node: '>=10'} + brace-expansion@1.1.11: resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==} @@ -11700,9 +11838,51 @@ packages: breakword@1.0.5: resolution: {integrity: sha512-ex5W9DoOQ/LUEU3PMdLs9ua/CYZl1678NUkKOdUSi8Aw5F1idieaiRURCBFJCwVcrD1J8Iy3vfWSloaMwO2qFg==} + brfs@2.0.2: + resolution: {integrity: sha512-IrFjVtwu4eTJZyu8w/V2gxU7iLTtcHih67sgEdzrhjLBMHp2uYefUBfdM4k2UvcuWMgV7PQDZHSLeNWnLFKWVQ==} + hasBin: true + + brorand@1.1.0: + resolution: {integrity: sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w==} + + browser-pack@6.1.0: + resolution: {integrity: sha512-erYug8XoqzU3IfcU8fUgyHqyOXqIE4tUTTQ+7mqUjQlvnXkOO6OlT9c/ZoJVHYoAaqGxr09CN53G7XIsO4KtWA==} + hasBin: true + + browser-process-hrtime@0.1.3: + resolution: {integrity: sha512-bRFnI4NnjO6cnyLmOV/7PVoDEMJChlcfN0z4s1YMBY989/SvlfMI1lgCnkFUs53e9gQF+w7qu7XdllSTiSl8Aw==} + + browser-resolve@2.0.0: + resolution: {integrity: sha512-7sWsQlYL2rGLy2IWm8WL8DCTJvYLc/qlOnsakDac87SOoCd16WLsaAMdCiAqsTNHIe+SXfaqyxyo6THoWqs8WQ==} + + browserify-aes@1.2.0: + resolution: {integrity: sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==} + + browserify-cipher@1.0.1: + resolution: {integrity: sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==} + + browserify-des@1.0.2: + resolution: {integrity: sha512-BioO1xf3hFwz4kc6iBhI3ieDFompMhrMlnDFC4/0/vd5MokpuAc3R+LYbwTA9A5Yc9pq9UYPqffKpW2ObuwX5A==} + + browserify-rsa@4.1.1: + resolution: {integrity: sha512-YBjSAiTqM04ZVei6sXighu679a3SqWORA3qZTEqZImnlkDIFtKc6pNutpjyZ8RJTjQtuYfeetkxM11GwoYXMIQ==} + engines: {node: '>= 0.10'} + + browserify-sign@4.2.5: + resolution: {integrity: sha512-C2AUdAJg6rlM2W5QMp2Q4KGQMVBwR1lIimTsUnutJ8bMpW5B52pGpR2gEnNBNwijumDo5FojQ0L9JrXA8m4YEw==} + engines: {node: '>= 0.10'} + browserify-zlib@0.1.4: resolution: {integrity: sha512-19OEpq7vWgsH6WkvkBJQDFvJS1uPcbFOQ4v9CU839dO+ZZXUZO6XpE6hNCqvlIIj+4fZvRiJ6DsAQ382GwiyTQ==} + browserify-zlib@0.2.0: + resolution: {integrity: sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==} + + browserify@17.0.1: + resolution: {integrity: sha512-pxhT00W3ylMhCHwG5yfqtZjNnFuX5h2IJdaBfSo4ChaaBsIp9VLrEMQ1bHV+Xr1uLPXuNDDM1GlJkjli0qkRsw==} + engines: {node: '>= 0.8'} + hasBin: true + browserslist@4.21.4: resolution: {integrity: sha512-CBHJJdDmgjl3daYjN5Cp5kbTf1mUhZoS+beLklHIvkOWscs83YAhLlF3Wsh/lciQYAcbBJgTOD44VtG31ZM4Hw==} engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} @@ -11731,9 +11911,19 @@ packages: buffer-equal-constant-time@1.0.1: resolution: {integrity: sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==} + buffer-equal@0.0.1: + resolution: {integrity: sha512-RgSV6InVQ9ODPdLWJ5UAqBqJBOg370Nz6ZQtRzpt6nUjc8v0St97uJ4PYC6NztqIScrAXafKM3mZPMygSe1ggA==} + engines: {node: '>=0.4.0'} + buffer-from@1.1.2: resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} + buffer-xor@1.0.3: + resolution: {integrity: sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ==} + + buffer@5.2.1: + resolution: {integrity: sha512-c+Ko0loDaFfuPWiL02ls9Xd3GO3cPVmUobQ6t3rXNUk304u6hGq+8N/kFi+QEIKhzK3uwolVhLzszmfLmMLnqg==} + buffer@5.7.1: resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==} @@ -11748,6 +11938,9 @@ packages: resolution: {integrity: sha512-8f9ZJCUXyT1M35Jx7MkBgmBMo3oHTTBIPLiY9xyL0pl3T5RwcPEY8cUHr5LBNfu/fk6c2T4DJZuVM/8ZZT2D2A==} engines: {node: '>=10.0.0'} + builtin-status-codes@3.0.0: + resolution: {integrity: sha512-HpGFw18DgFWlncDfjTa2rcQ4W88O1mC8e8yZ2AvQY5KDaktSTwo+KRf6nHK6FRI5FyRyb/5T6+TSxfP7QyGsmQ==} + builtins@1.0.3: resolution: {integrity: sha512-uYBjakWipfaO/bXI7E8rq6kpwHRZK5cNYrUv2OzZSI/FvmdMyXJ2tG9dKcjEC5YHmHpUAwsargWIZNWdxb/bnQ==} @@ -11811,6 +12004,9 @@ packages: resolution: {integrity: sha512-Oj3cAGPCqOZX7Rz64Uny2GYAZNliQSqfbePrgAQ1wKAihYmCUnraBtJtKcGR4xz7wF+LoJC+ssFZvv5BgF9Igg==} engines: {node: '>=8'} + cached-path-relative@1.1.0: + resolution: {integrity: sha512-WF0LihfemtesFcJgO7xfOoOcnWzY/QHR4qeDqV44jPU3HTI54+LnfXK3SA27AVVGCdZFgjjFFaqUA9Jx7dMJZA==} + call-bind-apply-helpers@1.0.2: resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==} engines: {node: '>= 0.4'} @@ -11831,6 +12027,9 @@ packages: resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} engines: {node: '>=6'} + camel-case@3.0.0: + resolution: {integrity: sha512-+MbKztAYHXPr1jNTSKQF52VpcFjwY5RkR7fxksV8Doo4KAYc5Fl4UJRgthBbTmEx8C54DqahhbLJkDwjI3PI/w==} + camelcase-css@2.0.1: resolution: {integrity: sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==} engines: {node: '>= 6'} @@ -11843,6 +12042,10 @@ packages: resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==} engines: {node: '>=6'} + camelcase@6.3.0: + resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==} + engines: {node: '>=10'} + caniuse-lite@1.0.30001577: resolution: {integrity: sha512-rs2ZygrG1PNXMfmncM0B5H1hndY5ZCC9b5TkFaVNfZ+AUlyqcMyVIQtc3fsezi0NUCk5XZfDf9WS6WxMxnfdrg==} @@ -11865,10 +12068,17 @@ packages: ccount@2.0.1: resolution: {integrity: sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==} + cephes@2.0.0: + resolution: {integrity: sha512-4GMUzkcXHZ0HMZ3gZdBrv8pQs1/zkJh2Q9rQOF8NJZHanM359y3XOSdeqmDBPfxQKYQpJt58R3dUpofrIXJ2mg==} + chai@5.2.0: resolution: {integrity: sha512-mCuXncKXk5iCLhfhwTc0izo0gtEmpz5CtG2y8GiOINBlMVS6v8TMRc5TaLWKS6692m9+dVVfzgeVxR5UxWHTYw==} engines: {node: '>=12'} + chalk@1.1.3: + resolution: {integrity: sha512-U3lRVLMSlsCfjqYPbLyVv11M9CPW4I728d6TCKMAOJueEeB9/8o+eSsMnxPJD+Q+K909sdESg7C+tIkoH6on1A==} + engines: {node: '>=0.10.0'} + chalk@2.4.2: resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==} engines: {node: '>=4'} @@ -11893,6 +12103,9 @@ packages: resolution: {integrity: sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==} engines: {node: '>=10'} + char-spinner@1.0.1: + resolution: {integrity: sha512-acv43vqJ0+N0rD+Uw3pDHSxP30FHrywu2NO6/wBaHChJIizpDeBUd6NjqhNhy9LGaEAhZAXn46QzmlAvIWd16g==} + character-entities-html4@2.1.0: resolution: {integrity: sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==} @@ -11959,10 +12172,17 @@ packages: peerDependencies: devtools-protocol: '*' + ci-info@2.0.0: + resolution: {integrity: sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==} + ci-info@3.8.0: resolution: {integrity: sha512-eXTggHWSooYhq49F2opQhuHWgzucfF2YgODK4e1566GQs5BIfP30B0oenwBJHfWxAs2fyPB1s7Mg949zLf61Yw==} engines: {node: '>=8'} + cipher-base@1.0.7: + resolution: {integrity: sha512-Mz9QMT5fJe7bKI7MH31UilT5cEK5EHHRCccw/YRFsRY47AuNgaV6HY3rscp0/I4Q+tTW/5zoqpSeRRI54TkDWA==} + engines: {node: '>= 0.10'} + citty@0.1.6: resolution: {integrity: sha512-tskPPKEs8D2KPafUypv2gxwJP8h/OaJmC82QQGGDQcHvXX43xF2VDACcJVmZ0EuSxkpO9Kc4MlrA3q0+FG58AQ==} @@ -11991,6 +12211,14 @@ packages: resolution: {integrity: sha512-LYv6XPxoyODi36Dp976riBtSY27VmFo+MKqEU9QCCWyTrdEPDog+RWA7xQWHi6Vbp61j5c4cdzzX1NidnwtUWg==} engines: {node: '>=12'} + cli-boxes@2.2.1: + resolution: {integrity: sha512-y4coMcylgSCdVinjiDBuR8PCC2bLjyGTwEmPb9NHR/QaNU6EUOXcTY/s6VjGMD6ENSEaeQYHCY0GNGS5jfMwPw==} + engines: {node: '>=6'} + + cli-cursor@2.1.0: + resolution: {integrity: sha512-8lgKz8LmCRYZZQDpRyT2m5rKJ08TnU4tR9FFFW2rxpxR1FzWi4PQ/NfyODchAatHaUgnSPVcx/R5w6NuTBzFiw==} + engines: {node: '>=4'} + cli-cursor@3.1.0: resolution: {integrity: sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==} engines: {node: '>=8'} @@ -12012,9 +12240,22 @@ packages: resolution: {integrity: sha512-+W/5efTR7y5HRD7gACw9yQjqMVvEMLBHmboM/kPWam+H+Hmyrgjh6YncVKK122YZkXrLudzTuAukUw9FnMf7IQ==} engines: {node: 10.* || >= 12.*} + cli-width@2.2.1: + resolution: {integrity: sha512-GRMWDxpOB6Dgk2E5Uo+3eEBvtOOlimMmpbFiKuLFnQzYDavtLFY3K5ona41jgN/WdRZtG7utuVSVTL4HbZHGkw==} + client-only@0.0.1: resolution: {integrity: sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==} + clinic@13.0.0: + resolution: {integrity: sha512-QAD3cLgA1OqEC7fJSDbAt4U0BKGAK1c5yopN5tu1OtmmsbRHHYxBeSMiElQfuMMdbkAuLEE7HOffZ0hKMzaYVw==} + hasBin: true + + clipboard-copy@4.0.1: + resolution: {integrity: sha512-wOlqdqziE/NNTUJsfSgXmBMIrYmfd5V0HCGsR8uAKHcg+h9NENWINcfRjtWGU77wDHC8B8ijV4hMTGYbrKovng==} + + cliui@5.0.0: + resolution: {integrity: sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==} + cliui@6.0.0: resolution: {integrity: sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==} @@ -12052,6 +12293,10 @@ packages: resolution: {integrity: sha512-RMr0FhtfXemyinomL4hrWcYJxmX6deFdCxpJzhDttxgO1+bcCnkk+9drydLVDmAMG7NE6aN/fl4F7ucU/90gAA==} engines: {node: '>=0.10.0'} + code-point-at@1.1.0: + resolution: {integrity: sha512-RpAVKQA5T63xEj6/giIbUEtZwJ4UFIc3ZtvEkiaUERylqe8xb5IvqcgOurZLahv93CLKfxcw5YI+DZcUBRyLXA==} + engines: {node: '>=0.10.0'} + codemirror@6.0.2: resolution: {integrity: sha512-VhydHotNW5w1UGK0Qj96BwSk/Zqbp9WbnyK2W/eVMv4QyF41INRGpjUhFJY7/uDNuudSc33a/PKr4iDqRduvHw==} @@ -12071,6 +12316,10 @@ packages: color-string@1.9.1: resolution: {integrity: sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==} + color-support@1.1.3: + resolution: {integrity: sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==} + hasBin: true + color@3.2.1: resolution: {integrity: sha512-aBl7dZI9ENN6fUGC7mWpMTPNHmWUSNan9tuWN6ahh5ZLNk9baLJOnSMlrQkHcrfFgz2/RigjUVAjdx36VcemKA==} @@ -12078,6 +12327,9 @@ packages: resolution: {integrity: sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==} engines: {node: '>=12.5.0'} + combine-source-map@0.8.0: + resolution: {integrity: sha512-UlxQ9Vw0b/Bt/KYwCFqdEwsQ1eL8d1gibiFb7lxQJFdvTgc2hIZi6ugsg+kyhzhPV+QEpUiEIwInIAIrgoEkrg==} + combined-stream@1.0.8: resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} engines: {node: '>= 0.8'} @@ -12116,6 +12368,9 @@ packages: resolution: {integrity: sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==} engines: {node: ^12.20.0 || >=14} + commist@1.1.0: + resolution: {integrity: sha512-rraC8NXWOEjhADbZe9QBNzLAN5Q3fsTPQtBV+fEVj6xKIgDgNiEVE6ZNfHpZOqfQ21YUzfVNUXLOEZquYvQPPg==} + compare-versions@6.1.1: resolution: {integrity: sha512-4hm4VPpIecmlg59CHXnRDnqGplJFrbLG4aFEl5vl6cK1u76ws3LLvX7ikFnTDl5vo39sjWD6AaDPYodJp/NNHg==} @@ -12146,6 +12401,18 @@ packages: concat-map@0.0.1: resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} + concat-stream@1.6.2: + resolution: {integrity: sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==} + engines: {'0': node >= 0.8} + + concat-stream@2.0.0: + resolution: {integrity: sha512-MWufYdFw53ccGjCA+Ol7XJYpAlW6/prSMzuPOTRnJGcGzuhLn4Scrz7qf6o8bROZ514ltazcIFJZevcfbo0x7A==} + engines: {'0': node >= 6.0} + + conf@10.2.0: + resolution: {integrity: sha512-8fLl9F04EJqjSqH+QjITQfJF8BrOVaYr1jewVgSRAEWePfxT0sku4w2hrGQ60BC/TNLGQ2pgxNlTbWQmMPFvXg==} + engines: {node: '>=12'} + confbox@0.1.8: resolution: {integrity: sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==} @@ -12155,10 +12422,20 @@ packages: config-chain@1.1.13: resolution: {integrity: sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==} + configstore@5.0.1: + resolution: {integrity: sha512-aMKprgk5YhBNyH25hj8wGt2+D52Sw1DRRIzqBwLp2Ya9mFmY8KPvvtvmna8SxVR9JMZ4kzMD68N22vlaRpkeFA==} + engines: {node: '>=8'} + consola@3.4.2: resolution: {integrity: sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==} engines: {node: ^14.18.0 || >=16.10.0} + console-browserify@1.2.0: + resolution: {integrity: sha512-ZMkYO/LkF17QvCPqM0gxw8yUzigAOZOSWSHg91FH6orS7vcEj5dVZTidN2fQ14yBSdg97RqhSNwLUXInd52OTA==} + + constants-browserify@1.0.0: + resolution: {integrity: sha512-xFxOwqIzR/e1k1gLiWEophSCMqXcwVHIH7akf7b/vxcUeGunlj3hvZaaqxwHsTgn+IndtkQJgSztIDWeumWJDQ==} + content-disposition@0.5.4: resolution: {integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==} engines: {node: '>= 0.6'} @@ -12171,6 +12448,9 @@ packages: resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==} engines: {node: '>= 0.6'} + convert-source-map@1.1.3: + resolution: {integrity: sha512-Y8L5rp6jo+g9VEPgvqNfEopjTR4OTYct8lXlS8iVQdmnjDvbdbzYe9rjtFCB9egC86JoNCU61WRY+ScjkZpnIg==} + convert-source-map@1.9.0: resolution: {integrity: sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==} @@ -12271,6 +12551,18 @@ packages: resolution: {integrity: sha512-piICUB6ei4IlTv1+653yq5+KoqfBYmj9bw6LqXoOneTMDXk5nM1qt12mFW1caG3LlJXEKW1Bp0WggEmIfQB34g==} engines: {node: '>= 14'} + create-ecdh@4.0.4: + resolution: {integrity: sha512-mf+TCx8wWc9VpuxfP2ht0iSISLZnt0JgWlrOKZiNqyUZWnjIaCIVNQArMHnCZKfEYRg6IM7A+NeJoN8gf/Ws0A==} + + create-hash@1.2.0: + resolution: {integrity: sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==} + + create-hmac@1.1.7: + resolution: {integrity: sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==} + + crelt@1.0.5: + resolution: {integrity: sha512-+BO9wPPi+DWTDcNYhr/W90myha8ptzftZT+LwcmUbbok0rcP/fequmFYCw8NMoH7pkAZQzU78b3kYrlua5a9eA==} + crelt@1.0.6: resolution: {integrity: sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g==} @@ -12287,6 +12579,12 @@ packages: deprecated: Non-backwards compatible Breaking changes hasBin: true + cross-argv@1.0.0: + resolution: {integrity: sha512-uAVe/bgNHlPdP1VE4Sk08u9pAJ7o1x/tVQtX77T5zlhYhuwOWtVkPBEtHdvF5cq48VzeCG5i1zN4dQc8pwLYrw==} + + cross-argv@2.0.0: + resolution: {integrity: sha512-YIaY9TR5Nxeb8SMdtrU8asWVM4jqJDNDYlKV21LxtYcfNJhp1kEsgSa6qXwXgzN0WQWGODps0+TlGp2xQSHwOg==} + cross-env@7.0.3: resolution: {integrity: sha512-+/HKd6EgcQCJGh2PSjZuUitQBQynKor4wrFbRg4DtAgS1aWO+gU52xpH7M9ScGgXSYmAVS9bIJ8EzuaGw0oNAw==} engines: {node: '>=10.14', npm: '>=6', yarn: '>=1'} @@ -12307,12 +12605,20 @@ packages: resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==} engines: {node: '>= 8'} + crypto-browserify@3.12.1: + resolution: {integrity: sha512-r4ESw/IlusD17lgQi1O20Fa3qNnsckR126TdUuBgAu7GBYSIPvdNyONd3Zrxh0xCwA4+6w/TDArBPsMvhur+KQ==} + engines: {node: '>= 0.10'} + crypto-js@4.1.1: resolution: {integrity: sha512-o2JlM7ydqd3Qk9CA0L4NL6mTzU2sdx96a+oOfPu8Mkl/PK51vSyoi8/rQ8NknZtk44vq15lmhAj9CIAGwgeWKw==} crypto-js@4.2.0: resolution: {integrity: sha512-KALDyEYgpY+Rlob/iriUtjV6d5Eq+Y191A5g4UqLAi8CyGP9N1+FdVbkc1SxKc2r4YAYqG8JzO2KGL+AizD70Q==} + crypto-random-string@2.0.0: + resolution: {integrity: sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==} + engines: {node: '>=8'} + css-in-js-utils@3.1.0: resolution: {integrity: sha512-fJAcud6B3rRu+KHYk+Bwf+WFL2MDCJJ1XG9x137tJQ0xYxor7XziQtuGFbWNdqrvF4Tk26O3H73nfVqXt/fW1A==} @@ -12373,6 +12679,9 @@ packages: resolution: {integrity: sha512-xiEMER6E7TlTPnDxrM4eRiC6TRgjNX9xzEZ5U/Se2YJKr7Mq4pJn/2XEHjl3STcSh96GmkHPcBXLES8M29wyyg==} deprecated: Cuid and other k-sortable and non-cryptographic ids (Ulid, ObjectId, KSUID, all UUIDs) are all insecure. Use @paralleldrive/cuid2 instead. + cwise-compiler@1.1.3: + resolution: {integrity: sha512-WXlK/m+Di8DMMcCjcWr4i+XzcQra9eCdXIJrgh4TUgh0pIS/yJduLxS9JgefsHJ/YVLdgPtXm9r62W92MvanEQ==} + cytoscape-cose-bilkent@4.1.0: resolution: {integrity: sha512-wgQlVIUJF13Quxiv5e1gstZ08rnZj2XaLHGoFMYXz7SkNfCDOOteKBE6SYRfA9WxxI/iBc3ajfDoc6hb/MRAHQ==} peerDependencies: @@ -12394,6 +12703,9 @@ packages: resolution: {integrity: sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==} engines: {node: '>=12'} + d3-axis@1.0.12: + resolution: {integrity: sha512-ejINPfPSNdGFKEOAtnBtdkpr24c4d4jsei6Lg98mxf424ivoDP2956/5HDpIAtmHo85lqT4pruy+zEgvRUBqaQ==} + d3-axis@3.0.0: resolution: {integrity: sha512-IH5tgjV4jE/GhHkRV0HiVYPDtvfjHQlQfJHs0usq7M30XcSBvOotpmH1IgkcXsO/5gEQZD43B//fc7SRT5S+xw==} engines: {node: '>=12'} @@ -12406,6 +12718,12 @@ packages: resolution: {integrity: sha512-VE5S6TNa+j8msksl7HwjxMHDM2yNK3XCkusIlpX5kwauBfXuyLAtNg9jCp/iHH61tgI4sb6R/EIMWCqEIdjT/g==} engines: {node: '>=12'} + d3-color@1.4.1: + resolution: {integrity: sha512-p2sTHSLCJI2QKunbGb7ocOh7DgTAn8IrLx21QRc/BSnodXM4sv6aLQlnfpvehFMLZEfBc6g9pH9SWQccFYfJ9Q==} + + d3-color@2.0.0: + resolution: {integrity: sha512-SPXi0TSKPD4g9tw0NMZFnR95XVgUZiBH+uUTqQuDu1OsE2zomHU7ho0FISciaPvosimixwHFl3WHLGabv6dDgQ==} + d3-color@3.1.0: resolution: {integrity: sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==} engines: {node: '>=12'} @@ -12418,10 +12736,16 @@ packages: resolution: {integrity: sha512-mdjtIZ1XLAM8bm/hx3WwjfHt6Sggek7qH043O8KEjDXN40xi3vx/6pYSVTwLjEgiXQTbvaouWKynLBiUZ6SK6A==} engines: {node: '>=12'} + d3-dispatch@1.0.6: + resolution: {integrity: sha512-fVjoElzjhCEy+Hbn8KygnmMS7Or0a9sI2UzGwoB7cCtvI1XpVN9GpoYlnb3xt2YV66oXYb1fLJ8GMvP4hdU1RA==} + d3-dispatch@3.0.1: resolution: {integrity: sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg==} engines: {node: '>=12'} + d3-drag@1.2.5: + resolution: {integrity: sha512-rD1ohlkKQwMZYkQlYVCrSFxsWPzI97+W+PaEIBNTMxRuxz9RF0Hi5nJWHGVJ3Om9d2fRTe1yOBINJyy/ahV95w==} + d3-drag@3.0.0: resolution: {integrity: sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg==} engines: {node: '>=12'} @@ -12431,6 +12755,9 @@ packages: engines: {node: '>=12'} hasBin: true + d3-ease@1.0.7: + resolution: {integrity: sha512-lx14ZPYkhNx0s/2HX5sLFUI3mbasHjSSpwO/KaaNACweVwxUruKyWVcb293wMv1RqTPZyZ8kSZ2NogUZNcLOFQ==} + d3-ease@3.0.1: resolution: {integrity: sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==} engines: {node: '>=12'} @@ -12439,10 +12766,19 @@ packages: resolution: {integrity: sha512-kpkQIM20n3oLVBKGg6oHrUchHM3xODkTzjMoj7aWQFq5QEM+R6E4WkzT5+tojDY7yjez8KgCBRoj4aEr99Fdqw==} engines: {node: '>=12'} + d3-fg@6.14.0: + resolution: {integrity: sha512-M4QpFZOEvAq4ZDzwabJp2inL+KXS85T2SQl00zWwjnolaCJR+gHxUbT7Ha4GxTeW1NXwzbykhv/38I1fxQqbyg==} + d3-force@3.0.0: resolution: {integrity: sha512-zxV/SsA+U4yte8051P4ECydjD/S+qeYtnaIyAs9tgHCqfguma/aAQDjo85A9Z6EKhBirHRJHXIgJUlffT4wdLg==} engines: {node: '>=12'} + d3-format@1.4.5: + resolution: {integrity: sha512-J0piedu6Z8iB6TbIGfZgDzfXxUFN3qQRMofy2oPdXzQibYGqPB/9iMcxr/TGalU+2RsyDO+U4f33id8tbnSRMQ==} + + d3-format@2.0.0: + resolution: {integrity: sha512-Ab3S6XuE/Q+flY96HXT0jOXcM4EAClYFnRGY5zsjRGNy6qCYrQsMffs7cV5Q9xejb35zxW5hf/guKw34kvIKsA==} + d3-format@3.1.0: resolution: {integrity: sha512-YyUI6AEuY/Wpt8KWLgZHsIU86atmikuoOmCfommt0LYHiQSPjvX2AcFc38PX0CBpr2RCyZhjex+NS/LPOv6YqA==} engines: {node: '>=12'} @@ -12451,10 +12787,19 @@ packages: resolution: {integrity: sha512-637ln3gXKXOwhalDzinUgY83KzNWZRKbYubaG+fGVuc/dxO64RRljtCTnf5ecMyE1RIdtqpkVcq0IbtU2S8j2Q==} engines: {node: '>=12'} + d3-hierarchy@1.1.9: + resolution: {integrity: sha512-j8tPxlqh1srJHAtxfvOUwKNYJkQuBFdM1+JAUfq6xqH5eAqf93L7oG1NVqDa4CpFZNvnNKtCYEUC8KY9yEn9lQ==} + d3-hierarchy@3.1.2: resolution: {integrity: sha512-FX/9frcub54beBdugHjDCdikxThEqjnR93Qt7PvQTOHxyiNCAlvMrHhclk3cD5VeAaq9fxmfRp+CnWw9rEMBuA==} engines: {node: '>=12'} + d3-interpolate@1.4.0: + resolution: {integrity: sha512-V9znK0zc3jOPV4VD2zZn0sDhZU3WAE2bmlxdIwwQPPzPjvyLkd8B3JUVdS1IDUFDkWZ72c9qnv1GK2ZagTZ8EA==} + + d3-interpolate@2.0.1: + resolution: {integrity: sha512-c5UhwwTs/yybcmTpAVqwSFl6vrQ8JZJoT5F7xNFK9pymv5C0Ymcc9/LIJHtYIggg/yS9YHw8i8O8tgb9pupjeQ==} + d3-interpolate@3.0.1: resolution: {integrity: sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==} engines: {node: '>=12'} @@ -12485,10 +12830,16 @@ packages: resolution: {integrity: sha512-A3s5PWiZ9YCXFye1o246KoscMWqf8BsD9eRiJ3He7C9OBaxKhAd5TFCdEx/7VbKtxxTsu//1mMJFrEt572cEyQ==} engines: {node: '>=12'} + d3-scale@3.3.0: + resolution: {integrity: sha512-1JGp44NQCt5d1g+Yy+GeOnZP7xHo0ii8zsQp6PGzd+C1/dl0KGsp9A7Mxwp+1D1o4unbTTxVdU/ZOIEBoeZPbQ==} + d3-scale@4.0.2: resolution: {integrity: sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==} engines: {node: '>=12'} + d3-selection@1.4.2: + resolution: {integrity: sha512-SJ0BqYihzOjDnnlfyeHT0e30k0K1+5sR3d5fNueCNeuhZTnGw4M4o8mqJchSwgKMXCNFo+e2VTChiSJ0vYtXkg==} + d3-selection@3.0.0: resolution: {integrity: sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==} engines: {node: '>=12'} @@ -12500,24 +12851,42 @@ packages: resolution: {integrity: sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA==} engines: {node: '>=12'} + d3-time-format@2.3.0: + resolution: {integrity: sha512-guv6b2H37s2Uq/GefleCDtbe0XZAuy7Wa49VGkPVPMfLL9qObgBST3lEHJBMUp8S7NdLQAGIvr2KXk8Hc98iKQ==} + d3-time-format@4.1.0: resolution: {integrity: sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==} engines: {node: '>=12'} + d3-time@1.1.0: + resolution: {integrity: sha512-Xh0isrZ5rPYYdqhAVk8VLnMEidhz5aP7htAADH6MfzgmmicPkTo8LhkLxci61/lCB7n7UmE3bN0leRt+qvkLxA==} + + d3-time@2.1.1: + resolution: {integrity: sha512-/eIQe/eR4kCQwq7yxi7z4c6qEXf2IYGcjoWB5OOQy4Tq9Uv39/947qlDcN2TLkiTzQWzvnsuYPB9TrWaNfipKQ==} + d3-time@3.1.0: resolution: {integrity: sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==} engines: {node: '>=12'} + d3-timer@1.0.10: + resolution: {integrity: sha512-B1JDm0XDaQC+uvo4DT79H0XmBskgS3l6Ve+1SBCfxgmtIb1AVrPIoqd+nPSv+loMX8szQ0sVUhGngL7D5QPiXw==} + d3-timer@3.0.1: resolution: {integrity: sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==} engines: {node: '>=12'} + d3-transition@1.3.2: + resolution: {integrity: sha512-sc0gRU4PFqZ47lPVHloMn9tlPcv8jxgOQg+0zjhfZXMQuvppjG6YuwdMBE0TuqCZjeJkLecku/l9R0JPcRhaDA==} + d3-transition@3.0.1: resolution: {integrity: sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w==} engines: {node: '>=12'} peerDependencies: d3-selection: 2 - 3 + d3-zoom@1.8.3: + resolution: {integrity: sha512-VoLXTK4wvy1a0JpH2Il+F2CiOhVu7VRXWF5M/LroMIh3/zBAC3WAt7QoIvPibOavVo20hN6/37vwAsdBejLyKQ==} + d3-zoom@3.0.0: resolution: {integrity: sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw==} engines: {node: '>=12'} @@ -12526,12 +12895,26 @@ packages: resolution: {integrity: sha512-e1U46jVP+w7Iut8Jt8ri1YsPOvFpg46k+K8TpCb0P+zjCkjkPnV7WzfDJzMHy1LnA+wj5pLT1wjO901gLXeEhA==} engines: {node: '>=12'} + d@1.0.2: + resolution: {integrity: sha512-MOqHvMWF9/9MX6nza0KgvFH4HpMU0EF5uUDXqX/BtxtU8NfB0QzRtJ8Oe/6SuS4kbhyzVJwjd97EA4PKrzJ8bw==} + engines: {node: '>=0.12'} + dagre-d3-es@7.0.11: resolution: {integrity: sha512-tvlJLyQf834SylNKax8Wkzco/1ias1OPw8DcUMDE7oUIoSEW25riQVuiu/0OWEFqT0cxHT3Pa9/D82Jr47IONw==} damerau-levenshtein@1.0.8: resolution: {integrity: sha512-sdQSFB7+llfUcQHUQO3+B8ERRj0Oa4w9POWMI/puGtuf7gFywGmkaLCElnudfTiKZV+NvHqL0ifzdrI8Ro7ESA==} + dargs@7.0.0: + resolution: {integrity: sha512-2iy1EkLdlBzQGvbweYRFxmFath8+K7+AKB0TlhHWkNuH+TmovaMH/Wp7V7R4u7f4SnX3OgLsU9t1NI9ioDnUpg==} + engines: {node: '>=8'} + + dash-ast@1.0.0: + resolution: {integrity: sha512-Vy4dx7gquTeMcQR/hDkYLGUnwVil6vk4FOOct+djUnHOUWt+zJPJAaRIXaAFkPXtJjvlY7o3rfRu0/3hpnwoUA==} + + dash-ast@2.0.1: + resolution: {integrity: sha512-5TXltWJGc+RdnabUGzhRae1TRq6m4gr+3K2wQX0is5/F2yS6MJXJvLyI3ErAnsAXuJoGqvfVD5icRgim07DrxQ==} + dashdash@1.14.1: resolution: {integrity: sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==} engines: {node: '>=0.10'} @@ -12565,6 +12948,10 @@ packages: dayjs@1.11.18: resolution: {integrity: sha512-zFBQ7WFRvVRhKcWoUh+ZA1g2HVgUbsZm9sbddh8EC5iv93sui8DVVz1Npvz+r6meo9VKfa8NyLWBsQK1VvIKPA==} + debounce-fn@4.0.0: + resolution: {integrity: sha512-8pYCQiL9Xdcg0UPSD3d+0KMlOjp+KGU5EPwYddgzQ7DATsg4fuUDjQtsYLmWjnk2obnNHgV3vE2Y4jejSOJVBQ==} + engines: {node: '>=10'} + debounce@1.2.1: resolution: {integrity: sha512-XRRe6Glud4rd/ZGQfiV1ruXSfbvfJedlV9Y6zOlP+2K04vBYiJEte6stfFkCP03aMnY5tsipamumUjL14fofug==} @@ -12742,10 +13129,17 @@ packages: deprecation@2.3.1: resolution: {integrity: sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ==} + deps-sort@2.0.1: + resolution: {integrity: sha512-1orqXQr5po+3KI6kQb9A4jnXT1PBwggGl2d7Sq2xsnOeI9GPcE/tGcF9UiSZtZBM7MukY4cAh7MemS6tZYipfw==} + hasBin: true + dequal@2.0.3: resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==} engines: {node: '>=6'} + des.js@1.1.0: + resolution: {integrity: sha512-r17GxjhUCjSRy8aiJpr8/UadFIzMzJGexI3Nmz4ADi9LYSFx4gTBp80+NaX/YsXWWLhpZ7v/v/ubEc/bCNfKwg==} + destr@2.0.3: resolution: {integrity: sha512-2N3BOUU4gYMpTP24s5rF5iP7BDr7uNTCs4ozw3kf/eKfvWSIu93GEBi5m427YoyJoeOzQ5smuu4nNAPGb8idSQ==} @@ -12793,12 +13187,15 @@ packages: resolution: {integrity: sha512-D+mk+qE8VC/PAUrlAU34N+VfXev0ghe5ywmpqrawphmVZc1bEfn56uo9qpyGp1p4xpzOHkSW4ztBd6L7Xx4ACw==} engines: {node: '>=0.3.1'} + diffie-hellman@5.0.3: + resolution: {integrity: sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==} + dir-glob@3.0.1: resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==} engines: {node: '>=8'} - discontinuous-range@1.0.0: - resolution: {integrity: sha512-c68LpLbO+7kP/b1Hr1qs8/BJ09F5khZGTxqxZuhzxpmwJKOgRFHJWIb9/KmqnqHhLdO55aOxFH/EGBvUQbL/RQ==} + distributions@2.2.0: + resolution: {integrity: sha512-n7ybud+CRAOZlpg+ETuA0PTiSBfyVNt8Okns5gSK4NvHwj7RamQoufptOucvVcTn9CV4DZ38p1k6TgwMexUNkQ==} dlv@1.1.3: resolution: {integrity: sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==} @@ -12835,6 +13232,10 @@ packages: dom-serializer@2.0.0: resolution: {integrity: sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==} + domain-browser@1.2.0: + resolution: {integrity: sha512-jnjyiM6eRyZl2H+W8Q/zLMA481hzi0eszAaBUzIVnmYVDBbnLxVNnfu1HgEBvCbL+71FrxMl3E6lpKH7Ge3OXA==} + engines: {node: '>=0.4', npm: '>=1.2'} + domelementtype@2.3.0: resolution: {integrity: sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==} @@ -12848,6 +13249,14 @@ packages: domutils@3.0.1: resolution: {integrity: sha512-z08c1l761iKhDFtfXO04C7kTdPBLi41zwOZl00WS8b5eiaebNpY00HKbztwBq+e3vyqWNwWF3mP9YLUeqIrF+Q==} + dot-prop@5.3.0: + resolution: {integrity: sha512-QM8q3zDe58hqUqjraQOmzZ1LIH9SWQJTlEKCH4kJ2oQvLZk7RbQXvtDM2XEq3fwkV9CCvvH4LA0AV+ogFsBM2Q==} + engines: {node: '>=8'} + + dot-prop@6.0.1: + resolution: {integrity: sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==} + engines: {node: '>=10'} + dotenv@16.0.3: resolution: {integrity: sha512-7GO6HghkA5fYG9TYnNxi14/7K9f5occMlp3zXAuSxn7CKCxt9xbNWG7yF8hTCSUchlfWSe3uLmlPfigevRItzQ==} engines: {node: '>=12'} @@ -12883,6 +13292,12 @@ packages: resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==} engines: {node: '>= 0.4'} + dup@1.0.0: + resolution: {integrity: sha512-Bz5jxMMC0wgp23Zm15ip1x8IhYRqJvF3nFC0UInJUDkN1z4uNPk9jTnfCUJXbOGiQ1JbXLQsiV41Fb+HXcj5BA==} + + duplexer2@0.1.4: + resolution: {integrity: sha512-asLFVfWWtJ90ZyOUHMqk7/S2w2guQKxUI2itj3d92ADHhxUSbCMGi1f1cBcJ7xM1To+pE/Khbwo1yuNbMEPKeA==} + duplexer3@0.1.5: resolution: {integrity: sha512-1A8za6ws41LQgv9HrE/66jyC5yuSjQ3L/KOpFtoBilsAK2iA2wuS5rTt1OCzIvtS2V7nVmedsUU+DGRcjBmOYA==} @@ -12940,6 +13355,12 @@ packages: electron-to-chromium@1.5.98: resolution: {integrity: sha512-bI/LbtRBxU2GzK7KK5xxFd2y9Lf9XguHooPYbcXWy6wUoT8NMnffsvRhPmSeUHLSDKAEtKuTaEtK4Ms15zkIEA==} + elliptic@6.6.1: + resolution: {integrity: sha512-RaddvvMatK2LJHqFJ+YA4WysVN5Ita9E35botqIYspQ4TkRAlCicdzKOjlyv/1Za5RyTNn7di//eEV0uTAfe3g==} + + emoji-regex@7.0.3: + resolution: {integrity: sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==} + emoji-regex@8.0.0: resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==} @@ -12967,6 +13388,9 @@ packages: end-of-stream@1.4.4: resolution: {integrity: sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==} + endpoint@0.4.5: + resolution: {integrity: sha512-oA2ALUF+d4Y0I8/WMV/0BuAZGHxfIdAygr9ZXP4rfzmp5zpYZmYKHKAbqRQnrE1YGdPhVg4D24CQkyx2qYEoHg==} + engine.io-client@6.5.3: resolution: {integrity: sha512-9Z0qLB0NIisTRt1DZ/8U2k12RJn8yls/nXMZLn+/N8hANT3TcYjKFKcwbw5zFQiN4NTde3TSY9zb79e1ij6j9Q==} @@ -13002,6 +13426,9 @@ packages: resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==} engines: {node: '>=6'} + env-string@1.0.1: + resolution: {integrity: sha512-/DhCJDf5DSFK32joQiWRpWrT0h7p3hVQfMKxiBb7Nt8C8IF8BYyPtclDnuGGLOoj16d/8udKeiE7JbkotDmorQ==} + environment@1.1.0: resolution: {integrity: sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==} engines: {node: '>=18'} @@ -13064,6 +13491,24 @@ packages: resolution: {integrity: sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==} engines: {node: '>= 0.4'} + es5-ext@0.10.64: + resolution: {integrity: sha512-p2snDhiLaXe6dahss1LddxqEm+SkuDvV8dnIQG0MWjyHpcMNfXKPE+/Cc0y+PhxJX3A4xGNeFCj5oc0BUh6deg==} + engines: {node: '>=0.10'} + + es6-iterator@2.0.3: + resolution: {integrity: sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g==} + + es6-map@0.1.5: + resolution: {integrity: sha512-mz3UqCh0uPCIqsw1SSAkB/p0rOzF/M0V++vyN7JqlPtSW/VsYgQBvVvqMLmfBuyMzTpLnNqi6JmcSizs4jy19A==} + + es6-set@0.1.6: + resolution: {integrity: sha512-TE3LgGLDIBX332jq3ypv6bcOpkLO0AslAQo7p2VqX/1N46YNsvIWgvjojjSEnWEGWMhr1qUbYeTSir5J6mFHOw==} + engines: {node: '>=0.12'} + + es6-symbol@3.1.4: + resolution: {integrity: sha512-U9bFFjX8tFiATgtkJ1zg25+KviIXpgRvRHS8sau3GfhVzThRQrOeksPeT0BWW2MNZs1OEWJ1DPXOQMn0KKRkvg==} + engines: {node: '>=0.12'} + esbuild-android-64@0.15.18: resolution: {integrity: sha512-wnpt3OXRhcjfIDSZu9bnzT4/TNTDsOUvip0foZOUBG7QbSt//w3QV4FInVJxNhKc/ErhUxc5z4QjHtMi7/TbgA==} engines: {node: '>=12'} @@ -13229,6 +13674,10 @@ packages: resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==} engines: {node: '>=6'} + escape-goat@2.1.1: + resolution: {integrity: sha512-8/uIhbG12Csjy2JEW7D9pHbreaVaS/OpN3ycnyvElTdwM5n6GY6W6e2IPemfvGZeUMqZ9A/3GqIZMgKnBhAw/Q==} + engines: {node: '>=8'} + escape-html@1.0.3: resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==} @@ -13244,6 +13693,11 @@ packages: resolution: {integrity: sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==} engines: {node: '>=12'} + escodegen@1.14.3: + resolution: {integrity: sha512-qFcX0XJkdg+PB3xjZZG/wKSuT1PnQWx57+TVSjIMmILd2yC/6ByYElPwJnslDsuWuSAp4AwJGumarAAmJch5Kw==} + engines: {node: '>=4.0'} + hasBin: true + escodegen@2.1.0: resolution: {integrity: sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==} engines: {node: '>=6.0'} @@ -13439,6 +13893,10 @@ packages: esm-env@1.2.2: resolution: {integrity: sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==} + esniff@2.0.1: + resolution: {integrity: sha512-kTUIGKQ/mDPFoJ0oVfcmyJn4iBDRptjNVIzwIFR7tqWXdVI9xfA2RMwY/gbSpJG3lkdWNEjLap/NqVHZiJsdfg==} + engines: {node: '>=0.10'} + espree@9.4.1: resolution: {integrity: sha512-XwctdmTO6SIvCzd9810yyNzIrOrqNYV9Koizx4C/mRhf9uq0o4yHoCEU/670pOxOL/MSraektvSAji79kX90Vg==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} @@ -13471,6 +13929,12 @@ packages: resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==} engines: {node: '>=4.0'} + estree-is-function@1.0.0: + resolution: {integrity: sha512-nSCWn1jkSq2QAtkaVLJZY2ezwcFO161HVc174zL1KPW3RJ+O6C3eJb8Nx7OXzvhoEv+nLgSR1g71oWUHUDTrJA==} + + estree-is-member-expression@1.0.0: + resolution: {integrity: sha512-Ec+X44CapIGExvSZN+pGkmr5p7HwUVQoPQSd458Lqwvaf4/61k/invHSh4BYK8OXnCkfEhWuIoG5hayKLQStIg==} + estree-util-attach-comments@2.1.0: resolution: {integrity: sha512-rJz6I4L0GaXYtHpoMScgDIwM0/Vwbu5shbMeER596rB2D1EWF6+Gj0e0UKzJPZrpoOc87+Q2kgVFHfjAymIqmw==} @@ -13518,6 +13982,9 @@ packages: resolution: {integrity: sha512-t12sJlfkxo0Hon6MYCwOd2qliAjGObrnGL6hYXP9h8AiNAVQCiyGrFrqtOH8TIhM0kgaGrq3s/DeZ679Sr8ipw==} hasBin: true + event-emitter@0.3.5: + resolution: {integrity: sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA==} + event-target-shim@5.0.1: resolution: {integrity: sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==} engines: {node: '>=6'} @@ -13560,9 +14027,16 @@ packages: resolution: {integrity: sha512-fvIkb9qZzdMxgZrEQDyll+9oJsyaVvY92I2Re+qK0qEJ+w5s0X3dtz+M0VAPOjP1gtU3iqWyjQ0G3nvd5CLZ2g==} engines: {node: '>=20.0.0'} + evp_bytestokey@1.0.3: + resolution: {integrity: sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==} + evt@2.4.13: resolution: {integrity: sha512-haTVOsmjzk+28zpzvVwan9Zw2rLQF2izgi7BKjAPRzZAfcv+8scL0TpM8MzvGNKFYHiy+Bq3r6FYIIUPl9kt3A==} + execa@4.1.0: + resolution: {integrity: sha512-j5W0//W7f8UxAn8hXVnwG8tLwdiUy4FJLcSupCg6maBYZDpyBvTApK7KyuI4bKj8KOh1r2YH+6ucuYtJv1bTZA==} + engines: {node: '>=10'} + execa@5.1.1: resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==} engines: {node: '>=10'} @@ -13571,6 +14045,9 @@ packages: resolution: {integrity: sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==} engines: {node: '>=16.17'} + execspawn@1.0.1: + resolution: {integrity: sha512-s2k06Jy9i8CUkYe0+DxRlvtkZoOkwwfhB+Xxo5HGUtrISVW2m98jO2tr67DGRFxZwkjQqloA3v/tNtjhBRBieg==} + exit-hook@2.2.1: resolution: {integrity: sha512-eNTPlAD67BmP31LDINZ3U7HSF8l57TxOY2PmBJ1shpCvpnxBF93mWCE8YHBnXs8qiUZJc9WDcWIeC3a2HIAMfw==} engines: {node: '>=6'} @@ -13600,6 +14077,9 @@ packages: exsolve@1.0.7: resolution: {integrity: sha512-VO5fQUzZtI6C+vx4w/4BWJpg3s/5l+6pRQEHzFRM8WFi4XffSP1Z+4qi7GbjWbvRQEbdIco5mIMq+zX4rPuLrw==} + ext@1.7.0: + resolution: {integrity: sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==} + extend@3.0.2: resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==} @@ -13741,6 +14221,10 @@ packages: fft.js@4.0.4: resolution: {integrity: sha512-f9c00hphOgeQTlDyavwTtu6RiK8AIFjD6+jvXkNkpeQ7rirK3uFWVpalkoS4LAwbdX7mfZ8aoBfFVQX1Re/8aw==} + figures@2.0.0: + resolution: {integrity: sha512-Oa2M9atig69ZkfwiApY8F2Yy+tzMbazyvqv21R0NsSC8floSOC09BbT1ITWAdoMGQvJ/aZnR1KMwdx9tvHnTNA==} + engines: {node: '>=4'} + file-entry-cache@6.0.1: resolution: {integrity: sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==} engines: {node: ^10.12.0 || >=12.0.0} @@ -13775,6 +14259,10 @@ packages: resolution: {integrity: sha512-eRoFWQw+Yv2tuYlK2pjFS2jGXSxSppAs3hSQjfxVKxM5amECzIgYYc1FEI8ZmhSh/Ig+FrKEz43NLRKJjYCZVg==} engines: {node: '>=20'} + find-up@3.0.0: + resolution: {integrity: sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==} + engines: {node: '>=6'} + find-up@4.1.0: resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==} engines: {node: '>=8'} @@ -13790,10 +14278,16 @@ packages: find-yarn-workspace-root2@1.2.16: resolution: {integrity: sha512-hr6hb1w8ePMpPVUK39S4RlwJzi+xPLuVuG8XlwXU3KD5Yn3qgBWVfy3AzNlDhWvE1EORCE65/Qm26rFQt3VLVA==} + flame-gradient@1.0.0: + resolution: {integrity: sha512-9ejk16/DqvQJ4dHsh68W/4N0zmVQ60zukyUuEHrTbf5pJvP4JqlIdke86Z9174PZokRCXAntY5+H1txSyC7mUA==} + flat-cache@3.0.4: resolution: {integrity: sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==} engines: {node: ^10.12.0 || >=12.0.0} + flatstr@1.0.12: + resolution: {integrity: sha512-4zPxDyhCyiN2wIAtSLI6gc82/EjqZc1onI4Mz/l0pWrAlsSfYH/2ZIcU+e3oA2wDwbzIWNKwa23F8rh6+DRWkw==} + flatted@3.2.7: resolution: {integrity: sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==} @@ -13809,6 +14303,10 @@ packages: for-each@0.3.3: resolution: {integrity: sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==} + for-each@0.3.5: + resolution: {integrity: sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==} + engines: {node: '>= 0.4'} + foreground-child@3.1.1: resolution: {integrity: sha512-TMKDUnIte6bfb5nWv7V/caI169OHgvwjb7V4WkeUvbQQdjr5rWKqHFiKWb/fcOwB+CzBT+qbWjvj+DVwRskpIg==} engines: {node: '>=14'} @@ -13886,6 +14384,12 @@ packages: resolution: {integrity: sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==} engines: {node: '>= 0.8'} + from2-string@1.1.0: + resolution: {integrity: sha512-m8vCh+KnXXXBtfF2VUbiYlQ+nczLcntB0BrtNgpmLkHylhObe9WF1b2LZjBBzrZzA6P4mkEla6ZYQoOUTG8cYA==} + + from2@2.3.0: + resolution: {integrity: sha512-OMcX/4IC/uqEPVgGeyfN22LJk6AZrMkRZHxcHBMBvHScDGgwTm2GT2Wkgtocyd3JfZffjj2kYUDXXII0Fk9W0g==} + fs-constants@1.0.0: resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==} @@ -13893,6 +14397,10 @@ packages: resolution: {integrity: sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==} engines: {node: '>=12'} + fs-extra@11.3.2: + resolution: {integrity: sha512-Xr9F6z6up6Ws+NjzMCZc6WXg2YFRlrLP9NQDO3VQrWrfiojdhS56TzueT88ze0uBdCTwEIhQ3ptnmKeWGFAe0A==} + engines: {node: '>=14.14'} + fs-extra@7.0.1: resolution: {integrity: sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==} engines: {node: '>=6 <7 || >=8'} @@ -13936,6 +14444,12 @@ packages: functions-have-names@1.2.3: resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==} + generate-function@2.3.1: + resolution: {integrity: sha512-eeB5GfMNeevm/GRYq20ShmsaGcmI81kIX2K9XQx5miC8KdHaC6Jm0qQ8ZNeGOi7wYB8OsdxKs+Y2oVuTFuVwKQ==} + + generate-object-property@1.2.0: + resolution: {integrity: sha512-TuOwZWgJ2VAMEGJvAyPWvpqxSANF0LDpmyHauMjFYzaACvn+QTT/AZomvPCzVBV7yDN3OmwHQ5OvHaeLKre3JQ==} + generic-names@4.0.0: resolution: {integrity: sha512-ySFolZQfw9FoDb3ed9d80Cm9f0+r7qj+HJkWjeD9RBfpxEVTlVhol+gvaQB/78WbwYfbnNh8nWHHBSlg072y6A==} @@ -13943,6 +14457,9 @@ packages: resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==} engines: {node: '>=6.9.0'} + get-assigned-identifiers@1.2.0: + resolution: {integrity: sha512-mBBwmeGTrxEMO4pMaaf/uUEFHnYtwr8FTe8Y/mer4rcV/bye0qGm6pw1bGZFGStxC5O76c5ZAVBGnqHmOaJpdQ==} + get-caller-file@2.0.5: resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==} engines: {node: 6.* || 8.* || >= 10.*} @@ -14064,6 +14581,10 @@ packages: resolution: {integrity: sha512-e1LleDykUz2Iu+MTYdkSsuWX8lvAjAcs0Xef0lNIu0S2wOAzuTxCJtcd9S3cijlwYF18EsU3rzb8jPVobxDh9Q==} engines: {node: '>=16 || 14 >=14.17'} + global-dirs@3.0.1: + resolution: {integrity: sha512-NBcGGFbBA9s1VzD41QXDG+3++t9Mn5t1FpLdhESY6oKY4gYTFpX4wO3sqGUa0Srjtbfj3szX0RnemmrVRUdULA==} + engines: {node: '>=10'} + globals@11.12.0: resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==} engines: {node: '>=4'} @@ -14149,6 +14670,13 @@ packages: resolution: {integrity: sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==} engines: {node: '>=6'} + has-ansi@2.0.0: + resolution: {integrity: sha512-C8vBJ8DwUCx19vhm7urhTuUsr4/IyP6l4VzNQDv+ryHQObW3TTTp9yB68WpYgRe2bbaGuZ/se74IqFeVnMnLZg==} + engines: {node: '>=0.10.0'} + + has-async-hooks@1.0.0: + resolution: {integrity: sha512-YF0VPGjkxr7AyyQQNykX8zK4PvtEDsUJAPqwu06UFz1lb6EvI53sPh5H1kWxg8NXI5LsfRCZ8uX9NkYDZBb/mw==} + has-bigints@1.0.2: resolution: {integrity: sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==} @@ -14183,10 +14711,28 @@ packages: resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==} engines: {node: '>= 0.4'} + has-unicode@2.0.1: + resolution: {integrity: sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==} + + has-yarn@2.1.0: + resolution: {integrity: sha512-UqBRqi4ju7T+TqGNdqAO0PaSVGsDGJUBQvk9eUWNGRY1CFGDzYhLWoM7JQEemnlvVcv/YEmc2wNW8BC24EnUsw==} + engines: {node: '>=8'} + has@1.0.3: resolution: {integrity: sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==} engines: {node: '>= 0.4.0'} + hash-base@3.0.5: + resolution: {integrity: sha512-vXm0l45VbcHEVlTCzs8M+s0VeYsB2lnlAaThoLKGXr3bE/VWDOelNUnycUPEhKEaXARL2TEFjBOyUiM6+55KBg==} + engines: {node: '>= 0.10'} + + hash-base@3.1.2: + resolution: {integrity: sha512-Bb33KbowVTIj5s7Ked1OsqHUeCpz//tPwR+E2zJgJKo9Z5XolZ9b6bdUgjmYlwnWhoOQKoTd1TYToZGn5mAYOg==} + engines: {node: '>= 0.8'} + + hash.js@1.1.7: + resolution: {integrity: sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==} + hasown@2.0.2: resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} engines: {node: '>= 0.4'} @@ -14236,13 +14782,28 @@ packages: hastscript@9.0.1: resolution: {integrity: sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==} + hdr-histogram-js@3.0.1: + resolution: {integrity: sha512-l3GSdZL1Jr1C0kyb461tUjEdrRPZr8Qry7jByltf5JGrA0xvqOSrxRBfcrJqqV/AMEtqqhHhC6w8HW0gn76tRQ==} + engines: {node: '>=14'} + + hdr-histogram-percentiles-obj@3.0.0: + resolution: {integrity: sha512-7kIufnBqdsBGcSZLPJwqHT3yhk1QTsSlFsVD3kx5ixH/AlgBs9yM1q6DPhXZ8f8gtdqgh7N7/5btRLpQsS2gHw==} + hexoid@1.0.0: resolution: {integrity: sha512-QFLV0taWQOZtvIRIAdBChesmogZrtuXvVWsFHZTk2SU+anspqZ2vMnoLg7IE1+Uk16N19APic1BuF8bC8c2m5g==} engines: {node: '>=8'} + hidden-markov-model-tf@4.0.0: + resolution: {integrity: sha512-q8VeBNCyQ5CNsUlbt4T5JXc+pUeKqq7LEGjs4HiH+thgZ2fuyJ9pf/V66ZFx9jZobXkwxVuQRWKZa3TwOFW+zw==} + peerDependencies: + '@tensorflow/tfjs-core': ^3.13.0 + highlight.js@10.7.3: resolution: {integrity: sha512-tzcUFauisWKNHaRkN4Wjl/ZA07gENAjFl3J/c480dprkGTg5EQstgaNFqBfUqCq54kZRIEcreTsAgF/m2quD7A==} + hmac-drbg@1.0.1: + resolution: {integrity: sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg==} + hoist-non-react-statics@3.3.2: resolution: {integrity: sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==} @@ -14257,6 +14818,9 @@ packages: resolution: {integrity: sha512-r0EI+HBMcXadMrugk0GCQ+6BQV39PiWAZVfq7oIckeGiN7sjRGyQxPdft3nQekFTCQbYxLBH+/axZMeH8UX6+w==} engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} + hsl-to-rgb-for-reals@1.1.1: + resolution: {integrity: sha512-LgOWAkrN0rFaQpfdWBQlv/VhkOxb5AsBjk6NQVx4yEzWS923T07X0M1Y0VNko2H52HeSpZrZNNMJ0aFqsdVzQg==} + html-escaper@2.0.2: resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==} @@ -14274,6 +14838,10 @@ packages: html-void-elements@3.0.0: resolution: {integrity: sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==} + htmlescape@1.1.1: + resolution: {integrity: sha512-eVcrzgbR4tim7c7soKQKtxa/kQM4TzjnlU83rcZ9bHU6t31ehfV7SktN6McWgwPWg+JYMA/O3qpGxBvFq1z2Jg==} + engines: {node: '>=0.10'} + htmlparser2@8.0.2: resolution: {integrity: sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==} @@ -14284,6 +14852,9 @@ packages: resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==} engines: {node: '>= 0.8'} + http-parser-js@0.5.10: + resolution: {integrity: sha512-Pysuw9XpUq5dVc/2SMHpuTY01RFl8fttgcyunjL7eEMhGM3cI4eOmiCycJDVCo/7O7ClfQD3SaI6ftDzqOXYMA==} + http-proxy-agent@7.0.2: resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==} engines: {node: '>= 14'} @@ -14292,6 +14863,9 @@ packages: resolution: {integrity: sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ==} engines: {node: '>=0.8', npm: '>=1.3.7'} + https-browserify@1.0.0: + resolution: {integrity: sha512-J+FkSdyD+0mA0N+81tMotaRMfSL9SGi+xpD3T6YApKsc3bGSXJlfXri3VyFOeYkfLRQisDk1W+jIFFKBeUBbBg==} + https-proxy-agent@5.0.1: resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==} engines: {node: '>= 6'} @@ -14303,6 +14877,10 @@ packages: human-id@1.0.2: resolution: {integrity: sha512-UNopramDEhHJD+VR+ehk8rOslwSfByxPIZyJRfV739NDhN5LF1fa1MqnzKm2lGTQRjNrjK19Q5fhkgIfjlVUKw==} + human-signals@1.1.1: + resolution: {integrity: sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw==} + engines: {node: '>=8.12.0'} + human-signals@2.1.0: resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==} engines: {node: '>=10.17.0'} @@ -14317,6 +14895,15 @@ packages: humanize-ms@1.2.1: resolution: {integrity: sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==} + hyperid@3.3.0: + resolution: {integrity: sha512-7qhCVT4MJIoEsNcbhglhdmBKb09QtcmJNiIQGq7js/Khf5FtQQ9bzcAuloeqBeee7XD7JqDeve9KNlQya5tSGQ==} + + hyperscript-attribute-to-property@1.0.2: + resolution: {integrity: sha512-oerMul16jZCmrbNsUw8QgrtDzF8lKgFri1bKQjReLw1IhiiNkI59CWuzZjJDGT79UQ1YiWqXhJMv/tRMVqgtkA==} + + hyperx@2.5.4: + resolution: {integrity: sha512-iOkSh7Yse7lsN/B9y7OsevLWjeXPqGuHQ5SbwaiJM5xAhWFqhoN6erpK1dQsS12OFU36lyai1pnx1mmzWLQqcA==} + hyphenate-style-name@1.0.4: resolution: {integrity: sha512-ygGZLjmXfPHj+ZWh6LwbC37l43MhfztxetbFCoYTM2VjkIUpeHgSNn7QIyVFj7YQ1Wl9Cbw5sholVJPzWvC2MQ==} @@ -14355,6 +14942,10 @@ packages: import-in-the-middle@1.14.2: resolution: {integrity: sha512-5tCuY9BV8ujfOpwtAGgsTx9CGUapcFMEEyByLv1B+v2+6DhAcw+Zr0nhQT7uwaZ7DiourxFEscghOR8e1aPLQw==} + import-lazy@2.1.0: + resolution: {integrity: sha512-m7ZEHgtw69qOGw+jwxXkHlrlIPdTGkyh66zXZ1ajZbxkDBNjSY/LGbmjc7h0s2ELsUDTAhFr55TrPSSqJGPG0A==} + engines: {node: '>=4'} + import-meta-resolve@4.1.0: resolution: {integrity: sha512-I6fiaX09Xivtk+THaMfAwnA3MVA5Big1WHF1Dfx9hFuvNIWpXnorlkzhcQf6ehrqQiiZECRt1poOAkPmer3ruw==} @@ -14374,16 +14965,26 @@ packages: resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==} deprecated: This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful. + inherits@2.0.3: + resolution: {integrity: sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw==} + inherits@2.0.4: resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} ini@1.3.8: resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==} + ini@2.0.0: + resolution: {integrity: sha512-7PnF4oN3CvZF23ADhA5wRaYEQpJ8qygSkbtTXWBeXWXmEVRXK+1ITciHWwHhsjv1TmW0MgacIv6hEi5pX5NQdA==} + engines: {node: '>=10'} + ini@5.0.0: resolution: {integrity: sha512-+N0ngpO3e7cRUWOJAS7qw0IZIVc6XPrW4MlFBdD066F2L4k1L6ker3hLqSq7iXxU5tgS4WGkIUElWn5vogAEnw==} engines: {node: ^18.17.0 || >=20.5.0} + inline-source-map@0.6.3: + resolution: {integrity: sha512-1aVsPEsJWMJq/pdMU61CDlm1URcW702MTB4w9/zUjMus6H/Py8o7g68Pr9D4I6QluWGt/KdmswuRhaA05xVR1w==} + inline-style-parser@0.1.1: resolution: {integrity: sha512-7NXolsK4CAS5+xvdj5OMMbI962hU/wvwoxk+LWR9Ek9bVtyuuYScDN6eS0rUm6TxApFpw7CX1o4uJzcd4AyD3Q==} @@ -14399,6 +15000,18 @@ packages: react: ^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc + inquirer@6.5.2: + resolution: {integrity: sha512-cntlB5ghuB0iuO65Ovoi8ogLHiWGs/5yNrtUcKjFhSSiVeAIVpD7koaSU9RM8mpXw5YDi9RdYXGQMaOURB7ycQ==} + engines: {node: '>=6.0.0'} + + insert-module-globals@7.2.1: + resolution: {integrity: sha512-ufS5Qq9RZN+Bu899eA9QCAYThY+gGW7oRkmb0vC93Vlyu/CFGcH0OYPEjVkDXA5FEbTt1+VWzdoOD3Ny9N+8tg==} + hasBin: true + + insight@0.11.1: + resolution: {integrity: sha512-TBcZ0qC9dgdmcxL93OoqkY/RZXJtIi0i07phX/QyYk2ysmJtZex59dgTj4Doq50N9CG9dLRe/RIudc/5CCoFNw==} + engines: {node: '>=12.20'} + install@0.13.0: resolution: {integrity: sha512-zDml/jzr2PKU9I8J/xyZBQn8rPCAY//UOYNmR01XwNwyfhEWObo2SWfSl1+0tm1u6PhxLwDnfsT/6jB7OUxqFA==} engines: {node: '>= 0.10'} @@ -14440,6 +15053,9 @@ packages: resolution: {integrity: sha512-1DKMMzlIHM02eBBVOFQ1+AolGjs6+xEcM4PDL7NqOS6szq7H9jSaEkIUH6/a5Hl241LzW6JLSiAbNvTQjUupUA==} engines: {node: '>=12.22.0'} + iota-array@1.0.0: + resolution: {integrity: sha512-pZ2xT+LOHckCatGQ3DcG/a+QuEqvoxqkiL7tvE8nn3uuu+f6i1TtpB5/FtWFbxUuVr5PZCx8KskuGatbJDXOWA==} + ip-address@9.0.5: resolution: {integrity: sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==} engines: {node: '>= 12'} @@ -14485,10 +15101,16 @@ packages: resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==} engines: {node: '>=8'} + is-boolean-attribute@0.0.1: + resolution: {integrity: sha512-0kXT52Scokg2Miscvsn5UVqg6y1691vcLJcagie1YHJB4zOEuAhMERLX992jtvaStGy2xQTqOtJhvmG/MK1T5w==} + is-boolean-object@1.1.2: resolution: {integrity: sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==} engines: {node: '>= 0.4'} + is-buffer@1.1.6: + resolution: {integrity: sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==} + is-buffer@2.0.5: resolution: {integrity: sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==} engines: {node: '>=4'} @@ -14497,6 +15119,10 @@ packages: resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==} engines: {node: '>= 0.4'} + is-ci@2.0.0: + resolution: {integrity: sha512-YfJT7rkpQB0updsdHLGWrvhBJfcfzNNawYDNIyQXJz0IViGf75O8EBPKSdvw2rF+LGCsX4FZ8tcr3b19LcZq4w==} + hasBin: true + is-ci@3.0.1: resolution: {integrity: sha512-ZYvCgrefwqoQ6yTyYUbQu64HsITZ3NfKX1lzaEYdkTDcfKzzCI/wthRRYKkdjHKFVgNiXKAKm65Zo1pk2as/QQ==} hasBin: true @@ -14536,6 +15162,14 @@ packages: resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} engines: {node: '>=0.10.0'} + is-fullwidth-code-point@1.0.0: + resolution: {integrity: sha512-1pqUqRjkhPJ9miNq9SwMfdvi6lBJcd6eFxvfaivQhaH3SgisfiuudvFntdKOmxuee/77l+FPjKrQjWvmPjWrRw==} + engines: {node: '>=0.10.0'} + + is-fullwidth-code-point@2.0.0: + resolution: {integrity: sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==} + engines: {node: '>=4'} + is-fullwidth-code-point@3.0.0: resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} engines: {node: '>=8'} @@ -14560,6 +15194,10 @@ packages: engines: {node: '>=14.16'} hasBin: true + is-installed-globally@0.4.0: + resolution: {integrity: sha512-iwGqO3J21aaSkC7jWnHP/difazwS7SFeIqxv6wEtLU8Y5KlzFTjyqcSIT0d8s4+dDhKytsk9PJZ2BkS5eZwQRQ==} + engines: {node: '>=10'} + is-interactive@1.0.0: resolution: {integrity: sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==} engines: {node: '>=8'} @@ -14576,6 +15214,10 @@ packages: resolution: {integrity: sha512-P3fxi10Aji2FZmHTrMPSNFbNC6nnp4U5juPAIjXPHkUNubi4+qK7vvdsaNpAUwXslhYm9oyjEYTxs1xd/+Ph0w==} engines: {node: '>=16'} + is-npm@5.0.0: + resolution: {integrity: sha512-WW/rQLOazUq+ST/bCAVBp/2oMERWLsR7OrKyt052dNDk4DHcDE0/7QSXITlmi+VBcV13DfIbysG3tZJm5RfdBA==} + engines: {node: '>=10'} + is-number-object@1.0.7: resolution: {integrity: sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==} engines: {node: '>= 0.4'} @@ -14584,6 +15226,10 @@ packages: resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} engines: {node: '>=0.12.0'} + is-obj@2.0.0: + resolution: {integrity: sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==} + engines: {node: '>=8'} + is-path-inside@3.0.3: resolution: {integrity: sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==} engines: {node: '>=8'} @@ -14607,6 +15253,9 @@ packages: is-promise@4.0.0: resolution: {integrity: sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==} + is-property@1.0.2: + resolution: {integrity: sha512-Ks/IoX00TtClbGQr4TWXemAnktAQvYB7HzcCxDGqEZU6oCmb2INHuOoKxbtR+HFkmYWBKv/dOZtGRiAjDhj92g==} + is-reference@3.0.3: resolution: {integrity: sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw==} @@ -14649,6 +15298,10 @@ packages: resolution: {integrity: sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==} engines: {node: '>= 0.4'} + is-typed-array@1.1.15: + resolution: {integrity: sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==} + engines: {node: '>= 0.4'} + is-typedarray@1.0.0: resolution: {integrity: sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==} @@ -14667,6 +15320,10 @@ packages: resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==} engines: {node: '>=0.10.0'} + is-wsl@1.1.0: + resolution: {integrity: sha512-gfygJYZ2gLTDlmbWMI0CE2MwnFzSN/2SZfkMlItC4K/JBlsWVDB0bO6XhqcY13YXE7iMcAJnzTCJjPiTeJJ0Mw==} + engines: {node: '>=4'} + is-wsl@2.2.0: resolution: {integrity: sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==} engines: {node: '>=8'} @@ -14675,6 +15332,9 @@ packages: resolution: {integrity: sha512-UcVfVfaK4Sc4m7X3dUSoHoozQGBEFeDC+zVo06t98xe8CzHSZZBekNXH+tu0NalHolcJ/QAGqS46Hef7QXBIMw==} engines: {node: '>=16'} + is-yarn-global@0.3.0: + resolution: {integrity: sha512-VjSeb/lHmkoyd8ryPVIKvOCn4D1koMqY+vqyjjUfc3xyKtP4dYOxM44sZrnqQSzSds3xyOrUTLTC9LVCVgLngw==} + isarray@1.0.0: resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==} @@ -14833,6 +15493,9 @@ packages: json-schema-traverse@1.0.0: resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==} + json-schema-typed@7.0.3: + resolution: {integrity: sha512-7DE8mpG+/fVw+dTpjbxnx47TaMnDfOI1jwft9g1VybltZCduyRQPJPvc+zzKY9WPHxhPWczyFuYa6I8Mw4iU5A==} + json-schema@0.4.0: resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==} @@ -14872,6 +15535,10 @@ packages: jsonify@0.0.1: resolution: {integrity: sha512-2/Ki0GcmuqSrgFyelQq9M05y7PS0mEwuIzrf3f1fPqkVDVRvZrPZtVSMHxdgo8Aq0sxAOb/cr2aqqA3LeWHVPg==} + jsonparse@1.3.1: + resolution: {integrity: sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==} + engines: {'0': node >= 0.2.0} + jsonpath-plus@10.3.0: resolution: {integrity: sha512-8TNmfeTCk2Le33A3vRRwtuworG/L5RrgMvdjhKZxvyShO+mBu2fP50OWUjRLNtvw344DdDarFh9buFAZs5ujeA==} engines: {node: '>=18.0.0'} @@ -14885,6 +15552,11 @@ packages: resolution: {integrity: sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==} engines: {node: '>=0.10.0'} + jsonstream2@3.0.0: + resolution: {integrity: sha512-8ngq2XB8NjYrpe3+Xtl9lFJl6RoV2dNT4I7iyaHwxUpTBwsj0AlAR7epGfeYVP0z4Z7KxMoSxRgJWrd2jmBT/Q==} + engines: {node: '>=5.10.0'} + hasBin: true + jsonwebtoken@9.0.2: resolution: {integrity: sha512-PRp66vJ865SSqOlgqS8hujT5U4AOgMfhrwYIuIhfKaoSCZcirrmASQr8CX7cUg+RMih+hgznrjp99o+W4pJLHQ==} engines: {node: '>=12', npm: '>=6'} @@ -14928,6 +15600,9 @@ packages: kolorist@1.8.0: resolution: {integrity: sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ==} + labeled-stream-splicer@2.0.2: + resolution: {integrity: sha512-Ca4LSXFFZUjPScRaqOcFxneA0VpKZr4MMYCljyQr4LIewTLb3Y0IUTIsnBBsVubIeEfxeSZpSjSsRM8APEQaAw==} + langium@3.3.1: resolution: {integrity: sha512-QJv/h939gDpvT+9SiLVlY7tZC3xB2qK57v0J04Sh9wpMb6MP1q8gB21L3WIo8T5P1MSMg3Ep14L7KkDCFG3y4w==} engines: {node: '>=16.0.0'} @@ -14946,6 +15621,10 @@ packages: language-tags@1.0.5: resolution: {integrity: sha512-qJhlO9cGXi6hBGKoxEG/sKZDAHD5Hnu9Hs4WbOY3pCWXDhw0N8x1NenNzm2EnNLkLkk7J2SdxAkDSbb6ftT+UQ==} + latest-version@5.1.0: + resolution: {integrity: sha512-weT+r0kTkRQdCdYCNtkMwWXQTMEswKrFBkm4ckQOMVhhqhIMI1UT2hMj+1iigIhgSZm5gTmrRXBNoGUgaTY1xA==} + engines: {node: '>=8'} + layerr@2.0.1: resolution: {integrity: sha512-z0730CwG/JO24evdORnyDkwG1Q7b7mF2Tp1qRQ0YvrMMARbt1DFG694SOv439Gm7hYKolyZyaB49YIrYIfZBdg==} @@ -15016,6 +15695,14 @@ packages: resolution: {integrity: sha512-HJp37y62j3j8qzAOODWuUJl4ysLwsDvCTBV6odr3jIRHR/a5e+tI14VQGIBcpK9ysqC3pGWyW5Rp9Jv1YDubyw==} hasBin: true + leven@2.1.0: + resolution: {integrity: sha512-nvVPLpIHUxCUoRLrFqTgSxXJ614d8AgQoWl7zPe/2VadE8+1dpU3LBhowRuBAcuwruWtOdD8oYC9jDNJjXDPyA==} + engines: {node: '>=0.10.0'} + + levn@0.3.0: + resolution: {integrity: sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA==} + engines: {node: '>= 0.8.0'} + levn@0.4.1: resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==} engines: {node: '>= 0.8.0'} @@ -15140,6 +15827,10 @@ packages: locate-character@3.0.0: resolution: {integrity: sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA==} + locate-path@3.0.0: + resolution: {integrity: sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==} + engines: {node: '>=6'} + locate-path@5.0.0: resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==} engines: {node: '>=8'} @@ -15161,6 +15852,12 @@ packages: lodash.castarray@4.4.0: resolution: {integrity: sha512-aVx8ztPv7/2ULbArGJ2Y42bG1mEQ5mGjpdvrbJcJFU3TbYybe+QlLS4pst9zV52ymy2in1KpFPiZnAOATxD4+Q==} + lodash.chunk@4.2.0: + resolution: {integrity: sha512-ZzydJKfUHJwHa+hF5X66zLFCBrWn5GeF28OHEr4WVWtNDXlQ/IjWKPBiikqKo2ne0+v6JgCgJ0GzJp8k8bHC7w==} + + lodash.clonedeep@4.5.0: + resolution: {integrity: sha512-H5ZhCF25riFd9uB5UCkVKo61m3S/xZk1x4wA6yp/L3RFP6Z/eHH1ymQcGLo7J3GMPfm0V/7m1tryHuGVxpqEBQ==} + lodash.debounce@4.0.8: resolution: {integrity: sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==} @@ -15170,6 +15867,9 @@ packages: lodash.escaperegexp@4.1.2: resolution: {integrity: sha512-TM9YBvyC84ZxE3rgfefxUWiQKLilstD6k7PTGt6wfbtXF8ixIJLOL3VYyV/z+ZiPLsVxAsKAFVwWlWeb2Y8Yyw==} + lodash.flatten@4.4.0: + resolution: {integrity: sha512-C5N2Z3DgnnKr0LOpv/hKCgKdb7ZZwafIrsesve6lmzvZIRZRGaZ/l6Q8+2W7NaT+ZwO3fFlSCzCzrDCFdJfZ4g==} + lodash.groupby@4.6.0: resolution: {integrity: sha512-5dcWxm23+VAoz+awKmBaiBvzox8+RqMgFhi7UvX9DHZr2HdxHXM/Wrf8cfKpsW37RNrvtPn6hSwNqurSILbmJw==} @@ -15203,6 +15903,9 @@ packages: lodash.isundefined@3.0.1: resolution: {integrity: sha512-MXB1is3s899/cD8jheYYE2V9qTHwKvt+npCwpD+1Sxm3Q3cECXCiYHjeHWXNwr6Q0SOBPrYUDxendrO6goVTEA==} + lodash.memoize@3.0.4: + resolution: {integrity: sha512-eDn9kqrAmVUC1wmZvlQ6Uhde44n+tXpqPrN8olQJbttgh0oKclk+SF54P47VEGE9CEiMeRwAP8BaM7UHvBkz2A==} + lodash.merge@4.6.2: resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==} @@ -15232,6 +15935,9 @@ packages: resolution: {integrity: sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==} engines: {node: '>=10'} + long@4.0.0: + resolution: {integrity: sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA==} + long@5.2.3: resolution: {integrity: sha512-lcHwpNoggQTObv5apGNCTdJrO69eHOZMi4BNC+rTLER8iHAqGrUVeLh/irVIM7zTw2bOXA8T6uNPeujwOLg/2Q==} @@ -15245,6 +15951,9 @@ packages: loupe@3.1.3: resolution: {integrity: sha512-kkIp7XSkP78ZxJEsSxW3712C6teJVoeHHwgo9zJ380de7IYyJ2ISlxojcH2pC5OFLewESmnRi/+XCDIEEVyoug==} + lower-case@1.1.4: + resolution: {integrity: sha512-2Fgx1Ycm599x+WGpIYwJOvsjmXFzTSc34IwDWALRA/8AopUKAVPwfJ+h5+f85BCp0PWmmJcWzEpxOpoXycMpdA==} + lowercase-keys@1.0.1: resolution: {integrity: sha512-G2Lj61tXDnVFFOi8VZds+SoQjtQC3dgokKdDG2mTm1tx4m50NUHBOZSBwQQHyy0V12A0JTG4icfZQH+xPyh8VA==} engines: {node: '>=0.10.0'} @@ -15307,6 +16016,16 @@ packages: resolution: {integrity: sha512-0ckx7ZHRPqb0oUm8zNr+90mtf9DQB60H1wMCjBtfi62Kl3a7JbHob6gA2bC+xRvZoOL+1hzUK8jeuEIQE8svEQ==} hasBin: true + macos-release@2.5.1: + resolution: {integrity: sha512-DXqXhEM7gW59OjZO8NIjBCz9AQ1BEMrfiOAl4AYByHCtVHRF4KoGNO8mqQeM8lRCtQe/UnJ4imO/d2HdkKsd+A==} + engines: {node: '>=6'} + + magic-string@0.23.2: + resolution: {integrity: sha512-oIUZaAxbcxYIp4AyLafV6OVKoB3YouZs0UTCJ8mOKBHNyJgGDaMJ4TgA+VylJh6fx7EQCC52XkbURxxG9IoJXA==} + + magic-string@0.25.1: + resolution: {integrity: sha512-sCuTz6pYom8Rlt4ISPFn6wuFodbKMIHUMv4Qko9P17dpxb7s52KJTmRuZZqHdGmLCK9AOcDare039nRIcfdkEg==} + magic-string@0.30.17: resolution: {integrity: sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==} @@ -15319,10 +16038,17 @@ packages: magicast@0.3.5: resolution: {integrity: sha512-L0WhttDl+2BOsybvEOLK7fW3UA0OQ0IQ2d6Zl2x/a6vVRs3bAY0ECOSHHeL5jD+SbOpOCUEi0y1DgHEn9Qn1AQ==} + make-dir@3.1.0: + resolution: {integrity: sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==} + engines: {node: '>=8'} + make-dir@4.0.0: resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==} engines: {node: '>=10'} + manage-path@2.0.0: + resolution: {integrity: sha512-NJhyB+PJYTpxhxZJ3lecIGgh4kwIY2RAh44XvAz9UlqthlQwtPBf62uBVR8XaD8CRuSjQ6TnZH2lNJkbLPZM2A==} + map-obj@1.0.1: resolution: {integrity: sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg==} engines: {node: '>=0.10.0'} @@ -15380,6 +16106,9 @@ packages: peerDependencies: react: 18.x + md5.js@1.3.5: + resolution: {integrity: sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==} + mdast-util-definitions@5.1.1: resolution: {integrity: sha512-rQ+Gv7mHttxHOBx2dkF4HWTg+EE+UR78ptQWDylzPKaQuVGdG4HIoY3SrS/pCp80nZ04greFvXbVFHT+uf0JVQ==} @@ -15494,6 +16223,9 @@ packages: resolution: {integrity: sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==} engines: {node: '>=18'} + merge-source-map@1.0.4: + resolution: {integrity: sha512-PGSmS0kfnTnMJCzJ16BLLCEe6oeYCamKFFdQKshi4BmM6FUwipjVOcBFGxqtQtirtAG4iZvHlqST9CpZKqlRjA==} + merge-stream@2.0.0: resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==} @@ -15686,6 +16418,10 @@ packages: resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==} engines: {node: '>=8.6'} + miller-rabin@4.0.1: + resolution: {integrity: sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==} + hasBin: true + mime-db@1.52.0: resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==} engines: {node: '>= 0.6'} @@ -15717,10 +16453,18 @@ packages: engines: {node: '>=10.0.0'} hasBin: true + mimic-fn@1.2.0: + resolution: {integrity: sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==} + engines: {node: '>=4'} + mimic-fn@2.1.0: resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==} engines: {node: '>=6'} + mimic-fn@3.1.0: + resolution: {integrity: sha512-Ysbi9uYW9hFyfrThdDEQuykN4Ey6BuwPD2kpI5ES/nFTDn/98yxYNLZJcgUAKPT/mcrLLKaGzJR9YVxJrIdASQ==} + engines: {node: '>=8'} + mimic-fn@4.0.0: resolution: {integrity: sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==} engines: {node: '>=12'} @@ -15741,12 +16485,22 @@ packages: resolution: {integrity: sha512-r9deDe9p5FJUPZAk3A59wGH7Ii9YrjjWw0jmw/liSbHl2CHiyXj6FcDXDu2K3TjVAXqiJdaw3xxwlZZr9E6nHg==} hasBin: true + minify-stream@2.1.0: + resolution: {integrity: sha512-P5xE4EQRkn7Td54VGcgfDMFx1jmKPPIXCdcMfrbXS6cNHK4dO1LXwtYFb48hHrSmZfT+jlGImvHgSZEkbpNtCw==} + engines: {node: '>= 6'} + minimal-polyfills@2.2.2: resolution: {integrity: sha512-eEOUq/LH/DbLWihrxUP050Wi7H/N/I2dQT98Ep6SqOpmIbk4sXOI4wqalve66QoZa+6oljbZWU6I6T4dehQGmw==} minimal-polyfills@2.2.3: resolution: {integrity: sha512-oxdmJ9cL+xV72h0xYxp4tP2d5/fTBpP45H8DIOn9pASuF8a3IYTf+25fMGDYGiWW+MFsuog6KD6nfmhZJQ+uUw==} + minimalistic-assert@1.0.1: + resolution: {integrity: sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==} + + minimalistic-crypto-utils@1.0.1: + resolution: {integrity: sha512-JIYlbt6g8i5jKfJ3xz7rF0LXmv2TkDxBLUkiBeZ7bAx4GnnNMr8xFpGnOxn6GhTEHx3SjRrZEoU+j04prX1ktg==} + minimatch@10.0.1: resolution: {integrity: sha512-ethXTt3SGGR+95gudmqJ1eNhRO7eGEGIgYA9vnPatK4/etz2MEVDno5GMCibdMTuBMyElzIlgxMna3K94XDIDQ==} engines: {node: 20 || >=22} @@ -15846,12 +16600,30 @@ packages: ml-array-rescale@1.3.7: resolution: {integrity: sha512-48NGChTouvEo9KBctDfHC3udWnQKNKEWN0ziELvY3KG25GR5cA8K8wNVzracsqSW1QEkAXjTNx+ycgAv06/1mQ==} + ml-distance-euclidean@2.0.0: + resolution: {integrity: sha512-yC9/2o8QF0A3m/0IXqCTXCzz2pNEzvmcE/9HFKOZGnTjatvBbsn4lWYJkxENkA4Ug2fnYl7PXQxnPi21sgMy/Q==} + + ml-kmeans@4.2.1: + resolution: {integrity: sha512-MyXoWfDuoH+eYjPCIvfMXBuQ0K473APoc57oeFSFcGCHPZuppVv8cQKnhxYb8ZDEMN47MgcPtcHmueTeq6JmVQ==} + + ml-matrix@5.3.0: + resolution: {integrity: sha512-DuvdXYwfGRpM+7MVdvi/zSjiazn+8QPrACT3Xi0pQpYx5SXZ1WuFYwUDXTSmV9+hrCxRhrC4hrzesNcfjpvOsw==} + ml-matrix@6.12.1: resolution: {integrity: sha512-TJ+8eOFdp+INvzR4zAuwBQJznDUfktMtOB6g/hUcGh3rcyjxbz4Te57Pgri8Q9bhSQ7Zys4IYOGhFdnlgeB6Lw==} + ml-nearest-vector@2.0.1: + resolution: {integrity: sha512-gMPwNm3eed59ewJYiCK/+wElWBfNoD6JizH965ePiQgCo0pvQL63w4YdZhLs5eUV0iWcq6brVMUBL6iMySHnqg==} + + ml-random@0.5.0: + resolution: {integrity: sha512-zLJBmNb34LOz+vN6BD8l3aYm/VWYWbmAunrLMPs4dHf4gTl8BWlhil72j56HubPg86zrXioIs4qoHq7Topy6tw==} + ml-spectra-processing@14.13.0: resolution: {integrity: sha512-AZPE+XrBoRhSRwzUm0IbiQlAPbetDtndDnoq9VO/SzRkN82wrxJpU+urH4aaFVnxTJhxtGOI81FiAxjFe7xQtQ==} + ml-xsadd@2.0.0: + resolution: {integrity: sha512-VoAYUqmPRmzKbbqRejjqceGFp3VF81Qe8XXFGU0UXLxB7Mf4GGvyGq5Qn3k4AiQgDEV6WzobqlPOd+j0+m6IrA==} + ml-xsadd@3.0.1: resolution: {integrity: sha512-Fz2q6dwgzGM8wYKGArTUTZDGa4lQFA2Vi6orjGeTVRy22ZnQFKlJuwS9n8NRviqz1KHAHAzdKJwbnYhdo38uYg==} @@ -15861,6 +16633,11 @@ packages: mlly@1.7.4: resolution: {integrity: sha512-qmdSIPC4bDJXgZTCR7XosJiNKySV7O215tsPtDN9iEO/7q/76b/ijtgRu/+epFXSJhijtTCCGp3DWS549P3xKw==} + module-deps@6.2.3: + resolution: {integrity: sha512-fg7OZaQBcL4/L+AK5f4iVqf9OMbCclXfy/znXRxTVhJSeW5AIlS9AwheYwDaXM3lVW7OBeaeUEY3gbaC6cLlSA==} + engines: {node: '>= 0.8.0'} + hasBin: true + module-details-from-path@1.0.3: resolution: {integrity: sha512-ySViT69/76t8VhE1xXHK6Ch4NcDd26gx0MzKXLO+F7NOtnqH68d9zF94nT8ZWSxXh8ELOERsnJO/sWt1xZYw5A==} @@ -15871,6 +16648,9 @@ packages: resolution: {integrity: sha512-AbegBVI4sh6El+1gNwvD5YIck7nSA36weD7xvIxG4in80j/UoK8AEGaWnnz8v1GxonMCltmlNs5ZKbGvl9b1XQ==} engines: {node: '>= 0.8.0'} + morphdom@2.7.7: + resolution: {integrity: sha512-04GmsiBcalrSCNmzfo+UjU8tt3PhZJKzcOy+r1FlGA7/zri8wre3I1WkYN9PT3sIeIKfW9bpyElA+VzOg2E24g==} + mri@1.2.0: resolution: {integrity: sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==} engines: {node: '>=4'} @@ -15895,10 +16675,19 @@ packages: multipasta@0.2.5: resolution: {integrity: sha512-c8eMDb1WwZcE02WVjHoOmUVk7fnKU/RmUcosHACglrWAuPQsEJv+E8430sXj6jNc1jHw0zrS16aCjQh4BcEb4A==} + multistream@2.1.1: + resolution: {integrity: sha512-xasv76hl6nr1dEy3lPvy7Ej7K/Lx3O/FCvwge8PeVJpciPPoNCbaANcNiBug3IpdvTveZUcAV0DJzdnUDMesNQ==} + mustache@4.2.0: resolution: {integrity: sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==} hasBin: true + mute-stream@0.0.7: + resolution: {integrity: sha512-r65nCZhrbXXb6dXOACihYApHw2Q6pV0M3V0PSxd74N0+D8nzAdEAITq2oAjA1jVnKI+tGvEBUpqiMh0+rW6zDQ==} + + mutexify@1.4.0: + resolution: {integrity: sha512-pbYSsOrSB/AKN5h/WzzLRMFgZhClWccf2XIB4RSMC8JbquiB0e0/SH5AIfdQMdyHmYtv4seU7yV/TvAwPLJ1Yg==} + mz@2.7.0: resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==} @@ -15911,6 +16700,16 @@ packages: react: '*' react-dom: '*' + nanoassert@1.1.0: + resolution: {integrity: sha512-C40jQ3NzfkP53NsO8kEOFd79p4b9kDXQMwgiY1z8ZwrDZgUyom0AHwGegF4Dm99L+YoYhuaB0ceerUcXmqr1rQ==} + + nanobench@2.1.1: + resolution: {integrity: sha512-z+Vv7zElcjN+OpzAxAquUayFLGK3JI/ubCl0Oh64YQqsTGG09CGqieJVQw4ui8huDnnAgrvTv93qi5UaOoNj8A==} + hasBin: true + + nanohtml@1.10.0: + resolution: {integrity: sha512-r/3AQl+jxAxUIJRiKExUjBtFcE1cm4yTOsTIdVqqlxPNtBxJh522ANrcQYzdNHhPzbPgb7j6qujq6eGehBX0kg==} + nanoid@3.3.11: resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==} engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1} @@ -15945,9 +16744,32 @@ packages: natural-compare@1.4.0: resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==} - nearley@2.20.1: - resolution: {integrity: sha512-+Mc8UaAebFzgV+KpI5n7DasuuQCHA89dmwm7JXw3TV43ukfNQ9DnBH3Mdb2g/I4Fdxc26pwimBWvjIw0UAILSQ==} - hasBin: true + ndarray-blas-level1@1.1.3: + resolution: {integrity: sha512-g0Qzf+W0J2S/w1GeYlGuFjGRGGE+f+u8x4O8lhBtsrCaf++n/+YLTPKk1tovYmciL3zUePmwi/szoP5oj8zQvg==} + + ndarray-cholesky-factorization@1.0.2: + resolution: {integrity: sha512-8mXl8mMCDgv9plZem0ifolu39hHYu+IchdBX39VWS8X3f4935JDq5uGpxOJr2gXiy7QgY6MglAmoCjyHRWyqlQ==} + + ndarray-crout-decomposition@1.1.0: + resolution: {integrity: sha512-jcww9T/4thrVvBDCk5PivUScolTW1Lu6QWzvrxHMHAhZzTUzznvT/U/xfn40EfseiITLkHlST/0df5pn2yQHUQ==} + + ndarray-determinant@1.0.0: + resolution: {integrity: sha512-fJUlUhFZHwKP0lFsF2Si14dnkXBoiqKVzlv2nsUAcycsjjpuUkJGF0SXLHbRgl1wI6sgordV4P86bJ4ulcR6Yw==} + + ndarray-diagonal@1.0.0: + resolution: {integrity: sha512-r+LgakWgIt9xiRES42fwP6nc3pn4DjGSrs+OCPqiVTxtzCJ2L31KFypcHplSXG008j0IWZt6bx1+ZRbx+aQkfA==} + + ndarray-inv@0.2.0: + resolution: {integrity: sha512-rl+5PMUrP3WCYktFOK3myIiOwA6Q1oQddvQl2TN0tROcTXciCakha0QRMdE5t8ywlkbp1rmIKtWKFrEO7BAEUQ==} + + ndarray-ops@1.2.2: + resolution: {integrity: sha512-BppWAFRjMYF7N/r6Ie51q6D4fs0iiGmeXIACKY66fLpnwIui3Wc3CXiD/30mgLbDjPpSLrsqcp3Z62+IcHZsDw==} + + ndarray-scratch@1.2.0: + resolution: {integrity: sha512-a4pASwB1jQyJcKLYrwrladVfDZDUGc78qLJZbHyb1Q4rhte0URhzc6ALQpBcauwgov0sXLwZz3vYH5jKAhSMIg==} + + ndarray@1.0.19: + resolution: {integrity: sha512-B4JHA4vdyZU30ELBw3g7/p9bZupyew5a7tX1Y/gGeF2hafrPaQZhgrGQfsvgfYbgdFZjYwuEcnaobeM/WMW+HQ==} negotiator@0.6.3: resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==} @@ -15971,6 +16793,9 @@ packages: resolution: {integrity: sha512-kOCT/1MCPAxY5iUV3wytNFUMUolzuwd/VF/1KCx7kf6CutrOsTie+84zTGTpgQycjvfLdBBdvBvFLqFD2c0wkQ==} engines: {node: '>=18'} + next-tick@1.1.0: + resolution: {integrity: sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==} + next@14.1.0: resolution: {integrity: sha512-wlzrsbfeSU48YQBjZhDzOwhWhGsy+uQycR8bHAOt1LY1bn3zZEcDyHQOEoN3aWzQ8LHCAJ1nqrWCc9XF2+O45Q==} engines: {node: '>=18.17.0'} @@ -16072,6 +16897,9 @@ packages: nice-try@1.0.5: resolution: {integrity: sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==} + no-case@2.3.2: + resolution: {integrity: sha512-rmTZ9kz+f3rCvK2TD1Ue/oZlns7OGoIWP4fc3llxxRXlOkHKoWPPWJOfFYpITabSow43QJbRIoHQXtt10VldyQ==} + node-abi@3.75.0: resolution: {integrity: sha512-OhYaY5sDsIka7H7AtijtI9jwGYLyl29eQn/W623DiN/MIv5sUqc4g7BIDThX+gb7di9f6xK02nkp8sdfFWZLTg==} engines: {node: '>=10'} @@ -16137,6 +16965,10 @@ packages: engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} hasBin: true + normalize-html-whitespace@0.2.0: + resolution: {integrity: sha512-5CZAEQ4bQi8Msqw0GAT6rrkrjNN4ZKqAG3+jJMwms4O6XoMvh6ekwOueG4mRS1LbPUR1r9EdnhxxfpzMTOdzKw==} + engines: {node: '>= 0.10'} + normalize-package-data@2.5.0: resolution: {integrity: sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==} @@ -16194,6 +17026,10 @@ packages: num2fraction@1.2.2: resolution: {integrity: sha512-Y1wZESM7VUThYY+4W+X4ySH2maqcA+p7UR+w8VWNWVAd6lwuXXWz/w/Cz43J/dI2I+PS6wD5N+bJUF+gjWvIqg==} + number-is-nan@1.0.1: + resolution: {integrity: sha512-4jbtZXNAsfZbAHiiqjLPBiCl16dES1zI4Hpzzxw61Tk+loF+sBDBKx1ICKKKwIqQ7M0mFn1TmkN7euSncWgHiQ==} + engines: {node: '>=0.10.0'} + nypm@0.3.9: resolution: {integrity: sha512-BI2SdqqTHg2d4wJh8P9A1W+bslg33vOE9IZDY6eR2QC+Pu1iNBVZUqczrd43rJb+fMzHU7ltAYKsEFY/kHMFcw==} engines: {node: ^14.16.0 || >=16.10.0} @@ -16299,9 +17135,17 @@ packages: resolution: {integrity: sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA==} engines: {node: '>= 0.8'} + on-net-listen@1.1.2: + resolution: {integrity: sha512-y1HRYy8s/RlcBvDUwKXSmkODMdx4KSuIvloCnQYJ2LdBBC1asY4HtfhXwe3UWknLakATZDnbzht2Ijw3M1EqFg==} + engines: {node: '>=9.4.0 || ^8.9.4'} + once@1.4.0: resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==} + onetime@2.0.1: + resolution: {integrity: sha512-oyyPpiMaKARvvcgip+JV+7zci5L8D1W9RZIz2l1o08AM3pfspitVWnPt3mzHcBPp12oYMTy0pqrFs/C+m3EwsQ==} + engines: {node: '>=4'} + onetime@5.1.2: resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==} engines: {node: '>=6'} @@ -16320,6 +17164,10 @@ packages: resolution: {integrity: sha512-dtbI5oW7987hwC9qjJTyABldTaa19SuyJse1QboWv3b0qCcrrLNVDqBx1XgELAjh9QTVQaP/C5b1nhQebd1H2A==} engines: {node: '>=18'} + open@7.4.2: + resolution: {integrity: sha512-MVHddDVweXZF3awtlAS+6pgKLlm/JgxZ90+/NBurBoQctVOOB/zDdVjcyPzQ+0laDGbsWgrRkflI65sQeOgT9Q==} + engines: {node: '>=8'} + open@8.4.0: resolution: {integrity: sha512-XgFPPM+B28FtCCgSb9I+s9szOC1vZRSwgWsRUA5ylIxRTgKozqjOCrVOqGsYABPYK5qnfqClxZTFBa8PKt2v6Q==} engines: {node: '>=12'} @@ -16365,6 +17213,14 @@ packages: openid-client@6.3.3: resolution: {integrity: sha512-lTK8AV8SjqCM4qznLX0asVESAwzV39XTVdfMAM185ekuaZCnkWdPzcxMTXNlsm9tsUAMa1Q30MBmKAykdT1LWw==} + opn@5.5.0: + resolution: {integrity: sha512-PqHpggC9bLV0VeWcdKhkpxY+3JTzetLSqTCWL/z/tFIbI6G8JCjondXklT1JinczLz2Xib62sSp0T/gKT4KksA==} + engines: {node: '>=4'} + + optionator@0.8.3: + resolution: {integrity: sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==} + engines: {node: '>= 0.8.0'} + optionator@0.9.1: resolution: {integrity: sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==} engines: {node: '>= 0.8.0'} @@ -16373,6 +17229,13 @@ packages: resolution: {integrity: sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==} engines: {node: '>=10'} + os-browserify@0.3.0: + resolution: {integrity: sha512-gjcpUc3clBf9+210TRaDWbf+rZZZEshZ+DlXMRCeAjp0xhTrnQsKHypIy1J3d5hKdUzj69t708EHtU8P6bUn0A==} + + os-name@4.0.1: + resolution: {integrity: sha512-xl9MAoU97MH1Xt5K9ERft2YfCAoaO6msy1OBA0ozxEC0x0TmIoE6K3QvgJMMZA9yKGLmHXNY/YZoDbiGDj4zYw==} + engines: {node: '>=10'} + os-paths@7.4.0: resolution: {integrity: sha512-Ux1J4NUqC6tZayBqLN1kUlDAEvLiQlli/53sSddU4IN+h+3xxnv2HmRSMpVSvr1hvJzotfMs3ERvETGK+f4OwA==} engines: {node: '>= 4.0'} @@ -16423,6 +17286,10 @@ packages: resolution: {integrity: sha512-kuUqqHNUqoIWp/c467RI4X6mmyuojY5jGutNU0wVTmEOOfcuwLqyMVoAi9MKi2Ak+5i9+nhmrK4ufZE8069kHA==} engines: {node: '>=18'} + p-locate@3.0.0: + resolution: {integrity: sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==} + engines: {node: '>=6'} + p-locate@4.1.0: resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==} engines: {node: '>=8'} @@ -16504,10 +17371,20 @@ packages: pako@0.2.9: resolution: {integrity: sha512-NUcwaKxUxWrZLpDG+z/xZaCgQITkA/Dv4V/T6bw7VON6l1Xz/VnrBqrYjZQ12TamKHzITTfOEIYUj48y2KXImA==} + pako@1.0.11: + resolution: {integrity: sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==} + parent-module@1.0.1: resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==} engines: {node: '>=6'} + parents@1.0.1: + resolution: {integrity: sha512-mXKF3xkoUt5td2DoxpLmtOmZvko9VfFpwRwkKDHSNvgmpLAeBo18YDhcPbBzJq+QLCHMbGOfzia2cX4U+0v9Mg==} + + parse-asn1@5.1.9: + resolution: {integrity: sha512-fIYNuZ/HastSb80baGOuPRo1O9cf4baWw5WsAp7dBuUzeTD/BoaG8sVTdlPFksBE2lF21dN+A1AnrpIjSWqHHg==} + engines: {node: '>= 0.10'} + parse-duration@2.1.4: resolution: {integrity: sha512-b98m6MsCh+akxfyoz9w9dt0AlH2dfYLOBss5SdDsr9pkhKNvkWBXU/r8A4ahmIGByBOLV2+4YwfCuFxbDDaGyg==} @@ -16553,9 +17430,16 @@ packages: partysocket@1.0.2: resolution: {integrity: sha512-rAFOUKImaq+VBk2B+2RTBsWEvlnarEP53nchoUHzpVs8V6fG2/estihOTslTQUWHVuHEKDL5k8htG8K3TngyFA==} + path-browserify@1.0.1: + resolution: {integrity: sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==} + path-data-parser@0.1.0: resolution: {integrity: sha512-NOnmBpt5Y2RWbuv0LMzsayp3lVylAHLPUTut412ZA3l+C4uw4ZVkQbjShYCQ8TCpUMdPapr4YjUqLYD6v68j+w==} + path-exists@3.0.0: + resolution: {integrity: sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==} + engines: {node: '>=4'} + path-exists@4.0.0: resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} engines: {node: '>=8'} @@ -16583,6 +17467,10 @@ packages: path-parse@1.0.7: resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==} + path-platform@0.11.15: + resolution: {integrity: sha512-Y30dB6rab1A/nfEKsZxmr01nUotHX0c/ZiIAsCTatEe1CmS5Pm5He7fZ195bPT7RdquoaL8lLxFCMQi/bS7IJg==} + engines: {node: '>= 0.8.0'} + path-scurry@1.11.1: resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==} engines: {node: '>=16 || 14 >=14.18'} @@ -16616,6 +17504,10 @@ packages: resolution: {integrity: sha512-vE7JKRyES09KiunauX7nd2Q9/L7lhok4smP9RZTDeD4MVs72Dp2qNFVz39Nz5a0FVEW0BJR6C0DYrq6unoziZA==} engines: {node: '>= 14.16'} + pbkdf2@3.1.5: + resolution: {integrity: sha512-Q3CG/cYvCO1ye4QKkuH7EXxs3VC/rI1/trd+qX2+PolbaKG0H+bgcZzrTt96mMyRtejk+JMCiLUn3y29W8qmFQ==} + engines: {node: '>= 0.10'} + peberminta@0.9.0: resolution: {integrity: sha512-XIxfHpEuSJbITd1H3EeQwpcZbTLHc+VVr8ANI9t5sit565tsI4/xK3KWTUFE2e6QiangUkh3B0jihzmGnNrRsQ==} @@ -16793,6 +17685,10 @@ packages: pkg-types@2.3.0: resolution: {integrity: sha512-SIqCzDRg0s9npO5XQ3tNZioRY1uK06lA41ynBC1YmFTmnY6FjUjVt6s4LoADmwoig1qqD0oK8h1p/8mlMx8Oig==} + pkg-up@3.1.0: + resolution: {integrity: sha512-nDywThFk1i4BQK4twPQ6TA4RT8bDY96yeuCVBWL3ePARCiEKDRSrNGbFIgUJpLp+XeIR65v8ra7WuJOFUBtkMA==} + engines: {node: '>=8'} + platform@1.3.6: resolution: {integrity: sha512-fnWVljUchTro6RiCFvCXBbNhJc2NijN7oIQxbwsyL0buWJPG85v81ehlHI9fXrJsMNgTofEoWIQeClKpgxFLrg==} @@ -16827,6 +17723,12 @@ packages: postcss-functions@3.0.0: resolution: {integrity: sha512-N5yWXWKA+uhpLQ9ZhBRl2bIAdM6oVJYpDojuI1nF2SzXBimJcdjFwiAouBVbO5VuOF3qA6BSFWFc3wXbbj72XQ==} + postcss-import@13.0.0: + resolution: {integrity: sha512-LPUbm3ytpYopwQQjqgUH4S3EM/Gb9QsaSPP/5vnoi+oKVy3/mIk2sc0Paqw7RL57GpScm9MdIMUypw2znWiBpg==} + engines: {node: '>=10.0.0'} + peerDependencies: + postcss: ^8.0.0 + postcss-import@15.1.0: resolution: {integrity: sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==} engines: {node: '>=14.0.0'} @@ -17035,6 +17937,10 @@ packages: resolution: {integrity: sha512-+wZgbxNES/KlJs9q40F/1sfOd/j7f1O9JaHcW5Dsn3aUUOZg3L2bjpVUcKV2jvtElYfoTuQiNeMfQJ4kwUAhCQ==} engines: {node: '>=10'} + prelude-ls@1.1.2: + resolution: {integrity: sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w==} + engines: {node: '>= 0.8.0'} + prelude-ls@1.2.1: resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==} engines: {node: '>= 0.8.0'} @@ -17105,6 +18011,10 @@ packages: engines: {node: '>=14'} hasBin: true + pretty-bytes@5.6.0: + resolution: {integrity: sha512-FFw039TmrBqFK8ma/7OL3sDz/VytdtJr044/QUJtH0wK9lb9jLq9tJyIxUwtQJHwar2BqtiA4iCWSwo9JLkzFg==} + engines: {node: '>=6'} + pretty-format@27.5.1: resolution: {integrity: sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==} engines: {node: ^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0} @@ -17241,6 +18151,16 @@ packages: resolution: {integrity: sha512-RXyHaACeqXeqAKGLDl68rQKbmObRsTIn4TYVUUug1KfS47YWCo5MacGITEryugIgZqORCvJWEk4l449POg5Txg==} engines: {node: '>=12.0.0'} + protocol-buffers-encodings@1.2.0: + resolution: {integrity: sha512-daeNPuKh1NlLD1uDfbLpD+xyUTc07nEtfHwmBZmt/vH0B7VOM+JOCOpDcx9ZRpqHjAiIkGqyTDi+wfGSl17R9w==} + + protocol-buffers-schema@3.6.0: + resolution: {integrity: sha512-TdDRD+/QNdrCGCE7v8340QyuXd4kIWIgapsE2+n/SaGiSSbomYl4TjHlvIoCWRpE7wFt02EpB35VVA2ImcBVqw==} + + protocol-buffers@4.2.0: + resolution: {integrity: sha512-hNp56d5uuREVde7UqP+dmBkwzxrhJwYU5nL/mdivyFfkRZdgAgojkyBeU3jKo7ZHrjdSx6Q1CwUmYJI6INt20g==} + hasBin: true + proxy-addr@2.0.7: resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==} engines: {node: '>= 0.10'} @@ -17258,18 +18178,21 @@ packages: psl@1.9.0: resolution: {integrity: sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==} + public-encrypt@4.0.3: + resolution: {integrity: sha512-zVpa8oKZSz5bTMTFClc1fQOnyyEzpl5ozpi1B5YcvBrdohMjH2rfsBtyXcuNuwjsDIXmBYlF2N5FlJYhR29t8Q==} + pump@2.0.1: resolution: {integrity: sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==} - pump@3.0.0: - resolution: {integrity: sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==} - pump@3.0.2: resolution: {integrity: sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw==} pumpify@1.5.1: resolution: {integrity: sha512-oClZI37HvuUJJxSKKrC17bZ9Cu0ZYhEAGPsPUy9KlMUmv9dKX2o77RUmq7f3XjIxbwyGwYzbzQ1L2Ks8sIradQ==} + pumpify@2.0.1: + resolution: {integrity: sha512-m7KOje7jZxrmutanlkS1daj1dS6z6BgslzOXmcSEpIlCxM3VJH7lG5QLeck/6hgF6F4crFf01UtQmNsJfweTAw==} + punycode@1.4.1: resolution: {integrity: sha512-jmYNElW7yvO7TV33CjSmvSiE2yco3bV2czu/OzDKdMNVZQWfxCblURLhf+47syQRBntjfLdd/H0egrzIG+oaFQ==} @@ -17277,6 +18200,10 @@ packages: resolution: {integrity: sha512-LN6QV1IJ9ZhxWTNdktaPClrNfp8xdSAYS0Zk2ddX7XsXZAxckMHPCBcHRo0cTcEIgYPRiGEkmji3Idkh2yFtYw==} engines: {node: '>=6'} + pupa@2.1.1: + resolution: {integrity: sha512-l1jNAspIBSFqbT+y+5FosojNpVpF94nlI+wDUpqP9enwOTfHx9f0gh5nB96vl+6yTpsJsypeNrwfzPrKuHB41A==} + engines: {node: '>=8'} + puppeteer-core@24.15.0: resolution: {integrity: sha512-2iy0iBeWbNyhgiCGd/wvGrDSo73emNFjSxYOcyAqYiagkYt5q4cPfVXaVDKBsukgc2fIIfLAalBZlaxldxdDYg==} engines: {node: '>=18'} @@ -17312,9 +18239,19 @@ packages: quansync@0.2.11: resolution: {integrity: sha512-AifT7QEbW9Nri4tAwR5M/uzpBuqfZf+zwaEM/QkzEjj7NBuFD2rBuy0K3dE+8wltbezDV7JMA0WfnCPYRSYbXA==} + querystring-es3@0.2.1: + resolution: {integrity: sha512-773xhDQnZBMFobEiztv8LIl70ch5MSF/jUQVlhwFyBILqq96anmoctVIYz+ZRp0qbCKATTn6ev02M3r7Ga5vqA==} + engines: {node: '>=0.4.x'} + + querystringify@2.2.0: + resolution: {integrity: sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ==} + queue-microtask@1.2.3: resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} + queue-tick@1.0.1: + resolution: {integrity: sha512-kJt5qhMxoszgU/62PLP1CJytzd2NKetjSRnyuj31fDd3Rlcz3fzlFdFLD1SItunPwyqEOkca6GbV612BWfaBag==} + quick-format-unescaped@4.0.4: resolution: {integrity: sha512-tYC1Q1hgyRuHgloV/YXs2w15unPVh8qfu/qCTfhTYamaw7fyhumKa2yGpdSo87vY32rIclj+4fWYQXUMs9EHvg==} @@ -17322,12 +18259,9 @@ packages: resolution: {integrity: sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==} engines: {node: '>=8'} - railroad-diagrams@1.0.0: - resolution: {integrity: sha512-cz93DjNeLY0idrCNOH6PviZGRN9GJhsdm9hpn1YCS879fj4W+x5IFJhhkRZcwVgMmFF7R82UA/7Oh+R8lLZg6A==} - - randexp@0.4.6: - resolution: {integrity: sha512-80WNmd9DA0tmZrw9qQa62GPPWfuXJknrmVmLcxvq4uZBdYqb1wYoKTmnlGUchvVWe0XiLupYkBoXVOxz3C8DYQ==} - engines: {node: '>=0.12'} + quote-stream@1.0.2: + resolution: {integrity: sha512-kKr2uQ2AokadPjvTyKJQad9xELbZwYzWlNfI3Uz2j/ib5u6H9lDP7fUUR//rMycd0gv4Z5P1qXMfXR8YpIxrjQ==} + hasBin: true random-words@2.0.0: resolution: {integrity: sha512-uqpnDqFnYrZajgmvgjmBrSZL2V1UA/9bNPGrilo12CmBeBszoff/avElutUlwWxG12gvmCk/8dUhvHefYxzYjw==} @@ -17335,6 +18269,9 @@ packages: randombytes@2.1.0: resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==} + randomfill@1.0.4: + resolution: {integrity: sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==} + range-parser@1.2.1: resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==} engines: {node: '>= 0.6'} @@ -17537,6 +18474,9 @@ packages: read-cache@1.0.0: resolution: {integrity: sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==} + read-only-stream@2.0.0: + resolution: {integrity: sha512-3ALe0bjBVZtkdWKIcThYpQCLbBMd/+Tbh2CDSrAIDO3UsZ4Xs+tnyjv2MjCOMMgBG+AsUOeuP1cgtY1INISc8w==} + read-pkg-up@7.0.1: resolution: {integrity: sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==} engines: {node: '>=8'} @@ -17668,6 +18608,9 @@ packages: rehype-raw@7.0.0: resolution: {integrity: sha512-/aE8hCfKlQeA8LmyeyQvQF3eBiLRGNlfBJEvWH7ivp9sBqs7TNqBL5X3v157rM4IFETqDnIOO+z5M/biZbo9Ww==} + reinterval@1.1.0: + resolution: {integrity: sha512-QIRet3SYrGp0HUHO88jVskiG6seqUGC5iAG7AwI/BV4ypGcuqk9Du6YQBUOUqm9c8pw1eyLoIaONifRua1lsEQ==} + remark-frontmatter@4.0.1: resolution: {integrity: sha512-38fJrB0KnmD3E33a5jZC/5+gGAC2WKNiPw1/fdXJvijBlhA7RCsvJklrYJakS0HedninvaCYW8lQGf9C918GfA==} @@ -17803,6 +18746,9 @@ packages: resolution: {integrity: sha512-L9jEkOi3ASd9PYit2cwRfyppc9NoABujTP8/5gFcbERmo5jUoAKovIC3fsF17pkTnGsrByysqX+Kxd2OTNI1ww==} engines: {node: '>=0.10.5'} + requires-port@1.0.0: + resolution: {integrity: sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==} + resend@3.2.0: resolution: {integrity: sha512-lDHhexiFYPoLXy7zRlJ8D5eKxoXy6Tr9/elN3+Vv7PkUoYuSSD1fpiIfa/JYXEWyiyN2UczkCTLpkT8dDPJ4Pg==} engines: {node: '>=18'} @@ -17840,6 +18786,10 @@ packages: responselike@1.0.2: resolution: {integrity: sha512-/Fpe5guzJk1gPqdJLJR5u7eG/gNY4nImjbRDaVWVMRhne55TCmj2i9Q+54PBRfatRC8v/rIiv9BN0pMd9OV5EQ==} + restore-cursor@2.0.0: + resolution: {integrity: sha512-6IzJLuGi4+R14vwagDHX+JrXmPVtPpn4mffDJ1UdR7/Edm87fl6yi8mMBIVvFtJaNTUvjughmW4hwLhRG7gC1Q==} + engines: {node: '>=4'} + restore-cursor@3.1.0: resolution: {integrity: sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==} engines: {node: '>=8'} @@ -17852,6 +18802,9 @@ packages: resolution: {integrity: sha512-I1XxrZSQ+oErkRR4jYbAyEEu2I0avBvvMM5JN+6EBprOGRCs63ENqZ3vjavq8fBw2+62G5LF5XelKwuJpcvcxw==} engines: {node: '>=10'} + retimer@3.0.0: + resolution: {integrity: sha512-WKE0j11Pa0ZJI5YIk0nflGI7SQsfl2ljihVy7ogh7DeQSeYAUi0ubZ/yEueGtDfUPk6GH5LRw1hBdLq4IwUBWA==} + retry@0.12.0: resolution: {integrity: sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==} engines: {node: '>= 4'} @@ -17890,6 +18843,10 @@ packages: engines: {node: 20 || >=22} hasBin: true + ripemd160@2.0.3: + resolution: {integrity: sha512-5Di9UC0+8h1L6ZD2d7awM7E/T4uA1fJRlx6zk/NvdCCVEoAnFqvHmCuNeIKoCeIixBX/q8uM+6ycDvF8woqosA==} + engines: {node: '>= 0.8'} + robot3@0.4.1: resolution: {integrity: sha512-hzjy826lrxzx8eRgv80idkf8ua1JAepRc9Efdtj03N3KNJuznQCPlyCJ7gnUmDFwZCLQjxy567mQVKmdv2BsXQ==} @@ -17920,6 +18877,10 @@ packages: resolution: {integrity: sha512-9by4Ij99JUr/MCFBUkDKLWK3G9HVXmabKz9U5MlIAIuvuzkiOicRYs8XJLxX+xahD+mLiiCYDqF9dKAgtzKP1A==} engines: {node: '>=18'} + run-async@2.4.1: + resolution: {integrity: sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ==} + engines: {node: '>=0.12.0'} + run-exclusive@2.2.18: resolution: {integrity: sha512-TXr1Gkl1iEAOCCpBTRm/2m0+1KGjORcWpZZ+VGGTe7dYX8E4y8/fMvrHk0zf+kclec2R//tpvdBxgG0bDgaJfw==} @@ -17932,6 +18893,10 @@ packages: rw@1.3.3: resolution: {integrity: sha512-PdhdWy89SiZogBLaw42zdeqtRJ//zFd2PgQavcICDUgJT5oW10QCRKbJ6bg4r0/UY2M6BWd5tkxuGFRvCkgfHQ==} + rxjs@6.6.7: + resolution: {integrity: sha512-hTdwr+7yYNIT5n4AMYp85KA6yw2Va0FLa3Rguvbpa4W3I5xynaBZo41cM3XM+4Q6fRMj3sBYIR1VAmZMXYJvRQ==} + engines: {npm: '>=2.0.0'} + rxjs@7.8.2: resolution: {integrity: sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==} @@ -17986,6 +18951,9 @@ packages: resolution: {integrity: sha512-eflK8wEtyOE6+hsaRVPxvUKYCpRgzLqDTb8krvAsRIwOGlHoSgYLgBXoubGgLd2fT41/OUYdb48v4k4WWHQurA==} engines: {node: '>= 10.13.0'} + scope-analyzer@2.1.2: + resolution: {integrity: sha512-5cfCmsTYV/wPaRIItNxatw02ua/MThdIUNnUOCYp+3LSEJvnG804ANw2VLaavNILIfWXF1D1G2KNANkBBvInwQ==} + screenfull@5.2.0: resolution: {integrity: sha512-9BakfsO2aUQN2K9Fdbj87RJIEZ82Q9IGim7FqM5OsebfoFC6ZHXgDq/KvniuLTPdeM8wY2o6Dj3WQ7KeQCj3cA==} engines: {node: '>=0.10.0'} @@ -18005,6 +18973,10 @@ packages: sembear@0.5.2: resolution: {integrity: sha512-Ij1vCAdFgWABd7zTg50Xw1/p0JgESNxuLlneEAsmBrKishA06ulTTL/SHGmNy2Zud7+rKrHTKNI6moJsn1ppAQ==} + semver-diff@3.1.1: + resolution: {integrity: sha512-GX0Ix/CJcHyB8c4ykpHGIAvLyOwOobtM/8d+TQkAd81/bEjgPHrfba41Vpesr7jX/t8Uh+R3EX9eAS5be+jQYg==} + engines: {node: '>=8'} + semver@5.7.1: resolution: {integrity: sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==} hasBin: true @@ -18075,6 +19047,14 @@ packages: setprototypeof@1.2.0: resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==} + sha.js@2.4.12: + resolution: {integrity: sha512-8LzC5+bvI45BjpfXU8V5fdU2mfeKiQe1D1gIMn7XUlF3OTUrpdJpPPH4EMAnF0DsHHdSZqCdSss5qCmJKuiO3w==} + engines: {node: '>= 0.10'} + hasBin: true + + shallow-copy@0.0.1: + resolution: {integrity: sha512-b6i4ZpVuUxB9h5gfCxPiusKYkqTMOjEbBs4wMaFbkfia4yFv92UKZ6Df8WXcKbn08JNL/abvg3FnMAOfakDvUw==} + sharp@0.33.5: resolution: {integrity: sha512-haPVm1EkS9pgvHrQ/F3Xy+hgcuMV0Wm9vfIBSiwZ05k+xgb0PkBQpGsAA/oWdDobNaZTH5ppvHtzCFbnSEwHVw==} engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} @@ -18083,6 +19063,10 @@ packages: resolution: {integrity: sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==} engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} + shasum-object@1.0.1: + resolution: {integrity: sha512-SsC+1tW7XKQ/94D4k1JhLmjDFpVGET/Nf54jVDtbavbALf8Zhp0Td9zTlxScjMW6nbEIrpADtPWfLk9iCXzHDQ==} + hasBin: true + shebang-command@1.2.0: resolution: {integrity: sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==} engines: {node: '>=0.10.0'} @@ -18113,6 +19097,10 @@ packages: shimmer@1.2.1: resolution: {integrity: sha512-sQTKC1Re/rM6XyFM6fIAGHRPVGvyXfgzIDvzoq608vM+jeyVD0Tu1E6Np0Kc2zAIFWIj963V2800iF/9LPieQw==} + showdown@1.9.1: + resolution: {integrity: sha512-9cGuS382HcvExtf5AHk7Cb4pAeQQ+h0eTr33V1mu+crYWV4KvWAw6el92bDrqGEk5d46Ai/fhbEUwqJ/mTCNEA==} + hasBin: true + side-channel-list@1.0.0: resolution: {integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==} engines: {node: '>= 0.4'} @@ -18139,6 +19127,9 @@ packages: resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==} engines: {node: '>=14'} + signed-varint@2.0.1: + resolution: {integrity: sha512-abgDPg1106vuZZOvw7cFwdCABddfJRz5akcCcchzTbhyhYnsG31y4AlZEgp315T7W3nQq5P4xeOm186ZiPVFzw==} + simple-concat@1.0.1: resolution: {integrity: sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==} @@ -18154,6 +19145,12 @@ packages: simplur@3.0.1: resolution: {integrity: sha512-bBAoTn75tuKh83opmZ1VoyVoQIsvLCKzSxuasAxbnKofrT8eGyOEIaXSuNfhi/hI160+fwsR7ObcbBpOyzDvXg==} + single-line-log@1.1.2: + resolution: {integrity: sha512-awzaaIPtYFdexLr6TBpcZSGPB6D1RInNO/qNetgaJloPDF/D0GkVtLvGEp8InfmLV7CyLyQ5fIRP+tVN/JmWQA==} + + sinusoidal-decimal@1.0.0: + resolution: {integrity: sha512-KPUi1ZqLocV64n0AuV+g4VDjAM+tEEY66nUd+rYaVBHIfeheGGUvIxe9bf7Mpc1PonDTVW2uRr9nigQa9odvuA==} + sirv@2.0.4: resolution: {integrity: sha512-94Bdh3cC2PKrbgSOUqTiGPWVZeSiXfKOVZNJniWoqrWrRkB1CJzBU3NEbiTsPcYy1lDsANA/THzS+9WBiy5nfQ==} engines: {node: '>= 10'} @@ -18220,6 +19217,9 @@ packages: resolution: {integrity: sha512-l5x7VUUWbjVFbafGLxPWkYsHIhEvmF85tbIeFZWc8ZPtoMyybuEhL7Jye/ooC4/d48FgOjSJXgsF/AJPYCW8Zw==} engines: {node: '>= 10.0.0', npm: '>= 3.0.0'} + sonic-boom@1.4.1: + resolution: {integrity: sha512-LRHh/A8tpW7ru89lrlkU4AszXt1dbwSjVWguGrmlxE7tawVmDBlI1PILMkXAxJTwqhgsEeTHzj36D5CmHgQmNg==} + sonic-boom@4.2.0: resolution: {integrity: sha512-INb7TM37/mAcsGmc9hyyI6+QR3rR1zVRu36B0NeGXKnOOLiZOfER5SA+N7X7k3yUYRzLWafduTDvJAfDswwEww==} @@ -18267,6 +19267,10 @@ packages: engines: {node: '>= 8'} deprecated: The work that was done in this beta branch won't be included in future versions + sourcemap-codec@1.4.8: + resolution: {integrity: sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==} + deprecated: Please use @jridgewell/sourcemap-codec instead + space-separated-tokens@2.0.2: resolution: {integrity: sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==} @@ -18354,6 +19358,12 @@ packages: standard-as-callback@2.1.0: resolution: {integrity: sha512-qoRRSyROncaz1z0mvYqIE4lCd9p2R90i6GxW3uZv5ucSu8tU7B5HXUP1gG8pVZsYNVaXjk8ClXHPttLyxAL48A==} + static-eval@2.1.1: + resolution: {integrity: sha512-MgWpQ/ZjGieSVB3eOJVs4OA2LT/q1vx98KPCTTQPzq/aLr0YUXTsgryTXr4SLfR0ZfUUCiedM9n/ABeDIyy4mA==} + + static-module@3.0.4: + resolution: {integrity: sha512-gb0v0rrgpBkifXCa3yZXxqVmXDVE+ETXj6YlC/jt5VzOnGXR2C15+++eXuMDUYsePnbhf+lwW0pE1UXyOLtGCw==} + statuses@2.0.1: resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==} engines: {node: '>= 0.8'} @@ -18367,16 +19377,35 @@ packages: std-env@3.9.0: resolution: {integrity: sha512-UGvjygr6F6tpH7o2qyqR6QYpwraIjKSdtzyBdyytFOHmPZY917kwdwLG0RbOjWOnKmnm3PeHjaoLLMie7kPLQw==} + stream-browserify@3.0.0: + resolution: {integrity: sha512-H73RAHsVBapbim0tU2JwwOiXUj+fikfiaoYAKHF3VJfA0pe2BCzkhAHBlLG6REzE+2WNZcxOXjK7lkso+9euLA==} + stream-buffers@3.0.2: resolution: {integrity: sha512-DQi1h8VEBA/lURbSwFtEHnSTb9s2/pwLEaFuNhXwy1Dx3Sa0lOuYT2yNUr4/j2fs8oCAMANtrZ5OrPZtyVs3MQ==} engines: {node: '>= 0.10.0'} + stream-collector@1.0.1: + resolution: {integrity: sha512-b9/C+HonJNmPmdBFGa0aJc9cai07YksAFvmchnSobiIitppiBn6wfAN7rLGEz6fE30Rj9EC/UVkovzoLJTpC5Q==} + + stream-combiner2@1.1.1: + resolution: {integrity: sha512-3PnJbYgS56AeWgtKF5jtJRT6uFJe56Z0Hc5Ngg/6sI6rIt8iiMBTa9cvdyFfpMQjaVHr8dusbNeFGIIonxOvKw==} + + stream-http@3.2.0: + resolution: {integrity: sha512-Oq1bLqisTyK3TSCXpPbT4sdeYNdmyZJv1LxpEm2vu1ZhK89kSE5YXwZc3cWk0MagGaKriBh9mCFbVGtO+vY29A==} + stream-shift@1.0.3: resolution: {integrity: sha512-76ORR0DO1o1hlKwTbi/DM3EXWGf3ZJYO8cXX5RJwnul2DEg2oyoZyjLNoQM8WsvZiFKCRfC1O0J7iCvie3RZmQ==} stream-slice@0.1.2: resolution: {integrity: sha512-QzQxpoacatkreL6jsxnVb7X5R/pGw9OUv2qWTYWnmLpg4NdN31snPy/f3TdQE1ZUXaThRvj1Zw4/OGg0ZkaLMA==} + stream-splicer@2.0.1: + resolution: {integrity: sha512-Xizh4/NPuYSyAXyT7g8IvdJ9HJpxIGL9PjyhtywCZvvP0OPIdqyrr4dMikeuvY8xahpdKEBlBTySe583totajg==} + + stream-template@0.0.10: + resolution: {integrity: sha512-whIqf/ljJ88dr0z6iNFtJq09rs4R6JxJOnIqGthC3rHFEMYq6ssm4sPYILXEPrFYncMjF39An6MBys1o5BC19w==} + engines: {node: '>=4.0.0'} + stream-transform@2.1.3: resolution: {integrity: sha512-9GHUiM5hMiCi6Y03jD2ARC1ettBXkQBoQAe7nJsPknnI0ow10aXjTnew8QtYQmLjzn974BnmWEAJgCY6ZP1DeQ==} @@ -18385,6 +19414,9 @@ packages: peerDependencies: react: ^18.0.0 || ^19.0.0 + streaming-json-stringify@3.1.0: + resolution: {integrity: sha512-axtfs3BDxAsrZ9swD163FBrXZ8dhJJp6kUI6C97TvUZG9RHKfbg9nFbXqEheFNOb3IYMEt2ag9F62sWLFUZ4ug==} + streamsearch@1.1.0: resolution: {integrity: sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==} engines: {node: '>=10.0.0'} @@ -18395,6 +19427,18 @@ packages: string-hash@1.1.3: resolution: {integrity: sha512-kJUvRUFK49aub+a7T1nNE66EJbZBMnBgoC1UbCZ5n6bsZKBRga4KgBRTMn/pFkeCZSYtNeSyMxPDM0AXWELk2A==} + string-width@1.0.2: + resolution: {integrity: sha512-0XsVpQLnVCXHJfyEs8tC0zpTVIr5PKKsQtkT29IwupnPTjtPmQ3xT/4yCREF9hYkV/3M3kzcUTSAZT6a6h81tw==} + engines: {node: '>=0.10.0'} + + string-width@2.1.1: + resolution: {integrity: sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==} + engines: {node: '>=4'} + + string-width@3.1.0: + resolution: {integrity: sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==} + engines: {node: '>=6'} + string-width@4.2.3: resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} engines: {node: '>=8'} @@ -18436,6 +19480,18 @@ packages: stringify-entities@4.0.3: resolution: {integrity: sha512-BP9nNHMhhfcMbiuQKCqMjhDP5yBCAxsPu4pHFFzJ6Alo9dZgY4VLDPutXqIjpRiMoKdp7Av85Gr73Q5uH9k7+g==} + strip-ansi@3.0.1: + resolution: {integrity: sha512-VhumSSbBqDTP8p2ZLKj40UjBCV4+v8bUSEpUb4KjRgWk9pbqGF4REFj6KEagidb2f/M6AzC0EmFyDNGaw9OCzg==} + engines: {node: '>=0.10.0'} + + strip-ansi@4.0.0: + resolution: {integrity: sha512-4XaJ2zQdCzROZDivEVIDPkcQn8LMFSa8kj8Gxb/Lnwzv9A8VctNZ+lfivC/sV3ivW8ElJTERXZoPBRrZKkNKow==} + engines: {node: '>=4'} + + strip-ansi@5.2.0: + resolution: {integrity: sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==} + engines: {node: '>=6'} + strip-ansi@6.0.1: resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==} engines: {node: '>=8'} @@ -18528,11 +19584,17 @@ packages: stylis@4.3.6: resolution: {integrity: sha512-yQ3rwFWRfwNUY7H5vpU0wfdkNSnvnJinhF9830Swlaxl03zsOjCfmX0ugac+3LtK0lYSgwL/KXc8oYL3mG4YFQ==} + subarg@1.0.0: + resolution: {integrity: sha512-RIrIdRY0X1xojthNcVtgT9sjpOGagEUKpZdgBUi054OEPFo282yg+zE+t1Rj3+RqKq2xStL7uUHhY+AjbC4BXg==} + sucrase@3.35.0: resolution: {integrity: sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==} engines: {node: '>=16 || 14 >=14.17'} hasBin: true + summary@2.1.0: + resolution: {integrity: sha512-nMIjMrd5Z2nuB2RZCKJfFMjgS3fygbeyGk9PxPPaJR1RIcyN9yn4A63Isovzm3ZtQuEkLBVgMdPup8UeLH7aQw==} + superagent@9.0.2: resolution: {integrity: sha512-xuW7dzkUpcJq7QnhOsnNUgtYp3xRwpt2F7abdRYIpCsAt0hhUqia0EdxyXZQQpNmGtsCzYHryaKSV3q3GJnq7w==} engines: {node: '>=14.18.0'} @@ -18555,6 +19617,10 @@ packages: resolution: {integrity: sha512-HRVVSbCCMbj7/kdWF9Q+bbckjBHLtHMEoJWlkmYzzdwhYMkjkOwubLM6t7NbWKjgKamGDrWL1++KrjUO1t9oAQ==} engines: {node: '>=18'} + supports-color@2.0.0: + resolution: {integrity: sha512-KKNVtd6pCYgPIKU4cp2733HWYCpplQhddZLBUryaAHou723x+FRzQ5Df824Fj+IyyuiQTRoub4SnIFfIcrp70g==} + engines: {node: '>=0.8.0'} + supports-color@5.5.0: resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==} engines: {node: '>=4'} @@ -18605,6 +19671,9 @@ packages: resolution: {integrity: sha512-L1dapNV6vu2s/4Sputv8xGsCdAVlb5nRDMFU/E27D44l5U6cw1g0dGd45uLc+OXjNMmF4ntiMdCimzcjFKQI8Q==} engines: {node: ^14.18.0 || >=16.0.0} + syntax-error@1.4.0: + resolution: {integrity: sha512-YPPlu67mdnHGTup2A8ff7BC2Pjq0e0Yp/IyTFN03zWO0RcK07uLcbi7C2KpGR2FvWbaB0+bfE27a+sBKebSo7w==} + systeminformation@5.23.8: resolution: {integrity: sha512-Osd24mNKe6jr/YoXLLK3k8TMdzaxDffhpCxgkfgBHcapykIkd50HXThM3TCEuHO2pPuCsSx2ms/SunqhU5MmsQ==} engines: {node: '>=8.0.0'} @@ -18615,6 +19684,9 @@ packages: resolution: {integrity: sha512-9kY+CygyYM6j02t5YFHbNz2FN5QmYGv9zAjVp4lCDjlCw7amdckXlEt/bjMhUIfj4ThGRE4gCUH5+yGnNuPo5A==} engines: {node: '>=10.0.0'} + tachyons@4.12.0: + resolution: {integrity: sha512-2nA2IrYFy3raCM9fxJ2KODRGHVSZNTW3BR0YnlGsLUf1DA3pk3YfWZ/DdfbnZK6zLZS+jUenlUGJsKcA5fUiZg==} + tailwind-merge@1.12.0: resolution: {integrity: sha512-Y17eDp7FtN1+JJ4OY0Bqv9OA41O+MS8c1Iyr3T6JFLnOgLg3EvcyMKZAnQ8AGyvB5Nxm3t9Xb5Mhe139m8QT/g==} @@ -18752,9 +19824,9 @@ packages: uglify-js: optional: true - terser@5.17.1: - resolution: {integrity: sha512-hVl35zClmpisy6oaoKALOpS0rDYLxRFLHhRuDlEGTKey9qHjS1w9GMORjuwIMt70Wan4lwsLYyWDVnWgF+KUEw==} - engines: {node: '>=10'} + terser@4.8.1: + resolution: {integrity: sha512-4GnLC0x667eJG0ewJTa6z/yXrbLGv80D9Ru6HIpCQmO+Q4PfEtBFi0ObSckqwL6VyQv/7ENJieXHo2ANmdQwgw==} + engines: {node: '>=6.0.0'} hasBin: true terser@5.44.1: @@ -18796,6 +19868,23 @@ packages: through2@2.0.5: resolution: {integrity: sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==} + through2@3.0.2: + resolution: {integrity: sha512-enaDQ4MUyP2W6ZyT6EsMzqBPZaM/avg8iuo+l2d3QCs0J+6RaqkHV/2/lOwDTueBHeJ/2LG9lrLW3d5rWPucuQ==} + + through2@4.0.2: + resolution: {integrity: sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw==} + + through@2.3.8: + resolution: {integrity: sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==} + + timers-browserify@1.4.2: + resolution: {integrity: sha512-PIxwAupJZiYU4JmVZYwXp9FKsHMXb5h0ZEFyuXTAn8WLHOlcij+FEcbrvDsom1o5dr1YggEtFbECvGCW2sT53Q==} + engines: {node: '>=0.6.0'} + + timestring@6.0.0: + resolution: {integrity: sha512-wMctrWD2HZZLuIlchlkE2dfXJh7J2KDI9Dwl+2abPYg0mswQHfOAyQW3jJg1pY5VfttSINZuKcXoB3FGypVklA==} + engines: {node: '>=8'} + tiny-case@1.0.3: resolution: {integrity: sha512-Eet/eeMhkO6TX8mnUteS9zgPbUMQa4I6Kkp5ORiBD5476/m+PIRiumP5tmh5ioJpH7k51Kehawy2UDfsnxxY8Q==} @@ -18876,6 +19965,10 @@ packages: resolution: {integrity: sha512-nZD7m9iCPC5g0pYmcaxogYKggSfLsdxl8of3Q/oIbqCqLLIO9IAF0GWjX1z9NZRHPiXv8Wex4yDCaZsgEw0Y8w==} engines: {node: '>=14.14'} + to-buffer@1.2.2: + resolution: {integrity: sha512-db0E3UJjcFhpDhAF4tLo03oli3pwl3dbnzXOUIlRKrp+ldk/VUxzpWYZENsw2SZiuBjHAk7DfB0VU7NKdpb6sw==} + engines: {node: '>= 0.4'} + to-fast-properties@2.0.0: resolution: {integrity: sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==} engines: {node: '>=4'} @@ -18917,12 +20010,19 @@ packages: resolution: {integrity: sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==} engines: {node: '>=0.8'} + tough-cookie@4.1.4: + resolution: {integrity: sha512-Loo5UUvLD9ScZ6jh8beX1T6sO1w2/MpCRpEP7V280GKMVUQ0Jzar2U3UJPsrdbziLEMMhu3Ujnq//rhiFuIeag==} + engines: {node: '>=6'} + tr46@0.0.3: resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==} tr46@1.0.1: resolution: {integrity: sha512-dTpowEjclQ7Kgx5SdBkqRzVhERQXov8/l9Ft9dVM9fmg0W0KQSVaXX9T4i6twCPNtYiZM53lpSSUAwJbFPOHxA==} + transform-ast@2.4.4: + resolution: {integrity: sha512-AxjeZAcIOUO2lev2GDe3/xZ1Q0cVGjIMk5IsriTy8zbWlsEnjeB025AhkhBJHoy997mXpLd4R+kRbvnnQVuQHQ==} + tree-kill@1.2.2: resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==} hasBin: true @@ -19074,6 +20174,12 @@ packages: engines: {node: '>=18.0.0'} hasBin: true + ttest@3.0.0: + resolution: {integrity: sha512-bLo+LdYokiDZHVFIWJmC5afoh7wZ+o1h++0XXKh01+yprzz8CnaiGNcbcbqP0e3+iyDqclLI+rM0j/9AwmRljw==} + + tty-browserify@0.0.1: + resolution: {integrity: sha512-C3TaO7K81YvjCgQH9Q1S3R3P3BtN3RIM8n+OvX4il1K1zgE8ZhI0op7kClgkxtutIE8hQrcrHBXvIheqKUUCxw==} + tty-table@4.1.6: resolution: {integrity: sha512-kRj5CBzOrakV4VRRY5kUWbNYvo/FpOsz65DzI5op9P+cHov3+IqPbo1JE1ZnQGkHdZgNFDsrEjrfqqy/Ply9fw==} engines: {node: '>=8.0.0'} @@ -19092,6 +20198,9 @@ packages: cpu: [arm64] os: [darwin] + turbo-json-parse@2.3.0: + resolution: {integrity: sha512-f1CWo4TNqwicXXUAOU5K9RZX6MhEdtOPT+FmgPhiet0a698+46KiXzMHpl8V4fieUa6qXr968uuNbHDSfXjkcQ==} + turbo-linux-64@1.10.3: resolution: {integrity: sha512-kvAisGKE7xHJdyMxZLvg53zvHxjqPK1UVj4757PQqtx9dnjYHSc8epmivE6niPgDHon5YqImzArCjVZJYpIGHQ==} cpu: [x64] @@ -19122,10 +20231,17 @@ packages: tweetnacl@0.14.5: resolution: {integrity: sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==} + type-check@0.3.2: + resolution: {integrity: sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==} + engines: {node: '>= 0.8.0'} + type-check@0.4.0: resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==} engines: {node: '>= 0.8.0'} + type-component@0.0.1: + resolution: {integrity: sha512-mDZRBQS2yZkwRQKfjJvQ8UIYJeBNNWCq+HBNstl9N5s9jZ4dkVYXEGkVPsSCEh5Ld4JM1kmrZTzjnrqSAIQ7dw==} + type-fest@0.13.1: resolution: {integrity: sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==} engines: {node: '>=10'} @@ -19162,10 +20278,17 @@ packages: resolution: {integrity: sha512-gd0sGezQYCbWSbkZr75mln4YBidWUN60+devscpLF5mtRDUpiaTvKpBNrdaCvel1NdR2k6vclXybU5fBd2i+nw==} engines: {node: '>= 0.6'} + type@2.7.3: + resolution: {integrity: sha512-8j+1QmAbPvLZow5Qpi6NCaN8FB60p/6x8/vfNqOk/hC+HuvFZhL4+WfekuhQLiqFZXOgQdrs3B+XxEmCc6b3FQ==} + typed-array-buffer@1.0.2: resolution: {integrity: sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ==} engines: {node: '>= 0.4'} + typed-array-buffer@1.0.3: + resolution: {integrity: sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==} + engines: {node: '>= 0.4'} + typed-array-byte-length@1.0.1: resolution: {integrity: sha512-3iMJ9q0ao7WE9tWcaYKIptkNBuOIcZCCT0d4MRvuuH88fEoEH62IuQe0OtraD3ebQEoTRk8XCBoknUNc1Y67pw==} engines: {node: '>= 0.4'} @@ -19187,6 +20310,15 @@ packages: typed-query-selector@2.12.0: resolution: {integrity: sha512-SbklCd1F0EiZOyPiW192rrHZzZ5sBijB6xM+cpmrwDqObvdtunOHHIk9fCGsoK5JVIYXoyEp4iEdE3upFH3PAg==} + typedarray-pool@1.2.0: + resolution: {integrity: sha512-YTSQbzX43yvtpfRtIDAYygoYtgT+Rpjuxy9iOpczrjpXLgGoyG7aS5USJXV2d3nn8uHTeb9rXDvzS27zUg5KYQ==} + + typedarray-to-buffer@3.1.5: + resolution: {integrity: sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==} + + typedarray@0.0.6: + resolution: {integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==} + typescript@5.1.6: resolution: {integrity: sha512-zaWCozRZ6DLEWAWFrVDz1H6FVXzUSfTy5FUMWsQlU8Ym5JP9eO4xkTIROFCQvhQf61z6O/G6ugw3SgAnvvm+HA==} engines: {node: '>=14.17'} @@ -19229,12 +20361,20 @@ packages: resolution: {integrity: sha512-DU9F5t1tihdafuNyW3fIrXUFHHiHxmwuQSGVGIbSpqkc93IH4P0dU8nPhk0gOW7ARxaFu4+P/9cxVwn6PdnIaQ==} engines: {node: '>=16'} + umd@3.0.3: + resolution: {integrity: sha512-4IcGSufhFshvLNcMCV80UnQVlZ5pMOC8mvNPForqwA4+lzYQuetTESLDQkeLmihq8bRcnpbQa48Wb8Lh16/xow==} + hasBin: true + unbox-primitive@1.0.2: resolution: {integrity: sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==} uncrypto@0.1.3: resolution: {integrity: sha512-Ql87qFHB3s/De2ClA9e0gsnS6zXG27SkTiSJwjCc9MebbfapQfuPzumMIUMi38ezPZVNFcHI9sUIepeQfw8J8Q==} + undeclared-identifiers@1.1.3: + resolution: {integrity: sha512-pJOW4nxjlmfwKApE4zvxLScM/njmwj/DiUBv7EabwE4O8kRUy+HIwxQtZLBPll/jx1LJyBcqNfB3/cpv9EZwOw==} + hasBin: true + undici-types@5.26.5: resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==} @@ -19263,6 +20403,9 @@ packages: unified@11.0.5: resolution: {integrity: sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==} + uniq@1.0.1: + resolution: {integrity: sha512-Gw+zz50YNKPDKXs+9d+aKAjVwpjNwqzvNpLigIruT4HA9lMZNdMqs9x07kKHB/L9WRzqp4+DlTU5s4wG2esdoA==} + unique-filename@3.0.0: resolution: {integrity: sha512-afXhuC55wkAmZ0P18QsVE6kp8JaxrEokN2HGIoIVv2ijHQd419H0+6EigAFcIzXeMIkcIkNBpB3L/DXB3cTS/g==} engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} @@ -19271,6 +20414,10 @@ packages: resolution: {integrity: sha512-WrcA6AyEfqDX5bWige/4NQfPZMtASNVxdmWR76WESYQVAACSgWcR6e9i0mofqqBxYFtL4oAxPIptY73/0YE1DQ==} engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} + unique-string@2.0.0: + resolution: {integrity: sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==} + engines: {node: '>=8'} + unist-util-find-after@5.0.0: resolution: {integrity: sha512-amQa0Ep2m6hE2g72AugUItjbuM8X8cGQnFoHk0pGfrFeT9GZhzN5SW8nRsiGKK7Aif4CrACPENkA6P/Lw6fHGQ==} @@ -19329,6 +20476,10 @@ packages: resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==} engines: {node: '>= 4.0.0'} + universalify@0.2.0: + resolution: {integrity: sha512-CJ1QgKmNg3CwvAv/kOFmtnEN05f0D/cn9QntgNOQlQF9dgvVTHj3t+8JPdjqawCHk7V/KA+fbUqzZ9XWhcqPUg==} + engines: {node: '>= 4.0.0'} + universalify@2.0.0: resolution: {integrity: sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==} engines: {node: '>= 10.0.0'} @@ -19355,6 +20506,10 @@ packages: peerDependencies: browserslist: '>= 4.21.0' + update-notifier@5.1.0: + resolution: {integrity: sha512-ItnICHbeMh9GqUy31hFPrD1kcuZ3rpxDZbf4KUDavXwS0bW5m7SLbDQpGX3UYr072cbrF5hFUs3r5tUsPwjfHw==} + engines: {node: '>=10'} + uploadthing@7.1.0: resolution: {integrity: sha512-l1bRHs+q/YLx3XwBav98t4Bl1wLWaskhPEwopxtYgiRrxX5nW3uUuSP0RJ9eKwx0+6ZhHWxHDvShf7ZLledqmQ==} engines: {node: '>=18.13.0'} @@ -19376,6 +20531,9 @@ packages: tailwindcss: optional: true + upper-case@1.1.3: + resolution: {integrity: sha512-WRbjgmYzgXkCV7zNVpy5YgrHgbBv126rMALQQMrmzOVC4GM2waQ9x7xtm8VU+1yF2kWyPzI9zbZ48n4vSxwfSA==} + uri-js@4.4.1: resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} @@ -19383,6 +20541,13 @@ packages: resolution: {integrity: sha512-NjFKA0DidqPa5ciFcSrXnAltTtzz84ogy+NebPvfEgAck0+TNg4UJ4IN+fB7zRZfbgUf0syOo9MDxFkDSMuFaQ==} engines: {node: '>=4'} + url-parse@1.5.10: + resolution: {integrity: sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==} + + url@0.11.4: + resolution: {integrity: sha512-oCwdVC7mTuWiPyjLUz/COz5TLk6wgp0RCsN+wHZ2Ekneac9w8uuV0njcbbie2ME+Vs+d6duwmYuR3HgQXs1fOg==} + engines: {node: '>= 0.4'} + urlpattern-polyfill@9.0.0: resolution: {integrity: sha512-WHN8KDQblxd32odxeIgo83rdVDE2bvdkb86it7bMhYZwWKJz0+O0RK/eZiHYnM+zgt/U7hAHOlCQGfjjvSkw2g==} @@ -19423,6 +20588,12 @@ packages: util-deprecate@1.0.2: resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==} + util-extend@1.0.3: + resolution: {integrity: sha512-mLs5zAK+ctllYBj+iAQvlDCwoxU/WDOUaJkcFudeiAX6OajC6BKXJUa9a+tbtkC11dz2Ufb7h0lyvIOVn4LADA==} + + util@0.10.4: + resolution: {integrity: sha512-0Pm9hTQ3se5ll1XihRic3FDIku70C+iHUdT/W926rSgHV5QgXsYbKZN8MSC3tJtSkhuROzvsQjAaFENRXr+19A==} + util@0.12.5: resolution: {integrity: sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==} @@ -19430,6 +20601,9 @@ packages: resolution: {integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==} engines: {node: '>= 0.4.0'} + uuid-parse@1.1.0: + resolution: {integrity: sha512-OdmXxA8rDsQ7YpNVbKSJkNzTw2I+S5WsbMDnCtIWSQaosNAcWtFuI/YK1TjzUI6nbkgiqEyh8gWngfcv8Asd9A==} + uuid@10.0.0: resolution: {integrity: sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==} hasBin: true @@ -19484,6 +20658,12 @@ packages: validate.io-function@1.0.2: resolution: {integrity: sha512-LlFybRJEriSuBnUhQyG5bwglhh50EpTL2ul23MPIuR1odjO7XaMLFV8vHGwp7AZciFxtYOeiSCT5st+XSPONiQ==} + varint@5.0.0: + resolution: {integrity: sha512-gC13b/bWrqQoKY2EmROCZ+AR0jitc6DnDGaQ6Ls9QpKmuSgJB1eQ7H3KETtQm7qSdMWMKCmsshyCmUwMLh3OAA==} + + varint@5.0.2: + resolution: {integrity: sha512-lKxKYG6H03yCZUpAGOPOsMcGxd1RHCu1iKvEHYDPmTyq2HueGhD73ssNBqqQWfvYs04G9iUFRvmAVLW20Jw6ow==} + vary@1.1.2: resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==} engines: {node: '>= 0.8'} @@ -19613,6 +20793,9 @@ packages: jsdom: optional: true + vm-browserify@1.1.2: + resolution: {integrity: sha512-2ham8XPWTONajOR0ohOKOHXkm3+gaBmGut3SRuu75xLd/RRaY6vqgh8NBYYk7+RW3u5AtzPQZG8F10LHkl0lAQ==} + vscode-jsonrpc@8.2.0: resolution: {integrity: sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA==} engines: {node: '>=14.0.0'} @@ -19676,6 +20859,9 @@ packages: resolution: {integrity: sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug==} engines: {node: '>= 14'} + webfontloader@1.6.28: + resolution: {integrity: sha512-Egb0oFEga6f+nSgasH3E0M405Pzn6y3/9tOVanv/DLfa1YBIgcv90L18YyWnvXkRbIM17v5Kv6IT2N6g1x5tvQ==} + webidl-conversions@3.0.1: resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==} @@ -19735,6 +20921,14 @@ packages: resolution: {integrity: sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA==} engines: {node: '>= 0.4'} + which-typed-array@1.1.19: + resolution: {integrity: sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==} + engines: {node: '>= 0.4'} + + which-typed-array@1.1.9: + resolution: {integrity: sha512-w9c4xkx6mPidwp7180ckYWfMmvxpjlZuIudNtDf4N/tTAUB8VJbX25qZoAsrtGuYNnGw3pa0AXgbGKRB8/EceA==} + engines: {node: '>= 0.4'} + which@1.3.1: resolution: {integrity: sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==} hasBin: true @@ -19754,10 +20948,22 @@ packages: engines: {node: '>=8'} hasBin: true + widest-line@3.1.0: + resolution: {integrity: sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg==} + engines: {node: '>=8'} + + windows-release@4.0.0: + resolution: {integrity: sha512-OxmV4wzDKB1x7AZaZgXMVsdJ1qER1ed83ZrTYd5Bwq2HfJVg3DJS8nqlAG4sMoJ7mu8cuRmLEYyU13BKwctRAg==} + engines: {node: '>=10'} + word-wrap@1.2.3: resolution: {integrity: sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==} engines: {node: '>=0.10.0'} + wrap-ansi@5.1.0: + resolution: {integrity: sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==} + engines: {node: '>=6'} + wrap-ansi@6.2.0: resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==} engines: {node: '>=8'} @@ -19773,6 +20979,9 @@ packages: wrappy@1.0.2: resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} + write-file-atomic@3.0.3: + resolution: {integrity: sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==} + ws@7.5.9: resolution: {integrity: sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==} engines: {node: '>=8.3.0'} @@ -19849,6 +21058,10 @@ packages: resolution: {integrity: sha512-mgxlWVZw0TNWHoGmXq+NC3uhCIc55dDpAlDkMQUaIAcQzysb0kxctwv//fvuW61/nAAeUBJMQ8mnZjMmuYwOcQ==} engines: {node: '>= 4.0'} + xdg-basedir@4.0.0: + resolution: {integrity: sha512-PSNhEJDejZYV7h50BohL09Er9VaIefr2LMAf3OEmpCkjOi34eYyQYAXUTjEQtZJTKcF0E2UKTh+osDLsgNim9Q==} + engines: {node: '>=8'} + xdg-portable@10.6.0: resolution: {integrity: sha512-xrcqhWDvtZ7WLmt8G4f3hHy37iK7D2idtosRgkeiSPZEPmBShp0VfmRBLWAPC6zLF48APJ21yfea+RfQMF4/Aw==} engines: {node: '>= 4.0'} @@ -19889,6 +21102,9 @@ packages: engines: {node: '>= 14'} hasBin: true + yargs-parser@15.0.3: + resolution: {integrity: sha512-/MVEVjTXy/cGAjdtQf8dW3V9b97bPN7rNn8ETj6BmAQL7ibC7O1Q9SPJbGjgh3SlwoBNXMzj/ZGIj8mBgl12YA==} + yargs-parser@18.1.3: resolution: {integrity: sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==} engines: {node: '>=6'} @@ -19901,6 +21117,9 @@ packages: resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==} engines: {node: '>=12'} + yargs@14.2.3: + resolution: {integrity: sha512-ZbotRWhF+lkjijC/VhmOT9wSgyBQ7+zr13+YLkhfsSiTriYsMzkTUFP18pFhWwBeMa5gUc1MzbhrO6/VB7c9Xg==} + yargs@15.4.1: resolution: {integrity: sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==} engines: {node: '>=8'} @@ -19992,6 +21211,39 @@ packages: snapshots: + 0x@5.8.0: + dependencies: + ajv: 8.17.1 + browserify: 17.0.1 + concat-stream: 2.0.0 + d3-fg: 6.14.0 + debounce: 1.2.1 + debug: 4.4.1(supports-color@10.0.0) + end-of-stream: 1.4.4 + env-string: 1.0.1 + escape-string-regexp: 4.0.0 + execspawn: 1.0.1 + fs-extra: 10.1.0 + has-unicode: 2.0.1 + hsl-to-rgb-for-reals: 1.1.1 + jsonstream2: 3.0.0 + make-dir: 3.1.0 + minimist: 1.2.7 + morphdom: 2.7.7 + nanohtml: 1.10.0 + on-net-listen: 1.1.2 + opn: 5.5.0 + pump: 3.0.2 + pumpify: 2.0.1 + semver: 7.7.3 + single-line-log: 1.1.2 + split2: 4.2.0 + tachyons: 4.12.0 + through2: 4.0.2 + which: 2.0.2 + transitivePeerDependencies: + - supports-color + '@adobe/css-tools@4.4.0': {} '@ai-sdk/anthropic@2.0.4(zod@3.25.76)': @@ -20268,6 +21520,8 @@ snapshots: '@arr/every@1.0.1': {} + '@assemblyscript/loader@0.19.23': {} + '@aws-crypto/crc32@3.0.0': dependencies: '@aws-crypto/util': 3.0.0 @@ -22716,6 +23970,137 @@ snapshots: dependencies: '@clickhouse/client-common': 1.12.1 + '@clinic/bubbleprof@10.0.0': + dependencies: + '@clinic/clinic-common': 7.1.0 + '@clinic/node-trace-log-join': 2.0.0 + '@clinic/trace-events-parser': 2.0.0 + array-flatten: 3.0.0 + async: 3.2.6 + d3-axis: 1.0.12 + d3-color: 1.4.1 + d3-drag: 1.2.5 + d3-ease: 1.0.7 + d3-format: 1.4.5 + d3-interpolate: 1.4.0 + d3-scale: 3.3.0 + d3-selection: 1.4.2 + d3-shape: 1.3.7 + d3-time: 1.1.0 + d3-time-format: 2.3.0 + d3-transition: 1.3.2 + endpoint: 0.4.5 + lodash: 4.17.21 + minify-stream: 2.1.0 + mkdirp: 1.0.4 + on-net-listen: 1.1.2 + protocol-buffers: 4.2.0 + pump: 3.0.2 + + '@clinic/clinic-common@7.1.0': + dependencies: + brfs: 2.0.2 + browserify: 17.0.1 + chalk: 4.1.2 + lodash.debounce: 4.0.8 + loose-envify: 1.4.0 + postcss: 8.5.6 + postcss-import: 13.0.0(postcss@8.5.6) + stream-template: 0.0.10 + webfontloader: 1.6.28 + + '@clinic/doctor@11.0.0(encoding@0.1.13)': + dependencies: + '@clinic/clinic-common': 7.1.0 + '@clinic/node-trace-log-join': 2.0.0 + '@clinic/trace-events-parser': 2.0.0 + '@tensorflow/tfjs-backend-cpu': 3.21.0(@tensorflow/tfjs-core@3.21.0(encoding@0.1.13)) + '@tensorflow/tfjs-core': 3.21.0(encoding@0.1.13) + async: 3.2.6 + clipboard-copy: 4.0.1 + d3-array: 2.12.1 + d3-axis: 1.0.12 + d3-scale: 3.3.0 + d3-selection: 1.4.2 + d3-shape: 1.3.7 + d3-time-format: 2.3.0 + debug: 4.4.1(supports-color@10.0.0) + distributions: 2.2.0 + endpoint: 0.4.5 + hidden-markov-model-tf: 4.0.0(@tensorflow/tfjs-core@3.21.0(encoding@0.1.13)) + minify-stream: 2.1.0 + mkdirp: 1.0.4 + on-net-listen: 1.1.2 + protocol-buffers: 4.2.0 + pump: 3.0.2 + pumpify: 2.0.1 + semver: 7.7.3 + showdown: 1.9.1 + stream-template: 0.0.10 + streaming-json-stringify: 3.1.0 + summary: 2.1.0 + ttest: 3.0.0 + transitivePeerDependencies: + - encoding + - supports-color + + '@clinic/flame@13.0.0': + dependencies: + 0x: 5.8.0 + '@clinic/clinic-common': 7.1.0 + copy-to-clipboard: 3.3.3 + d3-array: 2.12.1 + d3-fg: 6.14.0 + d3-selection: 1.4.2 + flame-gradient: 1.0.0 + lodash.debounce: 4.0.8 + pump: 3.0.2 + querystringify: 2.2.0 + rimraf: 3.0.2 + transitivePeerDependencies: + - supports-color + + '@clinic/heap-profiler@5.0.0': + dependencies: + '@clinic/clinic-common': 7.1.0 + '@nearform/heap-profiler': 2.0.0 + abort-controller: 3.0.0 + copy-to-clipboard: 3.3.3 + d3-array: 2.12.1 + d3-fg: 6.14.0 + d3-selection: 1.4.2 + fs-extra: 11.3.2 + lodash.debounce: 4.0.8 + on-net-listen: 1.1.2 + pump: 3.0.2 + querystringify: 2.2.0 + sinusoidal-decimal: 1.0.0 + + '@clinic/node-trace-log-join@2.0.0': + dependencies: + '@clinic/trace-events-parser': 2.0.0 + multistream: 2.1.1 + pump: 3.0.2 + through2: 2.0.5 + + '@clinic/trace-events-parser@2.0.0': + dependencies: + turbo-json-parse: 2.3.0 + + '@codemirror/autocomplete@6.19.1': + dependencies: + '@codemirror/language': 6.11.3 + '@codemirror/state': 6.5.2 + '@codemirror/view': 6.38.7 + '@lezer/common': 1.3.0 + + '@codemirror/autocomplete@6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.0.2)': + dependencies: + '@codemirror/language': 6.3.2 + '@codemirror/state': 6.2.0 + '@codemirror/view': 6.7.2 + '@lezer/common': 1.0.2 + '@codemirror/autocomplete@6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.3.0)': dependencies: '@codemirror/language': 6.3.2 @@ -23886,11 +25271,6 @@ snapshots: '@jridgewell/set-array@1.2.1': {} - '@jridgewell/source-map@0.3.11': - dependencies: - '@jridgewell/gen-mapping': 0.3.13 - '@jridgewell/trace-mapping': 0.3.31 - '@jridgewell/source-map@0.3.3': dependencies: '@jridgewell/gen-mapping': 0.3.8 @@ -24096,6 +25476,11 @@ snapshots: '@msgpack/msgpack@3.0.0-beta2': {} + '@nearform/heap-profiler@2.0.0': + dependencies: + abort-controller: 3.0.0 + sonic-boom: 1.4.1 + '@neondatabase/serverless@0.9.5': dependencies: '@types/pg': 8.11.6 @@ -30323,6 +31708,25 @@ snapshots: graphql: 16.6.0 zod: 3.25.76 + '@tensorflow/tfjs-backend-cpu@3.21.0(@tensorflow/tfjs-core@3.21.0(encoding@0.1.13))': + dependencies: + '@tensorflow/tfjs-core': 3.21.0(encoding@0.1.13) + '@types/seedrandom': 2.4.34 + seedrandom: 3.0.5 + + '@tensorflow/tfjs-core@3.21.0(encoding@0.1.13)': + dependencies: + '@types/long': 4.0.2 + '@types/offscreencanvas': 2019.3.0 + '@types/seedrandom': 2.4.34 + '@types/webgl-ext': 0.0.30 + '@webgpu/types': 0.1.16 + long: 4.0.0 + node-fetch: 2.6.12(encoding@0.1.13) + seedrandom: 3.0.5 + transitivePeerDependencies: + - encoding + '@testcontainers/postgresql@10.28.0': dependencies: testcontainers: 10.28.0 @@ -30684,6 +32088,8 @@ snapshots: '@types/lodash@4.14.191': {} + '@types/long@4.0.2': {} + '@types/marked@4.0.8': {} '@types/mdast@3.0.10': @@ -30760,6 +32166,8 @@ snapshots: '@types/object-hash@3.0.6': {} + '@types/offscreencanvas@2019.3.0': {} + '@types/pg-pool@2.0.6': dependencies: '@types/pg': 8.11.14 @@ -30866,6 +32274,8 @@ snapshots: '@types/scheduler@0.16.2': {} + '@types/seedrandom@2.4.34': {} + '@types/seedrandom@3.0.8': {} '@types/semver@6.2.3': {} @@ -30942,6 +32352,8 @@ snapshots: '@types/uuid@9.0.0': {} + '@types/webgl-ext@0.0.30': {} + '@types/webpack@5.28.5(@swc/core@1.3.101(@swc/helpers@0.5.15))(esbuild@0.19.11)': dependencies: '@types/node': 20.14.14 @@ -31470,6 +32882,8 @@ snapshots: '@webassemblyjs/ast': 1.14.1 '@xtuc/long': 4.2.2 + '@webgpu/types@0.1.16': {} + '@whatwg-node/events@0.1.1': {} '@whatwg-node/fetch@0.9.14': @@ -31515,6 +32929,11 @@ snapshots: '@zxing/text-encoding@0.9.0': optional: true + JSONStream@1.3.5: + dependencies: + jsonparse: 1.3.1 + through: 2.3.8 + abbrev@2.0.0: {} abort-controller@3.0.0: @@ -31708,16 +33127,30 @@ snapshots: json-schema-traverse: 1.0.0 require-from-string: 2.0.2 + ansi-align@3.0.1: + dependencies: + string-width: 4.2.3 + ansi-colors@4.1.3: {} + ansi-escapes@3.2.0: {} + ansi-escapes@7.0.0: dependencies: environment: 1.1.0 + ansi-regex@2.1.1: {} + + ansi-regex@3.0.1: {} + + ansi-regex@4.1.1: {} + ansi-regex@5.0.1: {} ansi-regex@6.0.1: {} + ansi-styles@2.2.1: {} + ansi-styles@3.2.1: dependencies: color-convert: 1.9.3 @@ -31736,6 +33169,8 @@ snapshots: any-promise@1.3.0: {} + any-shell-escape@0.1.1: {} + anymatch@3.1.3: dependencies: normalize-path: 3.0.0 @@ -31797,6 +33232,10 @@ snapshots: array-flatten@1.1.1: {} + array-flatten@3.0.0: {} + + array-from@2.1.1: {} + array-includes@3.1.6: dependencies: call-bind: 1.0.8 @@ -31878,6 +33317,12 @@ snapshots: asap@2.0.6: {} + asn1.js@4.10.1: + dependencies: + bn.js: 4.12.2 + inherits: 2.0.4 + minimalistic-assert: 1.0.1 + asn1@0.2.6: dependencies: safer-buffer: 2.1.2 @@ -31886,6 +33331,11 @@ snapshots: assert-plus@1.0.0: {} + assert@1.5.1: + dependencies: + object.assign: 4.1.5 + util: 0.10.4 + assertion-error@2.0.1: {} ast-types-flow@0.0.7: {} @@ -31900,12 +33350,44 @@ snapshots: async-lock@1.4.1: {} + async@2.6.4: + dependencies: + lodash: 4.17.21 + async@3.2.6: {} asynckit@0.4.0: {} atomic-sleep@1.0.0: {} + atomically@1.7.0: {} + + autocannon@7.15.0: + dependencies: + chalk: 4.1.2 + char-spinner: 1.0.1 + cli-table3: 0.6.5 + color-support: 1.1.3 + cross-argv: 2.0.0 + form-data: 4.0.4 + has-async-hooks: 1.0.0 + hdr-histogram-js: 3.0.1 + hdr-histogram-percentiles-obj: 3.0.0 + http-parser-js: 0.5.10 + hyperid: 3.3.0 + lodash.chunk: 4.2.0 + lodash.clonedeep: 4.5.0 + lodash.flatten: 4.4.0 + manage-path: 2.0.0 + on-net-listen: 1.1.2 + pretty-bytes: 5.6.0 + progress: 2.0.3 + reinterval: 1.1.0 + retimer: 3.0.0 + semver: 7.7.3 + subarg: 1.0.0 + timestring: 6.0.0 + autoevals@0.0.130(encoding@0.1.13)(ws@8.12.0(bufferutil@4.0.9)): dependencies: ajv: 8.17.1 @@ -32070,11 +33552,17 @@ snapshots: bintrees@1.0.2: {} + bit-twiddle@1.0.2: {} + bl@4.1.0: dependencies: buffer: 5.7.1 inherits: 2.0.4 - readable-stream: 3.6.0 + readable-stream: 3.6.2 + + bn.js@4.12.2: {} + + bn.js@5.2.2: {} body-parser@1.20.3: dependencies: @@ -32113,6 +33601,17 @@ snapshots: bowser@2.12.1: {} + boxen@5.1.2: + dependencies: + ansi-align: 3.0.1 + camelcase: 6.3.0 + chalk: 4.1.2 + cli-boxes: 2.2.1 + string-width: 4.2.3 + type-fest: 0.20.2 + widest-line: 3.1.0 + wrap-ansi: 7.0.0 + brace-expansion@1.1.11: dependencies: balanced-match: 1.0.2 @@ -32130,10 +33629,129 @@ snapshots: dependencies: wcwidth: 1.0.1 + brfs@2.0.2: + dependencies: + quote-stream: 1.0.2 + resolve: 1.22.8 + static-module: 3.0.4 + through2: 2.0.5 + + brorand@1.1.0: {} + + browser-pack@6.1.0: + dependencies: + JSONStream: 1.3.5 + combine-source-map: 0.8.0 + defined: 1.0.1 + safe-buffer: 5.2.1 + through2: 2.0.5 + umd: 3.0.3 + + browser-process-hrtime@0.1.3: {} + + browser-resolve@2.0.0: + dependencies: + resolve: 1.22.8 + + browserify-aes@1.2.0: + dependencies: + buffer-xor: 1.0.3 + cipher-base: 1.0.7 + create-hash: 1.2.0 + evp_bytestokey: 1.0.3 + inherits: 2.0.4 + safe-buffer: 5.2.1 + + browserify-cipher@1.0.1: + dependencies: + browserify-aes: 1.2.0 + browserify-des: 1.0.2 + evp_bytestokey: 1.0.3 + + browserify-des@1.0.2: + dependencies: + cipher-base: 1.0.7 + des.js: 1.1.0 + inherits: 2.0.4 + safe-buffer: 5.2.1 + + browserify-rsa@4.1.1: + dependencies: + bn.js: 5.2.2 + randombytes: 2.1.0 + safe-buffer: 5.2.1 + + browserify-sign@4.2.5: + dependencies: + bn.js: 5.2.2 + browserify-rsa: 4.1.1 + create-hash: 1.2.0 + create-hmac: 1.1.7 + elliptic: 6.6.1 + inherits: 2.0.4 + parse-asn1: 5.1.9 + readable-stream: 2.3.8 + safe-buffer: 5.2.1 + browserify-zlib@0.1.4: dependencies: pako: 0.2.9 + browserify-zlib@0.2.0: + dependencies: + pako: 1.0.11 + + browserify@17.0.1: + dependencies: + JSONStream: 1.3.5 + assert: 1.5.1 + browser-pack: 6.1.0 + browser-resolve: 2.0.0 + browserify-zlib: 0.2.0 + buffer: 5.2.1 + cached-path-relative: 1.1.0 + concat-stream: 1.6.2 + console-browserify: 1.2.0 + constants-browserify: 1.0.0 + crypto-browserify: 3.12.1 + defined: 1.0.1 + deps-sort: 2.0.1 + domain-browser: 1.2.0 + duplexer2: 0.1.4 + events: 3.3.0 + glob: 7.2.3 + hasown: 2.0.2 + htmlescape: 1.1.1 + https-browserify: 1.0.0 + inherits: 2.0.4 + insert-module-globals: 7.2.1 + labeled-stream-splicer: 2.0.2 + mkdirp-classic: 0.5.3 + module-deps: 6.2.3 + os-browserify: 0.3.0 + parents: 1.0.1 + path-browserify: 1.0.1 + process: 0.11.10 + punycode: 1.4.1 + querystring-es3: 0.2.1 + read-only-stream: 2.0.0 + readable-stream: 2.3.8 + resolve: 1.22.8 + shasum-object: 1.0.1 + shell-quote: 1.8.1 + stream-browserify: 3.0.0 + stream-http: 3.2.0 + string_decoder: 1.3.0 + subarg: 1.0.0 + syntax-error: 1.4.0 + through2: 2.0.5 + timers-browserify: 1.4.2 + tty-browserify: 0.0.1 + url: 0.11.4 + util: 0.12.5 + vm-browserify: 1.1.2 + xtend: 4.0.2 + browserslist@4.21.4: dependencies: caniuse-lite: 1.0.30001577 @@ -32164,8 +33782,17 @@ snapshots: buffer-equal-constant-time@1.0.1: {} + buffer-equal@0.0.1: {} + buffer-from@1.1.2: {} + buffer-xor@1.0.3: {} + + buffer@5.2.1: + dependencies: + base64-js: 1.5.1 + ieee754: 1.2.1 + buffer@5.7.1: dependencies: base64-js: 1.5.1 @@ -32183,6 +33810,8 @@ snapshots: buildcheck@0.0.6: optional: true + builtin-status-codes@3.0.0: {} + builtins@1.0.3: {} builtins@5.0.1: @@ -32274,6 +33903,8 @@ snapshots: normalize-url: 4.5.1 responselike: 1.0.2 + cached-path-relative@1.1.0: {} + call-bind-apply-helpers@1.0.2: dependencies: es-errors: 1.3.0 @@ -32301,6 +33932,11 @@ snapshots: callsites@3.1.0: {} + camel-case@3.0.0: + dependencies: + no-case: 2.3.2 + upper-case: 1.1.3 + camelcase-css@2.0.1: {} camelcase-keys@6.2.2: @@ -32311,6 +33947,8 @@ snapshots: camelcase@5.3.1: {} + camelcase@6.3.0: {} + caniuse-lite@1.0.30001577: {} caniuse-lite@1.0.30001699: {} @@ -32325,6 +33963,8 @@ snapshots: ccount@2.0.1: {} + cephes@2.0.0: {} + chai@5.2.0: dependencies: assertion-error: 2.0.1 @@ -32333,6 +33973,14 @@ snapshots: loupe: 3.1.3 pathval: 2.0.0 + chalk@1.1.3: + dependencies: + ansi-styles: 2.2.1 + escape-string-regexp: 1.0.5 + has-ansi: 2.0.0 + strip-ansi: 3.0.1 + supports-color: 2.0.0 + chalk@2.4.2: dependencies: ansi-styles: 3.2.1 @@ -32355,6 +34003,8 @@ snapshots: char-regex@1.0.2: {} + char-spinner@1.0.1: {} + character-entities-html4@2.1.0: {} character-entities-legacy@3.0.0: {} @@ -32427,8 +34077,16 @@ snapshots: mitt: 3.0.1 zod: 3.25.76 + ci-info@2.0.0: {} + ci-info@3.8.0: {} + cipher-base@1.0.7: + dependencies: + inherits: 2.0.4 + safe-buffer: 5.2.1 + to-buffer: 1.2.2 + citty@0.1.6: dependencies: consola: 3.4.2 @@ -32453,6 +34111,12 @@ snapshots: dependencies: escape-string-regexp: 5.0.0 + cli-boxes@2.2.1: {} + + cli-cursor@2.1.0: + dependencies: + restore-cursor: 2.0.0 + cli-cursor@3.1.0: dependencies: restore-cursor: 3.1.0 @@ -32480,8 +34144,44 @@ snapshots: optionalDependencies: '@colors/colors': 1.5.0 + cli-width@2.2.1: {} + client-only@0.0.1: {} + clinic@13.0.0(encoding@0.1.13): + dependencies: + '@clinic/bubbleprof': 10.0.0 + '@clinic/doctor': 11.0.0(encoding@0.1.13) + '@clinic/flame': 13.0.0 + '@clinic/heap-profiler': 5.0.0 + any-shell-escape: 0.1.1 + async: 3.2.6 + autocannon: 7.15.0 + commist: 1.1.0 + cross-argv: 1.0.0 + dargs: 7.0.0 + env-string: 1.0.1 + execspawn: 1.0.1 + insight: 0.11.1 + minimist: 1.2.7 + open: 7.4.2 + ora: 5.4.1 + rimraf: 3.0.2 + stream-collector: 1.0.1 + subarg: 1.0.0 + update-notifier: 5.1.0 + transitivePeerDependencies: + - encoding + - supports-color + + clipboard-copy@4.0.1: {} + + cliui@5.0.0: + dependencies: + string-width: 3.1.0 + strip-ansi: 5.2.0 + wrap-ansi: 5.1.0 + cliui@6.0.0: dependencies: string-width: 4.2.3 @@ -32516,6 +34216,10 @@ snapshots: cluster-key-slot@1.1.2: {} + code-point-at@1.1.0: {} + + code-point-at@1.1.0: {} + codemirror@6.0.2(@lezer/common@1.3.0): dependencies: '@codemirror/autocomplete': 6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.3.0) @@ -32545,6 +34249,8 @@ snapshots: color-name: 1.1.4 simple-swizzle: 0.2.2 + color-support@1.1.3: {} + color@3.2.1: dependencies: color-convert: 1.9.3 @@ -32556,6 +34262,13 @@ snapshots: color-string: 1.9.1 optional: true + combine-source-map@0.8.0: + dependencies: + convert-source-map: 1.1.3 + inline-source-map: 0.6.3 + lodash.memoize: 3.0.4 + source-map: 0.5.6 + combined-stream@1.0.8: dependencies: delayed-stream: 1.0.0 @@ -32578,6 +34291,11 @@ snapshots: commander@9.5.0: {} + commist@1.1.0: + dependencies: + leven: 2.1.0 + minimist: 1.2.7 + compare-versions@6.1.1: {} component-emitter@1.3.1: {} @@ -32625,6 +34343,33 @@ snapshots: concat-map@0.0.1: {} + concat-stream@1.6.2: + dependencies: + buffer-from: 1.1.2 + inherits: 2.0.4 + readable-stream: 2.3.8 + typedarray: 0.0.6 + + concat-stream@2.0.0: + dependencies: + buffer-from: 1.1.2 + inherits: 2.0.4 + readable-stream: 3.6.2 + typedarray: 0.0.6 + + conf@10.2.0: + dependencies: + ajv: 8.17.1 + ajv-formats: 2.1.1(ajv@8.17.1) + atomically: 1.7.0 + debounce-fn: 4.0.0 + dot-prop: 6.0.1 + env-paths: 2.2.1 + json-schema-typed: 7.0.3 + onetime: 5.1.2 + pkg-up: 3.1.0 + semver: 7.7.3 + confbox@0.1.8: {} confbox@0.2.2: {} @@ -32634,8 +34379,21 @@ snapshots: ini: 1.3.8 proto-list: 1.2.4 + configstore@5.0.1: + dependencies: + dot-prop: 5.3.0 + graceful-fs: 4.2.11 + make-dir: 3.1.0 + unique-string: 2.0.0 + write-file-atomic: 3.0.3 + xdg-basedir: 4.0.0 + consola@3.4.2: {} + console-browserify@1.2.0: {} + + constants-browserify@1.0.0: {} + content-disposition@0.5.4: dependencies: safe-buffer: 5.2.1 @@ -32646,6 +34404,8 @@ snapshots: content-type@1.0.5: {} + convert-source-map@1.1.3: {} + convert-source-map@1.9.0: {} cookie-signature@1.0.6: {} @@ -32751,6 +34511,30 @@ snapshots: crc-32: 1.2.2 readable-stream: 4.7.0 + create-ecdh@4.0.4: + dependencies: + bn.js: 4.12.2 + elliptic: 6.6.1 + + create-hash@1.2.0: + dependencies: + cipher-base: 1.0.7 + inherits: 2.0.4 + md5.js: 1.3.5 + ripemd160: 2.0.3 + sha.js: 2.4.12 + + create-hmac@1.1.7: + dependencies: + cipher-base: 1.0.7 + create-hash: 1.2.0 + inherits: 2.0.4 + ripemd160: 2.0.3 + safe-buffer: 5.2.1 + sha.js: 2.4.12 + + crelt@1.0.5: {} + crelt@1.0.6: {} cron-parser@4.9.0: @@ -32761,6 +34545,10 @@ snapshots: cronstrue@2.61.0: {} + cross-argv@1.0.0: {} + + cross-argv@2.0.0: {} + cross-env@7.0.3: dependencies: cross-spawn: 7.0.3 @@ -32791,10 +34579,27 @@ snapshots: shebang-command: 2.0.0 which: 2.0.2 + crypto-browserify@3.12.1: + dependencies: + browserify-cipher: 1.0.1 + browserify-sign: 4.2.5 + create-ecdh: 4.0.4 + create-hash: 1.2.0 + create-hmac: 1.1.7 + diffie-hellman: 5.0.3 + hash-base: 3.0.5 + inherits: 2.0.4 + pbkdf2: 3.1.5 + public-encrypt: 4.0.3 + randombytes: 2.1.0 + randomfill: 1.0.4 + crypto-js@4.1.1: {} crypto-js@4.2.0: {} + crypto-random-string@2.0.0: {} + css-in-js-utils@3.1.0: dependencies: hyphenate-style-name: 1.0.4 @@ -32846,6 +34651,10 @@ snapshots: cuid@2.1.8: {} + cwise-compiler@1.1.3: + dependencies: + uniq: 1.0.1 + cytoscape-cose-bilkent@4.1.0(cytoscape@3.33.1): dependencies: cose-base: 1.0.3 @@ -32866,6 +34675,8 @@ snapshots: dependencies: internmap: 2.0.3 + d3-axis@1.0.12: {} + d3-axis@3.0.0: {} d3-brush@3.0.0: @@ -32880,6 +34691,10 @@ snapshots: dependencies: d3-path: 3.1.0 + d3-color@1.4.1: {} + + d3-color@2.0.0: {} + d3-color@3.1.0: {} d3-contour@4.0.2: @@ -32890,8 +34705,15 @@ snapshots: dependencies: delaunator: 5.0.1 + d3-dispatch@1.0.6: {} + d3-dispatch@3.0.1: {} + d3-drag@1.2.5: + dependencies: + d3-dispatch: 1.0.6 + d3-selection: 1.4.2 + d3-drag@3.0.0: dependencies: d3-dispatch: 3.0.1 @@ -32903,26 +34725,54 @@ snapshots: iconv-lite: 0.6.3 rw: 1.3.3 + d3-ease@1.0.7: {} + d3-ease@3.0.1: {} d3-fetch@3.0.1: dependencies: d3-dsv: 3.0.1 + d3-fg@6.14.0: + dependencies: + d3-array: 2.12.1 + d3-dispatch: 1.0.6 + d3-ease: 1.0.7 + d3-hierarchy: 1.1.9 + d3-scale: 3.3.0 + d3-selection: 1.4.2 + d3-zoom: 1.8.3 + escape-string-regexp: 1.0.5 + hsl-to-rgb-for-reals: 1.1.1 + d3-force@3.0.0: dependencies: d3-dispatch: 3.0.1 d3-quadtree: 3.0.1 d3-timer: 3.0.1 + d3-format@1.4.5: {} + + d3-format@2.0.0: {} + d3-format@3.1.0: {} d3-geo@3.1.1: dependencies: d3-array: 3.2.4 + d3-hierarchy@1.1.9: {} + d3-hierarchy@3.1.2: {} + d3-interpolate@1.4.0: + dependencies: + d3-color: 1.4.1 + + d3-interpolate@2.0.1: + dependencies: + d3-color: 2.0.0 + d3-interpolate@3.0.1: dependencies: d3-color: 3.1.0 @@ -32947,6 +34797,14 @@ snapshots: d3-color: 3.1.0 d3-interpolate: 3.0.1 + d3-scale@3.3.0: + dependencies: + d3-array: 2.12.1 + d3-format: 2.0.0 + d3-interpolate: 2.0.1 + d3-time: 2.1.1 + d3-time-format: 2.3.0 + d3-scale@4.0.2: dependencies: d3-array: 3.2.4 @@ -32955,6 +34813,8 @@ snapshots: d3-time: 3.1.0 d3-time-format: 4.1.0 + d3-selection@1.4.2: {} + d3-selection@3.0.0: {} d3-shape@1.3.7: @@ -32965,16 +34825,37 @@ snapshots: dependencies: d3-path: 3.1.0 + d3-time-format@2.3.0: + dependencies: + d3-time: 1.1.0 + d3-time-format@4.1.0: dependencies: d3-time: 3.1.0 + d3-time@1.1.0: {} + + d3-time@2.1.1: + dependencies: + d3-array: 2.12.1 + d3-time@3.1.0: dependencies: d3-array: 3.2.4 + d3-timer@1.0.10: {} + d3-timer@3.0.1: {} + d3-transition@1.3.2: + dependencies: + d3-color: 1.4.1 + d3-dispatch: 1.0.6 + d3-ease: 1.0.7 + d3-interpolate: 1.4.0 + d3-selection: 1.4.2 + d3-timer: 1.0.10 + d3-transition@3.0.1(d3-selection@3.0.0): dependencies: d3-color: 3.1.0 @@ -32984,6 +34865,14 @@ snapshots: d3-selection: 3.0.0 d3-timer: 3.0.1 + d3-zoom@1.8.3: + dependencies: + d3-dispatch: 1.0.6 + d3-drag: 1.2.5 + d3-interpolate: 1.4.0 + d3-selection: 1.4.2 + d3-transition: 1.3.2 + d3-zoom@3.0.0: dependencies: d3-dispatch: 3.0.1 @@ -33025,6 +34914,11 @@ snapshots: d3-transition: 3.0.1(d3-selection@3.0.0) d3-zoom: 3.0.0 + d@1.0.2: + dependencies: + es5-ext: 0.10.64 + type: 2.7.3 + dagre-d3-es@7.0.11: dependencies: d3: 7.9.0 @@ -33032,6 +34926,12 @@ snapshots: damerau-levenshtein@1.0.8: {} + dargs@7.0.0: {} + + dash-ast@1.0.0: {} + + dash-ast@2.0.1: {} + dashdash@1.14.1: dependencies: assert-plus: 1.0.0 @@ -33064,6 +34964,10 @@ snapshots: dayjs@1.11.18: {} + debounce-fn@4.0.0: + dependencies: + mimic-fn: 3.1.0 + debounce@1.2.1: {} debounce@2.0.0: {} @@ -33193,8 +35097,20 @@ snapshots: deprecation@2.3.1: {} + deps-sort@2.0.1: + dependencies: + JSONStream: 1.3.5 + shasum-object: 1.0.1 + subarg: 1.0.0 + through2: 2.0.5 + dequal@2.0.3: {} + des.js@1.1.0: + dependencies: + inherits: 2.0.4 + minimalistic-assert: 1.0.1 + destr@2.0.3: {} destroy@1.2.0: {} @@ -33230,11 +35146,19 @@ snapshots: diff@5.1.0: {} + diffie-hellman@5.0.3: + dependencies: + bn.js: 4.12.2 + miller-rabin: 4.0.1 + randombytes: 2.1.0 + dir-glob@3.0.1: dependencies: path-type: 4.0.0 - discontinuous-range@1.0.0: {} + distributions@2.2.0: + dependencies: + cephes: 2.0.0 dlv@1.1.3: {} @@ -33286,6 +35210,8 @@ snapshots: domhandler: 5.0.3 entities: 4.5.0 + domain-browser@1.2.0: {} + domelementtype@2.3.0: {} domhandler@5.0.3: @@ -33302,6 +35228,14 @@ snapshots: domelementtype: 2.3.0 domhandler: 5.0.3 + dot-prop@5.3.0: + dependencies: + is-obj: 2.0.0 + + dot-prop@6.0.1: + dependencies: + is-obj: 2.0.0 + dotenv@16.0.3: {} dotenv@16.4.4: {} @@ -33326,6 +35260,12 @@ snapshots: es-errors: 1.3.0 gopd: 1.2.0 + dup@1.0.0: {} + + duplexer2@0.1.4: + dependencies: + readable-stream: 2.3.8 + duplexer3@0.1.5: {} duplexer@0.1.2: {} @@ -33400,6 +35340,18 @@ snapshots: electron-to-chromium@1.5.98: {} + elliptic@6.6.1: + dependencies: + bn.js: 4.12.2 + brorand: 1.1.0 + hash.js: 1.1.7 + hmac-drbg: 1.0.1 + inherits: 2.0.4 + minimalistic-assert: 1.0.1 + minimalistic-crypto-utils: 1.0.1 + + emoji-regex@7.0.3: {} + emoji-regex@8.0.0: {} emoji-regex@9.2.2: {} @@ -33420,6 +35372,10 @@ snapshots: dependencies: once: 1.4.0 + endpoint@0.4.5: + dependencies: + inherits: 2.0.4 + engine.io-client@6.5.3(bufferutil@4.0.9)(supports-color@10.0.0): dependencies: '@socket.io/component-emitter': 3.1.0 @@ -33471,6 +35427,8 @@ snapshots: env-paths@2.2.1: {} + env-string@1.0.1: {} + environment@1.1.0: {} err-code@2.0.3: {} @@ -33615,6 +35573,42 @@ snapshots: is-date-object: 1.0.5 is-symbol: 1.0.4 + es5-ext@0.10.64: + dependencies: + es6-iterator: 2.0.3 + es6-symbol: 3.1.4 + esniff: 2.0.1 + next-tick: 1.1.0 + + es6-iterator@2.0.3: + dependencies: + d: 1.0.2 + es5-ext: 0.10.64 + es6-symbol: 3.1.4 + + es6-map@0.1.5: + dependencies: + d: 1.0.2 + es5-ext: 0.10.64 + es6-iterator: 2.0.3 + es6-set: 0.1.6 + es6-symbol: 3.1.4 + event-emitter: 0.3.5 + + es6-set@0.1.6: + dependencies: + d: 1.0.2 + es5-ext: 0.10.64 + es6-iterator: 2.0.3 + es6-symbol: 3.1.4 + event-emitter: 0.3.5 + type: 2.7.3 + + es6-symbol@3.1.4: + dependencies: + d: 1.0.2 + ext: 1.7.0 + esbuild-android-64@0.15.18: optional: true @@ -33866,6 +35860,8 @@ snapshots: escalade@3.2.0: {} + escape-goat@2.1.1: {} + escape-html@1.0.3: {} escape-string-regexp@1.0.5: {} @@ -33874,6 +35870,15 @@ snapshots: escape-string-regexp@5.0.0: {} + escodegen@1.14.3: + dependencies: + esprima: 4.0.1 + estraverse: 4.3.0 + esutils: 2.0.3 + optionator: 0.8.3 + optionalDependencies: + source-map: 0.6.1 + escodegen@2.1.0: dependencies: esprima: 4.0.1 @@ -34145,6 +36150,13 @@ snapshots: esm-env@1.2.2: {} + esniff@2.0.1: + dependencies: + d: 1.0.2 + es5-ext: 0.10.64 + event-emitter: 0.3.5 + type: 2.7.3 + espree@9.4.1: dependencies: acorn: 8.12.1 @@ -34175,6 +36187,10 @@ snapshots: estraverse@5.3.0: {} + estree-is-function@1.0.0: {} + + estree-is-member-expression@1.0.0: {} + estree-util-attach-comments@2.1.0: dependencies: '@types/estree': 1.0.8 @@ -34236,6 +36252,11 @@ snapshots: - bufferutil - utf-8-validate + event-emitter@0.3.5: + dependencies: + d: 1.0.2 + es5-ext: 0.10.64 + event-target-shim@5.0.1: {} event-target-shim@6.0.2: {} @@ -34262,12 +36283,29 @@ snapshots: dependencies: eventsource-parser: 3.0.3 + evp_bytestokey@1.0.3: + dependencies: + md5.js: 1.3.5 + safe-buffer: 5.2.1 + evt@2.4.13: dependencies: minimal-polyfills: 2.2.2 run-exclusive: 2.2.18 tsafe: 1.4.1 + execa@4.1.0: + dependencies: + cross-spawn: 7.0.6 + get-stream: 5.2.0 + human-signals: 1.1.1 + is-stream: 2.0.1 + merge-stream: 2.0.0 + npm-run-path: 4.0.1 + onetime: 5.1.2 + signal-exit: 3.0.7 + strip-final-newline: 2.0.0 + execa@5.1.1: dependencies: cross-spawn: 7.0.6 @@ -34292,6 +36330,10 @@ snapshots: signal-exit: 4.1.0 strip-final-newline: 3.0.0 + execspawn@1.0.1: + dependencies: + util-extend: 1.0.3 + exit-hook@2.2.1: {} expand-template@2.0.3: {} @@ -34377,6 +36419,10 @@ snapshots: exsolve@1.0.7: {} + ext@1.7.0: + dependencies: + type: 2.7.3 + extend@3.0.2: {} extendable-error@0.1.7: {} @@ -34522,6 +36568,10 @@ snapshots: fft.js@4.0.4: {} + figures@2.0.0: + dependencies: + escape-string-regexp: 1.0.5 + file-entry-cache@6.0.1: dependencies: flat-cache: 3.0.4 @@ -34574,6 +36624,10 @@ snapshots: fast-querystring: 1.1.2 safe-regex2: 5.0.0 + find-up@3.0.0: + dependencies: + locate-path: 3.0.0 + find-up@4.1.0: dependencies: locate-path: 5.0.0 @@ -34595,11 +36649,17 @@ snapshots: micromatch: 4.0.8 pkg-dir: 4.2.0 + flame-gradient@1.0.0: + dependencies: + sinusoidal-decimal: 1.0.0 + flat-cache@3.0.4: dependencies: flatted: 3.2.7 rimraf: 3.0.2 + flatstr@1.0.12: {} + flatted@3.2.7: {} follow-redirects@1.15.9: {} @@ -34608,6 +36668,10 @@ snapshots: dependencies: is-callable: 1.2.7 + for-each@0.3.5: + dependencies: + is-callable: 1.2.7 + foreground-child@3.1.1: dependencies: cross-spawn: 7.0.6 @@ -34683,6 +36747,15 @@ snapshots: fresh@2.0.0: {} + from2-string@1.1.0: + dependencies: + from2: 2.3.0 + + from2@2.3.0: + dependencies: + inherits: 2.0.4 + readable-stream: 2.3.8 + fs-constants@1.0.0: {} fs-extra@10.1.0: @@ -34691,6 +36764,12 @@ snapshots: jsonfile: 6.1.0 universalify: 2.0.0 + fs-extra@11.3.2: + dependencies: + graceful-fs: 4.2.11 + jsonfile: 6.1.0 + universalify: 2.0.0 + fs-extra@7.0.1: dependencies: graceful-fs: 4.2.11 @@ -34737,12 +36816,22 @@ snapshots: functions-have-names@1.2.3: {} + generate-function@2.3.1: + dependencies: + is-property: 1.0.2 + + generate-object-property@1.2.0: + dependencies: + is-property: 1.0.2 + generic-names@4.0.0: dependencies: loader-utils: 3.2.1 gensync@1.0.0-beta.2: {} + get-assigned-identifiers@1.2.0: {} + get-caller-file@2.0.5: {} get-intrinsic@1.2.4: @@ -34910,6 +36999,10 @@ snapshots: minipass: 4.2.8 path-scurry: 1.11.1 + global-dirs@3.0.1: + dependencies: + ini: 2.0.0 + globals@11.12.0: {} globals@13.19.0: @@ -35042,6 +37135,12 @@ snapshots: hard-rejection@2.1.0: {} + has-ansi@2.0.0: + dependencies: + ansi-regex: 2.1.1 + + has-async-hooks@1.0.0: {} + has-bigints@1.0.2: {} has-flag@3.0.0: {} @@ -35064,10 +37163,31 @@ snapshots: dependencies: has-symbols: 1.1.0 + has-unicode@2.0.1: {} + + has-yarn@2.1.0: {} + has@1.0.3: dependencies: function-bind: 1.1.2 + hash-base@3.0.5: + dependencies: + inherits: 2.0.4 + safe-buffer: 5.2.1 + + hash-base@3.1.2: + dependencies: + inherits: 2.0.4 + readable-stream: 2.3.8 + safe-buffer: 5.2.1 + to-buffer: 1.2.2 + + hash.js@1.1.7: + dependencies: + inherits: 2.0.4 + minimalistic-assert: 1.0.1 + hasown@2.0.2: dependencies: function-bind: 1.1.2 @@ -35214,10 +37334,35 @@ snapshots: property-information: 7.0.0 space-separated-tokens: 2.0.2 + hdr-histogram-js@3.0.1: + dependencies: + '@assemblyscript/loader': 0.19.23 + base64-js: 1.5.1 + pako: 1.0.11 + + hdr-histogram-percentiles-obj@3.0.0: {} + hexoid@1.0.0: {} + hidden-markov-model-tf@4.0.0(@tensorflow/tfjs-core@3.21.0(encoding@0.1.13)): + dependencies: + '@tensorflow/tfjs-core': 3.21.0(encoding@0.1.13) + ml-kmeans: 4.2.1 + ndarray: 1.0.19 + ndarray-cholesky-factorization: 1.0.2 + ndarray-determinant: 1.0.0 + ndarray-inv: 0.2.0 + seedrandom: 3.0.5 + semver: 6.3.1 + highlight.js@10.7.3: {} + hmac-drbg@1.0.1: + dependencies: + hash.js: 1.1.7 + minimalistic-assert: 1.0.1 + minimalistic-crypto-utils: 1.0.1 + hoist-non-react-statics@3.3.2: dependencies: react-is: 16.13.1 @@ -35230,6 +37375,8 @@ snapshots: dependencies: lru-cache: 7.18.3 + hsl-to-rgb-for-reals@1.1.1: {} + html-escaper@2.0.2: {} html-tags@3.3.1: {} @@ -35246,6 +37393,8 @@ snapshots: html-void-elements@3.0.0: {} + htmlescape@1.1.1: {} + htmlparser2@8.0.2: dependencies: domelementtype: 2.3.0 @@ -35263,6 +37412,8 @@ snapshots: statuses: 2.0.1 toidentifier: 1.0.1 + http-parser-js@0.5.10: {} + http-proxy-agent@7.0.2: dependencies: agent-base: 7.1.4 @@ -35276,6 +37427,8 @@ snapshots: jsprim: 1.4.2 sshpk: 1.18.0 + https-browserify@1.0.0: {} + https-proxy-agent@5.0.1: dependencies: agent-base: 6.0.2 @@ -35292,6 +37445,8 @@ snapshots: human-id@1.0.2: {} + human-signals@1.1.1: {} + human-signals@2.1.0: {} human-signals@5.0.0: {} @@ -35302,6 +37457,18 @@ snapshots: dependencies: ms: 2.1.3 + hyperid@3.3.0: + dependencies: + buffer: 5.7.1 + uuid: 8.3.2 + uuid-parse: 1.1.0 + + hyperscript-attribute-to-property@1.0.2: {} + + hyperx@2.5.4: + dependencies: + hyperscript-attribute-to-property: 1.0.2 + hyphenate-style-name@1.0.4: {} iconv-lite@0.4.24: @@ -35345,6 +37512,8 @@ snapshots: cjs-module-lexer: 1.2.3 module-details-from-path: 1.0.3 + import-lazy@2.1.0: {} + import-meta-resolve@4.1.0: {} imurmurhash@0.1.4: {} @@ -35358,12 +37527,20 @@ snapshots: once: 1.4.0 wrappy: 1.0.2 + inherits@2.0.3: {} + inherits@2.0.4: {} ini@1.3.8: {} + ini@2.0.0: {} + ini@5.0.0: {} + inline-source-map@0.6.3: + dependencies: + source-map: 0.5.6 + inline-style-parser@0.1.1: {} inline-style-parser@0.2.4: {} @@ -35377,6 +37554,47 @@ snapshots: react: 18.2.0 react-dom: 18.2.0(react@18.2.0) + inquirer@6.5.2: + dependencies: + ansi-escapes: 3.2.0 + chalk: 2.4.2 + cli-cursor: 2.1.0 + cli-width: 2.2.1 + external-editor: 3.1.0 + figures: 2.0.0 + lodash: 4.17.21 + mute-stream: 0.0.7 + run-async: 2.4.1 + rxjs: 6.6.7 + string-width: 2.1.1 + strip-ansi: 5.2.0 + through: 2.3.8 + + insert-module-globals@7.2.1: + dependencies: + JSONStream: 1.3.5 + acorn-node: 1.8.2 + combine-source-map: 0.8.0 + concat-stream: 1.6.2 + is-buffer: 1.1.6 + path-is-absolute: 1.0.1 + process: 0.11.10 + through2: 2.0.5 + undeclared-identifiers: 1.1.3 + xtend: 4.0.2 + + insight@0.11.1: + dependencies: + async: 2.6.4 + chalk: 4.1.2 + conf: 10.2.0 + inquirer: 6.5.2 + lodash.debounce: 4.0.8 + os-name: 4.0.1 + request: 2.88.2 + tough-cookie: 4.1.4 + uuid: 8.3.2 + install@0.13.0: {} internal-slot@1.0.4: @@ -35426,6 +37644,8 @@ snapshots: transitivePeerDependencies: - supports-color + iota-array@1.0.0: {} + ip-address@9.0.5: dependencies: jsbn: 1.1.0 @@ -35472,15 +37692,25 @@ snapshots: dependencies: binary-extensions: 2.2.0 + is-boolean-attribute@0.0.1: {} + is-boolean-object@1.1.2: dependencies: call-bind: 1.0.8 has-tostringtag: 1.0.2 + is-buffer@1.1.6: {} + + is-buffer@1.1.6: {} + is-buffer@2.0.5: {} is-callable@1.2.7: {} + is-ci@2.0.0: + dependencies: + ci-info: 2.0.0 + is-ci@3.0.1: dependencies: ci-info: 3.8.0 @@ -35509,6 +37739,12 @@ snapshots: is-extglob@2.1.1: {} + is-fullwidth-code-point@1.0.0: + dependencies: + number-is-nan: 1.0.1 + + is-fullwidth-code-point@2.0.0: {} + is-fullwidth-code-point@3.0.0: {} is-generator-function@1.0.10: @@ -35527,6 +37763,11 @@ snapshots: dependencies: is-docker: 3.0.0 + is-installed-globally@0.4.0: + dependencies: + global-dirs: 3.0.1 + is-path-inside: 3.0.3 + is-interactive@1.0.0: {} is-negative-zero@2.0.2: {} @@ -35535,12 +37776,16 @@ snapshots: is-network-error@1.0.0: {} + is-npm@5.0.0: {} + is-number-object@1.0.7: dependencies: has-tostringtag: 1.0.2 is-number@7.0.0: {} + is-obj@2.0.0: {} + is-path-inside@3.0.3: {} is-plain-obj@1.1.0: {} @@ -35553,6 +37798,8 @@ snapshots: is-promise@4.0.0: {} + is-property@1.0.2: {} + is-reference@3.0.3: dependencies: '@types/estree': 1.0.8 @@ -35592,6 +37839,10 @@ snapshots: dependencies: which-typed-array: 1.1.15 + is-typed-array@1.1.15: + dependencies: + which-typed-array: 1.1.19 + is-typedarray@1.0.0: {} is-unicode-supported@0.1.0: {} @@ -35604,6 +37855,8 @@ snapshots: is-windows@1.0.2: {} + is-wsl@1.1.0: {} + is-wsl@2.2.0: dependencies: is-docker: 2.2.1 @@ -35612,6 +37865,8 @@ snapshots: dependencies: is-inside-container: 1.0.0 + is-yarn-global@0.3.0: {} + isarray@1.0.0: {} isarray@2.0.5: {} @@ -35755,6 +38010,8 @@ snapshots: json-schema-traverse@1.0.0: {} + json-schema-typed@7.0.3: {} + json-schema@0.4.0: {} json-stable-stringify-without-jsonify@1.0.1: {} @@ -35795,6 +38052,8 @@ snapshots: jsonify@0.0.1: {} + jsonparse@1.3.1: {} + jsonpath-plus@10.3.0: dependencies: '@jsep-plugin/assignment': 1.3.0(jsep@1.4.0) @@ -35805,6 +38064,12 @@ snapshots: jsonpointer@5.0.1: {} + jsonstream2@3.0.0: + dependencies: + jsonparse: 1.3.1 + through2: 3.0.2 + type-component: 0.0.1 + jsonwebtoken@9.0.2: dependencies: jws: 3.2.3 @@ -35859,6 +38124,11 @@ snapshots: kolorist@1.8.0: {} + labeled-stream-splicer@2.0.2: + dependencies: + inherits: 2.0.4 + stream-splicer: 2.0.1 + langium@3.3.1: dependencies: chevrotain: 11.0.3 @@ -35884,6 +38154,10 @@ snapshots: dependencies: language-subtag-registry: 0.3.22 + latest-version@5.1.0: + dependencies: + package-json: 6.5.0 + layerr@2.0.1: {} layout-base@1.0.2: {} @@ -35939,6 +38213,13 @@ snapshots: lefthook-windows-arm64: 1.11.3 lefthook-windows-x64: 1.11.3 + leven@2.1.0: {} + + levn@0.3.0: + dependencies: + prelude-ls: 1.1.2 + type-check: 0.3.2 + levn@0.4.1: dependencies: prelude-ls: 1.2.1 @@ -36040,6 +38321,11 @@ snapshots: locate-character@3.0.0: {} + locate-path@3.0.0: + dependencies: + p-locate: 3.0.0 + path-exists: 3.0.0 + locate-path@5.0.0: dependencies: p-locate: 4.1.0 @@ -36058,12 +38344,18 @@ snapshots: lodash.castarray@4.4.0: {} + lodash.chunk@4.2.0: {} + + lodash.clonedeep@4.5.0: {} + lodash.debounce@4.0.8: {} lodash.defaults@4.2.0: {} lodash.escaperegexp@4.1.2: {} + lodash.flatten@4.4.0: {} + lodash.groupby@4.6.0: {} lodash.includes@4.3.0: {} @@ -36086,6 +38378,8 @@ snapshots: lodash.isundefined@3.0.1: {} + lodash.memoize@3.0.4: {} + lodash.merge@4.6.2: {} lodash.omit@4.5.0: {} @@ -36107,6 +38401,8 @@ snapshots: chalk: 4.1.2 is-unicode-supported: 0.1.0 + long@4.0.0: {} + long@5.2.3: {} longest-streak@3.1.0: {} @@ -36117,6 +38413,8 @@ snapshots: loupe@3.1.3: {} + lower-case@1.1.4: {} + lowercase-keys@1.0.1: {} lowercase-keys@2.0.0: {} @@ -36169,6 +38467,16 @@ snapshots: lz-string@1.4.4: {} + macos-release@2.5.1: {} + + magic-string@0.23.2: + dependencies: + sourcemap-codec: 1.4.8 + + magic-string@0.25.1: + dependencies: + sourcemap-codec: 1.4.8 + magic-string@0.30.17: dependencies: '@jridgewell/sourcemap-codec': 1.5.0 @@ -36189,10 +38497,16 @@ snapshots: '@babel/types': 7.27.0 source-map-js: 1.2.1 + make-dir@3.1.0: + dependencies: + semver: 6.3.1 + make-dir@4.0.0: dependencies: semver: 7.7.3 + manage-path@2.0.0: {} + map-obj@1.0.1: {} map-obj@4.3.0: {} @@ -36235,6 +38549,12 @@ snapshots: marked: 7.0.4 react: 18.3.1 + md5.js@1.3.5: + dependencies: + hash-base: 3.0.5 + inherits: 2.0.4 + safe-buffer: 5.2.1 + mdast-util-definitions@5.1.1: dependencies: '@types/mdast': 3.0.10 @@ -36535,6 +38855,10 @@ snapshots: merge-descriptors@2.0.0: {} + merge-source-map@1.0.4: + dependencies: + source-map: 0.5.6 + merge-stream@2.0.0: {} merge2@1.4.1: {} @@ -36981,6 +39305,11 @@ snapshots: braces: 3.0.3 picomatch: 2.3.1 + miller-rabin@4.0.1: + dependencies: + bn.js: 4.12.2 + brorand: 1.1.0 + mime-db@1.52.0: {} mime-db@1.53.0: {} @@ -36999,8 +39328,12 @@ snapshots: mime@3.0.0: {} + mimic-fn@1.2.0: {} + mimic-fn@2.1.0: {} + mimic-fn@3.1.0: {} + mimic-fn@4.0.0: {} mimic-response@1.0.1: {} @@ -37011,10 +39344,23 @@ snapshots: mini-svg-data-uri@1.4.4: {} + minify-stream@2.1.0: + dependencies: + concat-stream: 2.0.0 + convert-source-map: 1.9.0 + duplexify: 4.1.3 + from2-string: 1.1.0 + terser: 4.8.1 + xtend: 4.0.2 + minimal-polyfills@2.2.2: {} minimal-polyfills@2.2.3: {} + minimalistic-assert@1.0.1: {} + + minimalistic-crypto-utils@1.0.1: {} + minimatch@10.0.1: dependencies: brace-expansion: 2.0.1 @@ -37107,11 +39453,33 @@ snapshots: ml-array-max: 1.2.4 ml-array-min: 1.2.3 + ml-distance-euclidean@2.0.0: {} + + ml-kmeans@4.2.1: + dependencies: + ml-distance-euclidean: 2.0.0 + ml-matrix: 5.3.0 + ml-nearest-vector: 2.0.1 + ml-random: 0.5.0 + + ml-matrix@5.3.0: + dependencies: + ml-array-max: 1.2.4 + ml-array-rescale: 1.3.7 + ml-matrix@6.12.1: dependencies: is-any-array: 2.0.1 ml-array-rescale: 1.3.7 + ml-nearest-vector@2.0.1: + dependencies: + ml-distance-euclidean: 2.0.0 + + ml-random@0.5.0: + dependencies: + ml-xsadd: 2.0.0 + ml-spectra-processing@14.13.0: dependencies: binary-search: 1.3.6 @@ -37121,6 +39489,8 @@ snapshots: ml-matrix: 6.12.1 ml-xsadd: 3.0.1 + ml-xsadd@2.0.0: {} + ml-xsadd@3.0.1: {} mlly@1.7.1: @@ -37137,6 +39507,24 @@ snapshots: pkg-types: 1.3.1 ufo: 1.6.1 + module-deps@6.2.3: + dependencies: + JSONStream: 1.3.5 + browser-resolve: 2.0.0 + cached-path-relative: 1.1.0 + concat-stream: 1.6.2 + defined: 1.0.1 + detective: 5.2.1 + duplexer2: 0.1.4 + inherits: 2.0.4 + parents: 1.0.1 + readable-stream: 2.3.8 + resolve: 1.22.8 + stream-combiner2: 1.1.1 + subarg: 1.0.0 + through2: 2.0.5 + xtend: 4.0.2 + module-details-from-path@1.0.3: {} moo@0.5.2: {} @@ -37151,6 +39539,8 @@ snapshots: transitivePeerDependencies: - supports-color + morphdom@2.7.7: {} + mri@1.2.0: {} mrmime@1.0.1: {} @@ -37165,8 +39555,19 @@ snapshots: multipasta@0.2.5: {} + multistream@2.1.1: + dependencies: + inherits: 2.0.4 + readable-stream: 2.3.8 + mustache@4.2.0: {} + mute-stream@0.0.7: {} + + mutexify@1.4.0: + dependencies: + queue-tick: 1.0.1 + mz@2.7.0: dependencies: any-promise: 1.3.0 @@ -37189,6 +39590,29 @@ snapshots: stacktrace-js: 2.0.2 stylis: 4.3.0 + nanoassert@1.1.0: {} + + nanobench@2.1.1: + dependencies: + browser-process-hrtime: 0.1.3 + chalk: 1.1.3 + mutexify: 1.4.0 + pretty-hrtime: 1.0.3 + + nanohtml@1.10.0: + dependencies: + acorn-node: 1.8.2 + camel-case: 3.0.0 + convert-source-map: 1.9.0 + estree-is-member-expression: 1.0.0 + hyperx: 2.5.4 + is-boolean-attribute: 0.0.1 + nanoassert: 1.1.0 + nanobench: 2.1.1 + normalize-html-whitespace: 0.2.0 + through2: 2.0.5 + transform-ast: 2.4.4 + nanoid@3.3.11: {} nanoid@3.3.8: {} @@ -37205,12 +39629,46 @@ snapshots: natural-compare@1.4.0: {} - nearley@2.20.1: + ndarray-blas-level1@1.1.3: {} + + ndarray-cholesky-factorization@1.0.2: dependencies: - commander: 2.20.3 - moo: 0.5.2 - railroad-diagrams: 1.0.0 - randexp: 0.4.6 + ndarray: 1.0.19 + ndarray-blas-level1: 1.1.3 + ndarray-scratch: 1.2.0 + + ndarray-crout-decomposition@1.1.0: {} + + ndarray-determinant@1.0.0: + dependencies: + ndarray-crout-decomposition: 1.1.0 + ndarray-diagonal: 1.0.0 + ndarray-ops: 1.2.2 + ndarray-scratch: 1.2.0 + + ndarray-diagonal@1.0.0: + dependencies: + ndarray: 1.0.19 + + ndarray-inv@0.2.0: + dependencies: + ndarray: 1.0.19 + ndarray-scratch: 1.2.0 + + ndarray-ops@1.2.2: + dependencies: + cwise-compiler: 1.1.3 + + ndarray-scratch@1.2.0: + dependencies: + ndarray: 1.0.19 + ndarray-ops: 1.2.2 + typedarray-pool: 1.2.0 + + ndarray@1.0.19: + dependencies: + iota-array: 1.0.0 + is-buffer: 1.1.6 negotiator@0.6.3: {} @@ -37226,6 +39684,8 @@ snapshots: optionalDependencies: '@rollup/rollup-linux-x64-gnu': 4.53.2 + next-tick@1.1.0: {} + next@14.1.0(@opentelemetry/api@1.9.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1): dependencies: '@next/env': 14.1.0 @@ -37358,6 +39818,10 @@ snapshots: nice-try@1.0.5: {} + no-case@2.3.2: + dependencies: + lower-case: 1.1.4 + node-abi@3.75.0: dependencies: semver: 7.7.3 @@ -37407,6 +39871,8 @@ snapshots: dependencies: abbrev: 2.0.0 + normalize-html-whitespace@0.2.0: {} + normalize-package-data@2.5.0: dependencies: hosted-git-info: 2.8.9 @@ -37473,6 +39939,8 @@ snapshots: num2fraction@1.2.2: {} + number-is-nan@1.0.1: {} + nypm@0.3.9: dependencies: citty: 0.1.6 @@ -37597,10 +40065,16 @@ snapshots: on-headers@1.0.2: {} + on-net-listen@1.1.2: {} + once@1.4.0: dependencies: wrappy: 1.0.2 + onetime@2.0.1: + dependencies: + mimic-fn: 1.2.0 + onetime@5.1.2: dependencies: mimic-fn: 2.1.0 @@ -37624,6 +40098,11 @@ snapshots: is-inside-container: 1.0.0 is-wsl: 3.1.0 + open@7.4.2: + dependencies: + is-docker: 2.2.1 + is-wsl: 2.2.0 + open@8.4.0: dependencies: define-lazy-prop: 2.0.0 @@ -37708,6 +40187,19 @@ snapshots: jose: 6.0.8 oauth4webapi: 3.3.0 + opn@5.5.0: + dependencies: + is-wsl: 1.1.0 + + optionator@0.8.3: + dependencies: + deep-is: 0.1.4 + fast-levenshtein: 2.0.6 + levn: 0.3.0 + prelude-ls: 1.1.2 + type-check: 0.3.2 + word-wrap: 1.2.3 + optionator@0.9.1: dependencies: deep-is: 0.1.4 @@ -37729,6 +40221,13 @@ snapshots: strip-ansi: 6.0.1 wcwidth: 1.0.1 + os-browserify@0.3.0: {} + + os-name@4.0.1: + dependencies: + macos-release: 2.5.1 + windows-release: 4.0.0 + os-paths@7.4.0: optionalDependencies: fsevents: 2.3.3 @@ -37771,6 +40270,10 @@ snapshots: dependencies: yocto-queue: 1.1.1 + p-locate@3.0.0: + dependencies: + p-limit: 2.3.0 + p-locate@4.1.0: dependencies: p-limit: 2.3.0 @@ -37857,10 +40360,24 @@ snapshots: pako@0.2.9: {} + pako@1.0.11: {} + parent-module@1.0.1: dependencies: callsites: 3.1.0 + parents@1.0.1: + dependencies: + path-platform: 0.11.15 + + parse-asn1@5.1.9: + dependencies: + asn1.js: 4.10.1 + browserify-aes: 1.2.0 + evp_bytestokey: 1.0.3 + pbkdf2: 3.1.5 + safe-buffer: 5.2.1 + parse-duration@2.1.4: {} parse-entities@4.0.0: @@ -37913,8 +40430,12 @@ snapshots: dependencies: event-target-shim: 6.0.2 + path-browserify@1.0.1: {} + path-data-parser@0.1.0: {} + path-exists@3.0.0: {} + path-exists@4.0.0: {} path-exists@5.0.0: {} @@ -37929,6 +40450,8 @@ snapshots: path-parse@1.0.7: {} + path-platform@0.11.15: {} + path-scurry@1.11.1: dependencies: lru-cache: 10.4.3 @@ -37955,6 +40478,15 @@ snapshots: pathval@2.0.0: {} + pbkdf2@3.1.5: + dependencies: + create-hash: 1.2.0 + create-hmac: 1.1.7 + ripemd160: 2.0.3 + safe-buffer: 5.2.1 + sha.js: 2.4.12 + to-buffer: 1.2.2 + peberminta@0.9.0: {} peek-readable@5.4.2: {} @@ -38128,6 +40660,10 @@ snapshots: exsolve: 1.0.7 pathe: 2.0.3 + pkg-up@3.1.0: + dependencies: + find-up: 3.0.0 + platform@1.3.6: {} playwright-core@1.37.0: {} @@ -38159,6 +40695,13 @@ snapshots: postcss: 6.0.23 postcss-value-parser: 3.3.1 + postcss-import@13.0.0(postcss@8.5.6): + dependencies: + postcss: 8.5.6 + postcss-value-parser: 4.2.0 + read-cache: 1.0.0 + resolve: 1.22.8 + postcss-import@15.1.0(postcss@8.5.4): dependencies: postcss: 8.5.4 @@ -38408,7 +40951,7 @@ snapshots: mkdirp-classic: 0.5.3 napi-build-utils: 2.0.0 node-abi: 3.75.0 - pump: 3.0.0 + pump: 3.0.2 rc: 1.2.8 simple-get: 4.0.1 tar-fs: 2.1.3 @@ -38421,6 +40964,8 @@ snapshots: path-exists: 4.0.0 which-pm: 2.0.0 + prelude-ls@1.1.2: {} + prelude-ls@1.2.1: {} prepend-http@2.0.0: {} @@ -38433,6 +40978,8 @@ snapshots: prettier@3.0.0: {} + pretty-bytes@5.6.0: {} + pretty-format@27.5.1: dependencies: ansi-regex: 5.0.1 @@ -38575,6 +41122,23 @@ snapshots: '@types/node': 18.19.20 long: 5.2.3 + protocol-buffers-encodings@1.2.0: + dependencies: + b4a: 1.6.6 + signed-varint: 2.0.1 + varint: 5.0.0 + + protocol-buffers-schema@3.6.0: {} + + protocol-buffers@4.2.0: + dependencies: + generate-function: 2.3.1 + generate-object-property: 1.2.0 + protocol-buffers-encodings: 1.2.0 + protocol-buffers-schema: 3.6.0 + signed-varint: 2.0.1 + varint: 5.0.2 + proxy-addr@2.0.7: dependencies: forwarded: 0.2.0 @@ -38599,12 +41163,16 @@ snapshots: psl@1.9.0: {} - pump@2.0.1: + public-encrypt@4.0.3: dependencies: - end-of-stream: 1.4.4 - once: 1.4.0 + bn.js: 4.12.2 + browserify-rsa: 4.1.1 + create-hash: 1.2.0 + parse-asn1: 5.1.9 + randombytes: 2.1.0 + safe-buffer: 5.2.1 - pump@3.0.0: + pump@2.0.1: dependencies: end-of-stream: 1.4.4 once: 1.4.0 @@ -38620,10 +41188,20 @@ snapshots: inherits: 2.0.4 pump: 2.0.1 + pumpify@2.0.1: + dependencies: + duplexify: 4.1.3 + inherits: 2.0.4 + pump: 3.0.2 + punycode@1.4.1: {} punycode@2.2.0: {} + pupa@2.1.1: + dependencies: + escape-goat: 2.1.1 + puppeteer-core@24.15.0(bufferutil@4.0.9): dependencies: '@puppeteer/browsers': 2.10.6 @@ -38668,18 +41246,23 @@ snapshots: quansync@0.2.11: {} + querystring-es3@0.2.1: {} + + querystringify@2.2.0: {} + queue-microtask@1.2.3: {} + queue-tick@1.0.1: {} + quick-format-unescaped@4.0.4: {} quick-lru@4.0.1: {} - railroad-diagrams@1.0.0: {} - - randexp@0.4.6: + quote-stream@1.0.2: dependencies: - discontinuous-range: 1.0.0 - ret: 0.1.15 + buffer-equal: 0.0.1 + minimist: 1.2.7 + through2: 2.0.5 random-words@2.0.0: dependencies: @@ -38689,6 +41272,11 @@ snapshots: dependencies: safe-buffer: 5.2.1 + randomfill@1.0.4: + dependencies: + randombytes: 2.1.0 + safe-buffer: 5.2.1 + range-parser@1.2.1: {} raw-body@2.5.2: @@ -38832,7 +41420,7 @@ snapshots: react: 19.1.0 scheduler: 0.26.0 - react-email@2.1.2(@opentelemetry/api@1.9.0)(@swc/helpers@0.5.15)(bufferutil@4.0.9)(eslint@8.31.0): + react-email@2.1.2(@opentelemetry/api@1.9.0)(@swc/helpers@0.5.15)(eslint@8.31.0): dependencies: '@babel/parser': 7.24.1 '@radix-ui/colors': 1.0.1 @@ -38869,8 +41457,8 @@ snapshots: react: 18.3.1 react-dom: 18.2.0(react@18.3.1) shelljs: 0.8.5 - socket.io: 4.7.3(bufferutil@4.0.9) - socket.io-client: 4.7.3(bufferutil@4.0.9) + socket.io: 4.7.3 + socket.io-client: 4.7.3 sonner: 1.3.1(react-dom@18.2.0(react@18.3.1))(react@18.3.1) source-map-js: 1.0.2 stacktrace-parser: 0.1.10 @@ -39139,6 +41727,10 @@ snapshots: dependencies: pify: 2.3.0 + read-only-stream@2.0.0: + dependencies: + readable-stream: 2.3.8 + read-pkg-up@7.0.1: dependencies: find-up: 4.1.0 @@ -39314,6 +41906,8 @@ snapshots: hast-util-raw: 9.1.0 vfile: 6.0.3 + reinterval@1.1.0: {} + remark-frontmatter@4.0.1: dependencies: '@types/mdast': 3.0.10 @@ -39494,6 +42088,8 @@ snapshots: requireindex@1.2.0: {} + requires-port@1.0.0: {} + resend@3.2.0: dependencies: '@react-email/render': 0.0.12 @@ -39529,6 +42125,11 @@ snapshots: dependencies: lowercase-keys: 1.0.1 + restore-cursor@2.0.0: + dependencies: + onetime: 2.0.1 + signal-exit: 3.0.7 + restore-cursor@3.1.0: dependencies: onetime: 5.1.2 @@ -39538,6 +42139,8 @@ snapshots: ret@0.5.0: {} + retimer@3.0.0: {} + retry@0.12.0: {} retry@0.13.1: {} @@ -39565,6 +42168,11 @@ snapshots: glob: 11.0.0 package-json-from-dist: 1.0.0 + ripemd160@2.0.3: + dependencies: + hash-base: 3.1.2 + inherits: 2.0.4 + robot3@0.4.1: {} robust-predicates@3.0.2: {} @@ -39617,6 +42225,8 @@ snapshots: run-applescript@7.0.0: {} + run-async@2.4.1: {} + run-exclusive@2.2.18: dependencies: minimal-polyfills: 2.2.3 @@ -39629,6 +42239,10 @@ snapshots: rw@1.3.3: {} + rxjs@6.6.7: + dependencies: + tslib: 1.14.1 + rxjs@7.8.2: dependencies: tslib: 2.8.1 @@ -39692,6 +42306,16 @@ snapshots: ajv-formats: 2.1.1(ajv@8.17.1) ajv-keywords: 5.1.0(ajv@8.17.1) + scope-analyzer@2.1.2: + dependencies: + array-from: 2.1.1 + dash-ast: 2.0.1 + es6-map: 0.1.5 + es6-set: 0.1.6 + es6-symbol: 3.1.4 + estree-is-function: 1.0.0 + get-assigned-identifiers: 1.2.0 + screenfull@5.2.0: {} secure-json-parse@2.7.0: {} @@ -39709,6 +42333,10 @@ snapshots: '@types/semver': 6.2.3 semver: 6.3.1 + semver-diff@3.1.1: + dependencies: + semver: 6.3.1 + semver@5.7.1: {} semver@6.3.1: {} @@ -39822,6 +42450,14 @@ snapshots: setprototypeof@1.2.0: {} + sha.js@2.4.12: + dependencies: + inherits: 2.0.4 + safe-buffer: 5.2.1 + to-buffer: 1.2.2 + + shallow-copy@0.0.1: {} + sharp@0.33.5: dependencies: color: 4.2.3 @@ -39881,6 +42517,10 @@ snapshots: '@img/sharp-win32-x64': 0.34.5 optional: true + shasum-object@1.0.1: + dependencies: + fast-safe-stringify: 2.1.1 + shebang-command@1.2.0: dependencies: shebang-regex: 1.0.0 @@ -39914,6 +42554,10 @@ snapshots: shimmer@1.2.1: {} + showdown@1.9.1: + dependencies: + yargs: 14.2.3 + side-channel-list@1.0.0: dependencies: es-errors: 1.3.0 @@ -39948,6 +42592,10 @@ snapshots: signal-exit@4.1.0: {} + signed-varint@2.0.1: + dependencies: + varint: 5.0.2 + simple-concat@1.0.1: {} simple-get@4.0.1: @@ -39971,6 +42619,12 @@ snapshots: simplur@3.0.1: {} + single-line-log@1.1.2: + dependencies: + string-width: 1.0.2 + + sinusoidal-decimal@1.0.0: {} + sirv@2.0.4: dependencies: '@polka/url': 1.0.0-next.28 @@ -40015,7 +42669,7 @@ snapshots: - supports-color - utf-8-validate - socket.io-client@4.7.3(bufferutil@4.0.9): + socket.io-client@4.7.3: dependencies: '@socket.io/component-emitter': 3.1.0 debug: 4.3.7(supports-color@10.0.0) @@ -40044,7 +42698,7 @@ snapshots: transitivePeerDependencies: - supports-color - socket.io@4.7.3(bufferutil@4.0.9): + socket.io@4.7.3: dependencies: accepts: 1.3.8 base64id: 2.0.0 @@ -40085,6 +42739,11 @@ snapshots: ip-address: 9.0.5 smart-buffer: 4.2.0 + sonic-boom@1.4.1: + dependencies: + atomic-sleep: 1.0.0 + flatstr: 1.0.12 + sonic-boom@4.2.0: dependencies: atomic-sleep: 1.0.0 @@ -40120,6 +42779,8 @@ snapshots: dependencies: whatwg-url: 7.1.0 + sourcemap-codec@1.4.8: {} + space-separated-tokens@2.0.2: {} spawndamnit@2.0.0: @@ -40222,6 +42883,27 @@ snapshots: standard-as-callback@2.1.0: {} + static-eval@2.1.1: + dependencies: + escodegen: 2.1.0 + + static-module@3.0.4: + dependencies: + acorn-node: 1.8.2 + concat-stream: 1.6.2 + convert-source-map: 1.9.0 + duplexer2: 0.1.4 + escodegen: 1.14.3 + has: 1.0.3 + magic-string: 0.25.1 + merge-source-map: 1.0.4 + object-inspect: 1.13.4 + readable-stream: 2.3.8 + scope-analyzer: 2.1.2 + shallow-copy: 0.0.1 + static-eval: 2.1.1 + through2: 2.0.5 + statuses@2.0.1: {} std-env@3.7.0: {} @@ -40230,12 +42912,43 @@ snapshots: std-env@3.9.0: {} + stream-browserify@3.0.0: + dependencies: + inherits: 2.0.4 + readable-stream: 3.6.2 + stream-buffers@3.0.2: {} + stream-collector@1.0.1: + dependencies: + once: 1.4.0 + + stream-combiner2@1.1.1: + dependencies: + duplexer2: 0.1.4 + readable-stream: 2.3.8 + + stream-http@3.2.0: + dependencies: + builtin-status-codes: 3.0.0 + inherits: 2.0.4 + readable-stream: 3.6.2 + xtend: 4.0.2 + stream-shift@1.0.3: {} stream-slice@0.1.2: {} + stream-splicer@2.0.1: + dependencies: + inherits: 2.0.4 + readable-stream: 2.3.8 + + stream-template@0.0.10: + dependencies: + end-of-stream: 1.4.4 + readable-stream: 2.3.8 + stream-transform@2.1.3: dependencies: mixme: 0.5.4 @@ -40280,6 +42993,11 @@ snapshots: - '@types/react' - supports-color + streaming-json-stringify@3.1.0: + dependencies: + json-stringify-safe: 5.0.1 + readable-stream: 2.3.8 + streamsearch@1.1.0: {} streamx@2.22.0: @@ -40293,6 +43011,23 @@ snapshots: string-hash@1.1.3: {} + string-width@1.0.2: + dependencies: + code-point-at: 1.1.0 + is-fullwidth-code-point: 1.0.0 + strip-ansi: 3.0.1 + + string-width@2.1.1: + dependencies: + is-fullwidth-code-point: 2.0.0 + strip-ansi: 4.0.0 + + string-width@3.1.0: + dependencies: + emoji-regex: 7.0.3 + is-fullwidth-code-point: 2.0.0 + strip-ansi: 5.2.0 + string-width@4.2.3: dependencies: emoji-regex: 8.0.0 @@ -40366,6 +43101,18 @@ snapshots: character-entities-html4: 2.1.0 character-entities-legacy: 3.0.0 + strip-ansi@3.0.1: + dependencies: + ansi-regex: 2.1.1 + + strip-ansi@4.0.0: + dependencies: + ansi-regex: 3.0.1 + + strip-ansi@5.2.0: + dependencies: + ansi-regex: 4.1.1 + strip-ansi@6.0.1: dependencies: ansi-regex: 5.0.1 @@ -40434,6 +43181,10 @@ snapshots: stylis@4.3.6: {} + subarg@1.0.0: + dependencies: + minimist: 1.2.7 + sucrase@3.35.0: dependencies: '@jridgewell/gen-mapping': 0.3.8 @@ -40444,6 +43195,8 @@ snapshots: pirates: 4.0.5 ts-interface-checker: 0.1.13 + summary@2.1.0: {} + superagent@9.0.2: dependencies: component-emitter: 1.3.1 @@ -40473,6 +43226,8 @@ snapshots: supports-color@10.0.0: {} + supports-color@2.0.0: {} + supports-color@5.5.0: dependencies: has-flag: 3.0.0 @@ -40556,6 +43311,10 @@ snapshots: '@pkgr/utils': 2.3.1 tslib: 2.8.1 + syntax-error@1.4.0: + dependencies: + acorn-node: 1.8.2 + systeminformation@5.23.8: {} table@6.9.0: @@ -40566,6 +43325,8 @@ snapshots: string-width: 4.2.3 strip-ansi: 6.0.1 + tachyons@4.12.0: {} + tailwind-merge@1.12.0: {} tailwind-merge@2.2.0: @@ -40720,7 +43481,7 @@ snapshots: end-of-stream: 1.4.4 fs-constants: 1.0.0 inherits: 2.0.4 - readable-stream: 3.6.0 + readable-stream: 3.6.2 tar-stream@3.1.7: dependencies: @@ -40781,22 +43542,22 @@ snapshots: jest-worker: 27.5.1 schema-utils: 3.3.0 serialize-javascript: 6.0.1 - terser: 5.17.1 + terser: 5.44.1 webpack: 5.88.2(@swc/core@1.3.101(@swc/helpers@0.5.15))(esbuild@0.19.11) optionalDependencies: '@swc/core': 1.3.101(@swc/helpers@0.5.15) esbuild: 0.19.11 - terser@5.17.1: + terser@4.8.1: dependencies: - '@jridgewell/source-map': 0.3.3 - acorn: 8.14.1 + acorn: 8.15.0 commander: 2.20.3 + source-map: 0.6.1 source-map-support: 0.5.21 terser@5.44.1: dependencies: - '@jridgewell/source-map': 0.3.11 + '@jridgewell/source-map': 0.3.3 acorn: 8.15.0 commander: 2.20.3 source-map-support: 0.5.21 @@ -40856,6 +43617,23 @@ snapshots: readable-stream: 2.3.8 xtend: 4.0.2 + through2@3.0.2: + dependencies: + inherits: 2.0.4 + readable-stream: 3.6.2 + + through2@4.0.2: + dependencies: + readable-stream: 3.6.2 + + through@2.3.8: {} + + timers-browserify@1.4.2: + dependencies: + process: 0.11.10 + + timestring@6.0.0: {} + tiny-case@1.0.3: {} tiny-glob@0.2.9: @@ -40926,6 +43704,12 @@ snapshots: tmp@0.2.3: {} + to-buffer@1.2.2: + dependencies: + isarray: 2.0.5 + safe-buffer: 5.2.1 + typed-array-buffer: 1.0.3 + to-fast-properties@2.0.0: {} to-readable-stream@1.0.0: {} @@ -40956,12 +43740,29 @@ snapshots: psl: 1.9.0 punycode: 2.2.0 + tough-cookie@4.1.4: + dependencies: + psl: 1.9.0 + punycode: 2.2.0 + universalify: 0.2.0 + url-parse: 1.5.10 + tr46@0.0.3: {} tr46@1.0.1: dependencies: punycode: 2.2.0 + transform-ast@2.4.4: + dependencies: + acorn-node: 1.8.2 + convert-source-map: 1.9.0 + dash-ast: 1.0.0 + is-buffer: 2.0.5 + magic-string: 0.23.2 + merge-source-map: 1.0.4 + nanobench: 2.1.1 + tree-kill@1.2.2: {} trim-lines@3.0.1: {} @@ -41129,6 +43930,13 @@ snapshots: optionalDependencies: fsevents: 2.3.3 + ttest@3.0.0: + dependencies: + distributions: 2.2.0 + summary: 2.1.0 + + tty-browserify@0.0.1: {} + tty-table@4.1.6: dependencies: chalk: 4.1.2 @@ -41149,6 +43957,10 @@ snapshots: turbo-darwin-arm64@1.10.3: optional: true + turbo-json-parse@2.3.0: + dependencies: + generate-function: 2.3.1 + turbo-linux-64@1.10.3: optional: true @@ -41174,10 +43986,16 @@ snapshots: tweetnacl@0.14.5: {} + type-check@0.3.2: + dependencies: + prelude-ls: 1.1.2 + type-check@0.4.0: dependencies: prelude-ls: 1.2.1 + type-component@0.0.1: {} + type-fest@0.13.1: {} type-fest@0.20.2: {} @@ -41203,12 +44021,20 @@ snapshots: media-typer: 1.1.0 mime-types: 3.0.0 + type@2.7.3: {} + typed-array-buffer@1.0.2: dependencies: call-bind: 1.0.8 es-errors: 1.3.0 is-typed-array: 1.1.13 + typed-array-buffer@1.0.3: + dependencies: + call-bound: 1.0.4 + es-errors: 1.3.0 + is-typed-array: 1.1.15 + typed-array-byte-length@1.0.1: dependencies: call-bind: 1.0.8 @@ -41247,6 +44073,17 @@ snapshots: typed-query-selector@2.12.0: {} + typedarray-pool@1.2.0: + dependencies: + bit-twiddle: 1.0.2 + dup: 1.0.0 + + typedarray-to-buffer@3.1.5: + dependencies: + is-typedarray: 1.0.0 + + typedarray@0.0.6: {} + typescript@5.1.6: {} typescript@5.3.3: {} @@ -41270,6 +44107,8 @@ snapshots: dependencies: layerr: 2.0.1 + umd@3.0.3: {} + unbox-primitive@1.0.2: dependencies: call-bind: 1.0.8 @@ -41279,6 +44118,14 @@ snapshots: uncrypto@0.1.3: {} + undeclared-identifiers@1.1.3: + dependencies: + acorn-node: 1.8.2 + dash-ast: 1.0.0 + get-assigned-identifiers: 1.2.0 + simple-concat: 1.0.1 + xtend: 4.0.2 + undici-types@5.26.5: {} undici-types@6.20.0: {} @@ -41315,6 +44162,8 @@ snapshots: trough: 2.1.0 vfile: 6.0.3 + uniq@1.0.1: {} + unique-filename@3.0.0: dependencies: unique-slug: 4.0.0 @@ -41323,6 +44172,10 @@ snapshots: dependencies: imurmurhash: 0.1.4 + unique-string@2.0.0: + dependencies: + crypto-random-string: 2.0.0 + unist-util-find-after@5.0.0: dependencies: '@types/unist': 3.0.3 @@ -41402,6 +44255,8 @@ snapshots: universalify@0.1.2: {} + universalify@0.2.0: {} + universalify@2.0.0: {} unpipe@1.0.0: {} @@ -41424,6 +44279,23 @@ snapshots: escalade: 3.2.0 picocolors: 1.1.1 + update-notifier@5.1.0: + dependencies: + boxen: 5.1.2 + chalk: 4.1.2 + configstore: 5.0.1 + has-yarn: 2.1.0 + import-lazy: 2.1.0 + is-ci: 2.0.0 + is-installed-globally: 0.4.0 + is-npm: 5.0.0 + is-yarn-global: 0.3.0 + latest-version: 5.1.0 + pupa: 2.1.1 + semver: 7.7.3 + semver-diff: 3.1.1 + xdg-basedir: 4.0.0 + uploadthing@7.1.0(express@5.0.1)(fastify@5.4.0)(next@14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1))(tailwindcss@3.4.1): dependencies: '@effect/platform': 0.63.2(@effect/schema@0.72.2(effect@3.7.2))(effect@3.7.2) @@ -41437,6 +44309,8 @@ snapshots: next: 14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1) tailwindcss: 3.4.1 + upper-case@1.1.3: {} + uri-js@4.4.1: dependencies: punycode: 2.2.0 @@ -41445,6 +44319,16 @@ snapshots: dependencies: prepend-http: 2.0.0 + url-parse@1.5.10: + dependencies: + querystringify: 2.2.0 + requires-port: 1.0.0 + + url@0.11.4: + dependencies: + punycode: 1.4.1 + qs: 6.14.0 + urlpattern-polyfill@9.0.0: {} use-callback-ref@1.3.3(@types/react@18.2.69)(react@18.2.0): @@ -41501,6 +44385,12 @@ snapshots: util-deprecate@1.0.2: {} + util-extend@1.0.3: {} + + util@0.10.4: + dependencies: + inherits: 2.0.3 + util@0.12.5: dependencies: inherits: 2.0.4 @@ -41511,6 +44401,8 @@ snapshots: utils-merge@1.0.1: {} + uuid-parse@1.1.0: {} + uuid@10.0.0: {} uuid@11.1.0: {} @@ -41551,6 +44443,10 @@ snapshots: validate.io-function@1.0.2: {} + varint@5.0.0: {} + + varint@5.0.2: {} + vary@1.1.2: {} verror@1.10.0: @@ -41714,6 +44610,8 @@ snapshots: - supports-color - terser + vm-browserify@1.1.2: {} + vscode-jsonrpc@8.2.0: {} vscode-languageserver-protocol@3.17.5: @@ -41775,6 +44673,8 @@ snapshots: web-streams-polyfill@4.0.0-beta.3: {} + webfontloader@1.6.28: {} + webidl-conversions@3.0.1: {} webidl-conversions@4.0.2: {} @@ -41899,6 +44799,25 @@ snapshots: gopd: 1.2.0 has-tostringtag: 1.0.2 + which-typed-array@1.1.19: + dependencies: + available-typed-arrays: 1.0.7 + call-bind: 1.0.8 + call-bound: 1.0.4 + for-each: 0.3.5 + get-proto: 1.0.1 + gopd: 1.2.0 + has-tostringtag: 1.0.2 + + which-typed-array@1.1.9: + dependencies: + available-typed-arrays: 1.0.5 + call-bind: 1.0.7 + for-each: 0.3.3 + gopd: 1.2.0 + has-tostringtag: 1.0.0 + is-typed-array: 1.1.10 + which@1.3.1: dependencies: isexe: 2.0.0 @@ -41916,8 +44835,22 @@ snapshots: siginfo: 2.0.0 stackback: 0.0.2 + widest-line@3.1.0: + dependencies: + string-width: 4.2.3 + + windows-release@4.0.0: + dependencies: + execa: 4.1.0 + word-wrap@1.2.3: {} + wrap-ansi@5.1.0: + dependencies: + ansi-styles: 3.2.1 + string-width: 3.1.0 + strip-ansi: 5.2.0 + wrap-ansi@6.2.0: dependencies: ansi-styles: 4.3.0 @@ -41938,6 +44871,13 @@ snapshots: wrappy@1.0.2: {} + write-file-atomic@3.0.3: + dependencies: + imurmurhash: 0.1.4 + is-typedarray: 1.0.0 + signal-exit: 3.0.7 + typedarray-to-buffer: 3.1.5 + ws@7.5.9(bufferutil@4.0.9): optionalDependencies: bufferutil: 4.0.9 @@ -41968,6 +44908,8 @@ snapshots: optionalDependencies: fsevents: 2.3.3 + xdg-basedir@4.0.0: {} + xdg-portable@10.6.0: dependencies: os-paths: 7.4.0 @@ -41994,6 +44936,11 @@ snapshots: yaml@2.7.1: {} + yargs-parser@15.0.3: + dependencies: + camelcase: 5.3.1 + decamelize: 1.2.0 + yargs-parser@18.1.3: dependencies: camelcase: 5.3.1 @@ -42003,6 +44950,20 @@ snapshots: yargs-parser@21.1.1: {} + yargs@14.2.3: + dependencies: + cliui: 5.0.0 + decamelize: 1.2.0 + find-up: 3.0.0 + get-caller-file: 2.0.5 + require-directory: 2.1.1 + require-main-filename: 2.0.0 + set-blocking: 2.0.0 + string-width: 3.1.0 + which-module: 2.0.0 + y18n: 4.0.3 + yargs-parser: 15.0.3 + yargs@15.4.1: dependencies: cliui: 6.0.0 From 3c2c269079ca1047a6fb448fd26fa20a9a1a2dd1 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Fri, 9 Jan 2026 14:34:18 +0000 Subject: [PATCH 02/17] improve test harness producer throughput and better organize run outputs --- .../scripts/profile-runs-replication.ts | 126 +++++++++++++++++- apps/webapp/test/performance/config.ts | 8 ++ apps/webapp/test/performance/harness.ts | 102 +++++++++----- .../test/performance/metrics-collector.ts | 29 +++- .../test/performance/producer-runner.ts | 1 + apps/webapp/test/performance/producer.ts | 2 + 6 files changed, 222 insertions(+), 46 deletions(-) diff --git a/apps/webapp/scripts/profile-runs-replication.ts b/apps/webapp/scripts/profile-runs-replication.ts index b29b177f1e..639a458c2c 100644 --- a/apps/webapp/scripts/profile-runs-replication.ts +++ b/apps/webapp/scripts/profile-runs-replication.ts @@ -10,8 +10,11 @@ program .name("profile-runs-replication") .description("Profile RunsReplicationService performance and identify bottlenecks") .option("-c, --config ", "Config file path (JSON)") + .option("-n, --name ", "Run name/label (e.g., 'baseline', 'optimized-v1')") + .option("--description ", "Run description (what is being tested)") .option("-t, --throughput ", "Target throughput (records/sec)", "5000") .option("-d, --duration ", "Test duration per phase (seconds)", "60") + .option("-w, --workers ", "Number of producer worker processes", "1") .option("--mock-clickhouse", "Use mock ClickHouse (CPU-only profiling)") .option( "--profile ", @@ -59,6 +62,18 @@ async function loadConfig(options: any): Promise { } } + if (options.workers) { + config.producer.workerCount = parseInt(options.workers, 10); + } + + if (options.name) { + config.runName = options.name; + } + + if (options.description) { + config.runDescription = options.description; + } + if (options.mockClickhouse) { config.consumer.useMockClickhouse = true; } @@ -76,9 +91,12 @@ async function loadConfig(options: any): Promise { config.output.verbose = true; } - // Ensure output directory exists - const timestamp = new Date().toISOString().replace(/[:.]/g, "-").split("T")[0]; - const outputDir = path.join(config.profiling.outputDir, timestamp); + // Organize output directory: profiling-results/[runName]-[timestamp]/ + const timestamp = new Date().toISOString().replace(/[:.]/g, "-").replace("T", "_").split("_")[0]; + const timeWithSeconds = new Date().toISOString().replace(/[:.]/g, "-").replace("T", "_").substring(0, 19); + const runFolder = `${config.runName}-${timeWithSeconds}`; + const outputDir = path.join(config.profiling.outputDir, runFolder); + config.profiling.outputDir = outputDir; config.output.metricsFile = path.join(outputDir, "metrics.json"); @@ -89,6 +107,10 @@ function printConfig(config: HarnessConfig): void { console.log("\n" + "=".repeat(60)); console.log("RunsReplicationService Performance Test Harness"); console.log("=".repeat(60)); + console.log(`\n๐Ÿท๏ธ Run: ${config.runName}`); + if (config.runDescription) { + console.log(`๐Ÿ“ Description: ${config.runDescription}`); + } console.log("\n๐Ÿ“‹ Configuration:"); console.log(` Profiling DB: ${config.infrastructure.profilingDatabaseName}`); console.log(` Output Dir: ${config.profiling.outputDir}`); @@ -102,6 +124,7 @@ function printConfig(config: HarnessConfig): void { } console.log("\nโš™๏ธ Producer Config:"); + console.log(` Worker Processes: ${config.producer.workerCount}`); console.log(` Insert/Update: ${(config.producer.insertUpdateRatio * 100).toFixed(0)}% inserts`); console.log(` Batch Size: ${config.producer.batchSize}`); console.log(` Payload Size: ${config.producer.payloadSizeKB} KB`); @@ -133,6 +156,93 @@ function printSummary(phases: any[]): void { console.log("=".repeat(60) + "\n"); } +async function createSummaryReport( + config: HarnessConfig, + phases: any[], + outputPath: string +): Promise { + const lines: string[] = []; + + // Header + lines.push(`# Performance Test Run: ${config.runName}`); + lines.push(""); + lines.push(`**Date**: ${new Date().toISOString()}`); + if (config.runDescription) { + lines.push(`**Description**: ${config.runDescription}`); + } + lines.push(""); + + // Configuration + lines.push("## Configuration"); + lines.push(""); + lines.push(`- **Producer Workers**: ${config.producer.workerCount}`); + lines.push(`- **Batch Size**: ${config.producer.batchSize}`); + lines.push(`- **Insert/Update Ratio**: ${(config.producer.insertUpdateRatio * 100).toFixed(0)}% inserts`); + lines.push(`- **Payload Size**: ${config.producer.payloadSizeKB} KB`); + lines.push(`- **Consumer Flush Batch**: ${config.consumer.flushBatchSize}`); + lines.push(`- **Consumer Flush Interval**: ${config.consumer.flushIntervalMs} ms`); + lines.push(`- **Consumer Max Concurrency**: ${config.consumer.maxFlushConcurrency}`); + lines.push(`- **ClickHouse Mode**: ${config.consumer.useMockClickhouse ? "Mock (CPU-only)" : "Real"}`); + lines.push(`- **Profiling Tool**: ${config.profiling.tool}`); + lines.push(""); + + // Key Results - highlight most important metrics + lines.push("## Key Results"); + lines.push(""); + + // For flamegraph runs, focus on throughput only + if (config.profiling.enabled && config.profiling.tool !== "none") { + lines.push("**Profiling Output**: See flamegraph/analysis files in this directory"); + lines.push(""); + lines.push("### Throughput"); + lines.push(""); + lines.push("| Phase | Duration | Producer (rec/sec) | Consumer (rec/sec) |"); + lines.push("|-------|----------|--------------------|--------------------|"); + for (const phase of phases) { + lines.push( + `| ${phase.phase} | ${(phase.durationMs / 1000).toFixed(1)}s | ${phase.producerThroughput.toFixed(0)} | ${phase.consumerThroughput.toFixed(0)} |` + ); + } + } else { + // For non-profiling runs, show ELU prominently + lines.push("### Throughput & Event Loop Utilization"); + lines.push(""); + lines.push("| Phase | Duration | Producer (rec/sec) | Consumer (rec/sec) | ELU (%) |"); + lines.push("|-------|----------|--------------------|--------------------|---------|"); + for (const phase of phases) { + lines.push( + `| ${phase.phase} | ${(phase.durationMs / 1000).toFixed(1)}s | ${phase.producerThroughput.toFixed(0)} | ${phase.consumerThroughput.toFixed(0)} | ${(phase.eventLoopUtilization * 100).toFixed(1)}% |` + ); + } + } + lines.push(""); + + // Detailed Metrics + lines.push("## Detailed Metrics"); + lines.push(""); + + for (const phase of phases) { + lines.push(`### ${phase.phase}`); + lines.push(""); + lines.push(`- **Duration**: ${(phase.durationMs / 1000).toFixed(1)}s`); + lines.push(`- **Records Produced**: ${phase.recordsProduced.toLocaleString()}`); + lines.push(`- **Records Consumed**: ${phase.recordsConsumed.toLocaleString()}`); + lines.push(`- **Batches Flushed**: ${phase.batchesFlushed.toLocaleString()}`); + lines.push(`- **Producer Throughput**: ${phase.producerThroughput.toFixed(1)} rec/sec`); + lines.push(`- **Consumer Throughput**: ${phase.consumerThroughput.toFixed(1)} rec/sec`); + lines.push(`- **Event Loop Utilization**: ${(phase.eventLoopUtilization * 100).toFixed(1)}%`); + lines.push(`- **Heap Used**: ${phase.heapUsedMB.toFixed(1)} MB`); + lines.push(`- **Heap Total**: ${phase.heapTotalMB.toFixed(1)} MB`); + lines.push(`- **Replication Lag P50**: ${phase.replicationLagP50.toFixed(1)} ms`); + lines.push(`- **Replication Lag P95**: ${phase.replicationLagP95.toFixed(1)} ms`); + lines.push(`- **Replication Lag P99**: ${phase.replicationLagP99.toFixed(1)} ms`); + lines.push(""); + } + + // Write to file + await fs.writeFile(outputPath, lines.join("\n")); +} + async function main() { const options = program.opts(); const config = await loadConfig(options); @@ -146,14 +256,20 @@ async function main() { const phases = await harness.run(); await harness.teardown(); - // Export metrics + // Export metrics JSON await harness.exportMetrics(config.output.metricsFile); + // Create summary report + const summaryPath = path.join(config.profiling.outputDir, "SUMMARY.md"); + await createSummaryReport(config, phases, summaryPath); + // Print summary printSummary(phases); console.log("\nโœ… Profiling complete!"); - console.log(`๐Ÿ“Š Results saved to: ${config.profiling.outputDir}\n`); + console.log(`๐Ÿ“Š Results saved to: ${config.profiling.outputDir}`); + console.log(`๐Ÿ“„ Summary report: ${summaryPath}`); + console.log(`๐Ÿ“Š Detailed metrics: ${config.output.metricsFile}\n`); if (config.profiling.enabled && config.profiling.tool !== "none") { console.log("๐Ÿ”ฅ Profiling data:"); diff --git a/apps/webapp/test/performance/config.ts b/apps/webapp/test/performance/config.ts index 929e5dbf12..7ec9223b37 100644 --- a/apps/webapp/test/performance/config.ts +++ b/apps/webapp/test/performance/config.ts @@ -14,6 +14,8 @@ export interface TestPhase { export interface ProducerConfig { enabled: boolean; + workerCount: number; // Number of parallel producer processes + workerId?: string; // Unique identifier for this specific worker targetThroughput: number; insertUpdateRatio: number; // 0.0-1.0, e.g. 0.8 = 80% inserts, 20% updates batchSize: number; @@ -57,6 +59,8 @@ export interface InfrastructureConfig { } export interface HarnessConfig { + runName: string; // Short identifier for this run (e.g. "baseline", "optimized-v1") + runDescription?: string; // Optional longer description of what this run is testing phases: TestPhase[]; producer: ProducerConfig; consumer: ConsumerConfig; @@ -67,6 +71,8 @@ export interface HarnessConfig { export function getDefaultConfig(): Partial { return { + runName: "default", + runDescription: undefined, phases: [ { name: "warmup", @@ -81,6 +87,7 @@ export function getDefaultConfig(): Partial { ], producer: { enabled: true, + workerCount: 1, targetThroughput: 5000, insertUpdateRatio: 0.8, batchSize: 500, @@ -121,6 +128,7 @@ export function getDefaultConfig(): Partial { } export interface ProducerMetrics { + workerId?: string; // Unique identifier for this producer worker totalInserts: number; totalUpdates: number; actualThroughput: number; diff --git a/apps/webapp/test/performance/harness.ts b/apps/webapp/test/performance/harness.ts index d59a110a36..a4a155edb1 100644 --- a/apps/webapp/test/performance/harness.ts +++ b/apps/webapp/test/performance/harness.ts @@ -9,7 +9,7 @@ import path from "path"; export class RunsReplicationHarness { private prisma: PrismaClient | null = null; private adminPrisma: PrismaClient | null = null; - private producerProcess: ProducerProcessManager | null = null; + private producerProcesses: ProducerProcessManager[] = []; private consumerProcess: ConsumerProcessManager | null = null; private metricsCollector: MetricsCollector; @@ -52,11 +52,16 @@ export class RunsReplicationHarness { console.log("Running database migrations..."); await this.runMigrations(); - // 5. Configure replication + // 5. Truncate existing TaskRun data for clean slate + console.log("Truncating existing TaskRun data..."); + await this.prisma!.$executeRawUnsafe(`TRUNCATE TABLE public."TaskRun" CASCADE;`); + console.log("โœ… TaskRun table truncated"); + + // 6. Configure replication console.log("Configuring logical replication..."); await this.setupReplication(); - // 6. Set up test fixtures + // 7. Set up test fixtures console.log("Setting up test fixtures..."); await this.setupTestFixtures(); @@ -111,19 +116,31 @@ export class RunsReplicationHarness { await this.consumerProcess.start(); - // 10. Start producer process - console.log("Starting producer process..."); - this.producerProcess = new ProducerProcessManager(this.config.producer); + // 10. Start producer processes (multiple workers for high throughput) + const workerCount = this.config.producer.workerCount; + console.log(`Starting ${workerCount} producer process(es)...`); - this.producerProcess.setOnMetrics((metrics) => { - this.metricsCollector.recordProducerMetrics(metrics); - }); + for (let i = 0; i < workerCount; i++) { + const workerConfig = { ...this.config.producer }; + // Each worker gets a unique ID and a portion of the total throughput + workerConfig.workerId = `worker-${i + 1}`; + workerConfig.targetThroughput = this.config.producer.targetThroughput / workerCount; - this.producerProcess.setOnError((error) => { - console.error("Producer error:", error); - }); + const producerProcess = new ProducerProcessManager(workerConfig); + + producerProcess.setOnMetrics((metrics) => { + this.metricsCollector.recordProducerMetrics(metrics); + }); - await this.producerProcess.start(); + producerProcess.setOnError((error) => { + console.error(`Producer worker ${i + 1} error:`, error); + }); + + await producerProcess.start(); + this.producerProcesses.push(producerProcess); + + console.log(` โœ“ Producer worker ${i + 1}/${workerCount} started (target: ${workerConfig.targetThroughput.toFixed(0)} rec/sec)`); + } console.log("\nโœ… Profiling environment ready!\n"); } @@ -139,18 +156,23 @@ export class RunsReplicationHarness { this.metricsCollector.startPhase(phase.name); - // Start producer - this.producerProcess!.send({ - type: "start", - throughput: phase.targetThroughput, - }); + // Start all producer workers + const perWorkerThroughput = phase.targetThroughput / this.producerProcesses.length; + for (const producer of this.producerProcesses) { + producer.send({ + type: "start", + throughput: perWorkerThroughput, + }); + } // Wait for phase duration await this.waitWithProgress(phase.durationSec * 1000); - // Stop producer - this.producerProcess!.send({ type: "stop" }); - console.log("\nProducer stopped, waiting for consumer to catch up..."); + // Stop all producer workers + for (const producer of this.producerProcesses) { + producer.send({ type: "stop" }); + } + console.log("\nAll producers stopped, waiting for consumer to catch up..."); // Wait for consumer to catch up await this.waitForReplicationLag(100, 60000); @@ -168,9 +190,9 @@ export class RunsReplicationHarness { async teardown(): Promise { console.log("\n๐Ÿงน Tearing down...\n"); - if (this.producerProcess) { - console.log("Stopping producer process..."); - await this.producerProcess.stop(); + if (this.producerProcesses.length > 0) { + console.log(`Stopping ${this.producerProcesses.length} producer process(es)...`); + await Promise.all(this.producerProcesses.map((p) => p.stop())); } if (this.consumerProcess) { @@ -259,33 +281,41 @@ export class RunsReplicationHarness { `ALTER TABLE public."TaskRun" REPLICA IDENTITY FULL;` ); - // Check if slot exists + // Drop existing replication slot if it exists (ensures clean slate) const slotExists = await this.prisma!.$queryRaw>` SELECT slot_name FROM pg_replication_slots WHERE slot_name = ${this.config.consumer.slotName}; `; - if (slotExists.length === 0) { + if (slotExists.length > 0) { + console.log(`๐Ÿงน Dropping existing replication slot: ${this.config.consumer.slotName}`); await this.prisma!.$executeRawUnsafe( - `SELECT pg_create_logical_replication_slot('${this.config.consumer.slotName}', 'pgoutput');` + `SELECT pg_drop_replication_slot('${this.config.consumer.slotName}');` ); - console.log(`โœ… Created replication slot: ${this.config.consumer.slotName}`); - } else { - console.log(`โœ… Replication slot exists: ${this.config.consumer.slotName}`); } - // Check if publication exists + // Drop and recreate publication (ensures clean slate) const pubExists = await this.prisma!.$queryRaw>` SELECT pubname FROM pg_publication WHERE pubname = ${this.config.consumer.publicationName}; `; - if (pubExists.length === 0) { + if (pubExists.length > 0) { + console.log(`๐Ÿงน Dropping existing publication: ${this.config.consumer.publicationName}`); await this.prisma!.$executeRawUnsafe( - `CREATE PUBLICATION ${this.config.consumer.publicationName} FOR TABLE "TaskRun";` + `DROP PUBLICATION ${this.config.consumer.publicationName};` ); - console.log(`โœ… Created publication: ${this.config.consumer.publicationName}`); - } else { - console.log(`โœ… Publication exists: ${this.config.consumer.publicationName}`); } + + // Create fresh publication + await this.prisma!.$executeRawUnsafe( + `CREATE PUBLICATION ${this.config.consumer.publicationName} FOR TABLE "TaskRun";` + ); + console.log(`โœ… Created publication: ${this.config.consumer.publicationName}`); + + // Create fresh replication slot + await this.prisma!.$executeRawUnsafe( + `SELECT pg_create_logical_replication_slot('${this.config.consumer.slotName}', 'pgoutput');` + ); + console.log(`โœ… Created replication slot: ${this.config.consumer.slotName}`); } private async setupTestFixtures(): Promise { diff --git a/apps/webapp/test/performance/metrics-collector.ts b/apps/webapp/test/performance/metrics-collector.ts index 37dbc83ff8..0189ad0f2c 100644 --- a/apps/webapp/test/performance/metrics-collector.ts +++ b/apps/webapp/test/performance/metrics-collector.ts @@ -104,11 +104,30 @@ export class MetricsCollector { const durationMs = phase.endTime ? phase.endTime - phase.startTime : Date.now() - phase.startTime; const durationSec = durationMs / 1000; - // Producer metrics - const lastProducerMetric = phase.producerMetrics[phase.producerMetrics.length - 1]; - const recordsProduced = lastProducerMetric - ? lastProducerMetric.totalInserts + lastProducerMetric.totalUpdates - : 0; + // Producer metrics - aggregate from all workers + // Find the most recent metric from each worker and sum them + const latestMetricsByWorker = new Map(); + + for (const metric of phase.producerMetrics) { + const workerId = metric.workerId || "default"; + const existing = latestMetricsByWorker.get(workerId); + + // Keep the metric with the highest total (cumulative counters) + if (!existing || (metric.totalInserts + metric.totalUpdates) > (existing.totalInserts + existing.totalUpdates)) { + latestMetricsByWorker.set(workerId, metric); + } + } + + // Sum up the latest totals from each worker + let totalInserts = 0; + let totalUpdates = 0; + + for (const metric of latestMetricsByWorker.values()) { + totalInserts += metric.totalInserts; + totalUpdates += metric.totalUpdates; + } + + const recordsProduced = totalInserts + totalUpdates; const producerThroughput = durationSec > 0 ? recordsProduced / durationSec : 0; // Consumer metrics diff --git a/apps/webapp/test/performance/producer-runner.ts b/apps/webapp/test/performance/producer-runner.ts index 1b4124e24c..3963c6050d 100644 --- a/apps/webapp/test/performance/producer-runner.ts +++ b/apps/webapp/test/performance/producer-runner.ts @@ -42,6 +42,7 @@ async function main() { const producer = new TaskRunProducer({ prisma, dataGenerator, + workerId: config.workerId, targetThroughput: config.targetThroughput, insertUpdateRatio: config.insertUpdateRatio, batchSize: config.batchSize, diff --git a/apps/webapp/test/performance/producer.ts b/apps/webapp/test/performance/producer.ts index 86c407ad93..3509ccbd8e 100644 --- a/apps/webapp/test/performance/producer.ts +++ b/apps/webapp/test/performance/producer.ts @@ -5,6 +5,7 @@ import type { ProducerMetrics } from "./config"; export interface TaskRunProducerOptions { prisma: PrismaClient; dataGenerator: TaskRunDataGenerator; + workerId?: string; targetThroughput: number; insertUpdateRatio: number; batchSize: number; @@ -47,6 +48,7 @@ export class TaskRunProducer { const actualThroughput = elapsed > 0 ? (this.totalInserts + this.totalUpdates) / elapsed : 0; return { + workerId: this.options.workerId, totalInserts: this.totalInserts, totalUpdates: this.totalUpdates, actualThroughput, From b1e6dd059761fd5ad35999877612ca6f52ba3b3d Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Fri, 9 Jan 2026 17:10:16 +0000 Subject: [PATCH 03/17] use a less CPU-intensive way of inserting task runs --- .../services/runsReplicationService.server.ts | 4 +- .../scripts/profile-runs-replication.ts | 47 ++++++++++++++- apps/webapp/test/performance/config.ts | 1 + .../test/performance/consumer-runner.ts | 31 ++++++++-- apps/webapp/test/performance/consumer.ts | 54 +++++++++++++++--- apps/webapp/test/performance/harness.ts | 57 +++++++++++++++++-- internal-packages/clickhouse/src/index.ts | 4 ++ internal-packages/clickhouse/src/taskRuns.ts | 28 +++++++++ 8 files changed, 204 insertions(+), 22 deletions(-) diff --git a/apps/webapp/app/services/runsReplicationService.server.ts b/apps/webapp/app/services/runsReplicationService.server.ts index a561d990b9..b4f8fd8191 100644 --- a/apps/webapp/app/services/runsReplicationService.server.ts +++ b/apps/webapp/app/services/runsReplicationService.server.ts @@ -772,7 +772,7 @@ export class RunsReplicationService { async #insertTaskRunInserts(taskRunInserts: TaskRunV2[], attempt: number) { return await startSpan(this._tracer, "insertTaskRunsInserts", async (span) => { - const [insertError, insertResult] = await this.options.clickhouse.taskRuns.insert( + const [insertError, insertResult] = await this.options.clickhouse.taskRuns.insertUnsafe( taskRunInserts, { params: { @@ -797,7 +797,7 @@ export class RunsReplicationService { async #insertPayloadInserts(payloadInserts: RawTaskRunPayloadV1[], attempt: number) { return await startSpan(this._tracer, "insertPayloadInserts", async (span) => { - const [insertError, insertResult] = await this.options.clickhouse.taskRuns.insertPayloads( + const [insertError, insertResult] = await this.options.clickhouse.taskRuns.insertPayloadsUnsafe( payloadInserts, { params: { diff --git a/apps/webapp/scripts/profile-runs-replication.ts b/apps/webapp/scripts/profile-runs-replication.ts index 639a458c2c..4b89cc5361 100644 --- a/apps/webapp/scripts/profile-runs-replication.ts +++ b/apps/webapp/scripts/profile-runs-replication.ts @@ -3,6 +3,7 @@ import { program } from "commander"; import path from "path"; import fs from "fs/promises"; +import { spawn } from "child_process"; import { RunsReplicationHarness } from "../test/performance/harness"; import { getDefaultConfig, type HarnessConfig } from "../test/performance/config"; @@ -243,6 +244,48 @@ async function createSummaryReport( await fs.writeFile(outputPath, lines.join("\n")); } +async function generateVisualization(config: HarnessConfig): Promise { + console.log("\n๐Ÿ”ฅ Generating flamegraph visualization..."); + + // Find the clinic flame data file + const files = await fs.readdir(config.profiling.outputDir); + const flameDataFile = files.find((f) => f.endsWith(".clinic-flame")); + + if (!flameDataFile) { + console.warn("โš ๏ธ No clinic flame data file found. Skipping visualization."); + return; + } + + const dataPath = path.join(config.profiling.outputDir, flameDataFile); + console.log(` Data file: ${flameDataFile}`); + + // Run clinic flame --visualize-only + const clinicPath = path.join(__dirname, "../node_modules/.bin/clinic"); + + await new Promise((resolve, reject) => { + const proc = spawn(clinicPath, ["flame", "--visualize-only", dataPath], { + stdio: "inherit", + cwd: path.join(__dirname, ".."), + }); + + proc.on("exit", (code) => { + if (code === 0) { + console.log("โœ… Flamegraph generated successfully!"); + console.log(` Open: ${dataPath.replace(".clinic-flame", ".clinic-flame.html")}\n`); + resolve(); + } else { + console.error(`โš ๏ธ Flamegraph generation exited with code ${code}`); + resolve(); // Don't fail the whole run + } + }); + + proc.on("error", (error) => { + console.error("โš ๏ธ Error generating flamegraph:", error.message); + resolve(); // Don't fail the whole run + }); + }); +} + async function main() { const options = program.opts(); const config = await loadConfig(options); @@ -272,8 +315,8 @@ async function main() { console.log(`๐Ÿ“Š Detailed metrics: ${config.output.metricsFile}\n`); if (config.profiling.enabled && config.profiling.tool !== "none") { - console.log("๐Ÿ”ฅ Profiling data:"); - console.log(` View flamegraph/analysis in: ${config.profiling.outputDir}\n`); + // Generate visualization from collected data + await generateVisualization(config); } process.exit(0); diff --git a/apps/webapp/test/performance/config.ts b/apps/webapp/test/performance/config.ts index 7ec9223b37..56292b2d6c 100644 --- a/apps/webapp/test/performance/config.ts +++ b/apps/webapp/test/performance/config.ts @@ -38,6 +38,7 @@ export interface ConsumerConfig { redisOptions: RedisOptions; slotName: string; publicationName: string; + outputDir?: string; // For shutdown signal file } export interface ProfilingConfig { diff --git a/apps/webapp/test/performance/consumer-runner.ts b/apps/webapp/test/performance/consumer-runner.ts index 7908dd797e..cd9b4b078b 100644 --- a/apps/webapp/test/performance/consumer-runner.ts +++ b/apps/webapp/test/performance/consumer-runner.ts @@ -3,17 +3,24 @@ import { RunsReplicationService } from "~/services/runsReplicationService.server"; import { MockClickHouse } from "./clickhouse-mock"; import type { ConsumerConfig } from "./config"; +import fs from "fs"; +import path from "path"; async function main() { const hasIPC = !!process.send; if (!hasIPC) { - console.log("Warning: IPC not available (likely running under profiler) - metrics will not be sent to parent"); + console.log( + "Warning: IPC not available (likely running under profiler) - metrics will not be sent to parent" + ); } // Parse configuration from environment variable const config: ConsumerConfig = JSON.parse(process.env.CONSUMER_CONFIG!); + // Create shutdown signal file path + const shutdownFilePath = path.join(config.outputDir || "/tmp", ".shutdown-signal"); + console.log("Consumer process starting with config:", { useMockClickhouse: config.useMockClickhouse, flushBatchSize: config.flushBatchSize, @@ -34,6 +41,7 @@ async function main() { compression: { request: true, }, + logLevel: "info", }); } @@ -64,6 +72,20 @@ async function main() { }); } + // Watch for shutdown signal file (works even when IPC is unavailable) + const shutdownCheckInterval = setInterval(() => { + if (fs.existsSync(shutdownFilePath)) { + console.log("Consumer: Shutdown signal file detected, exiting..."); + clearInterval(shutdownCheckInterval); + clearInterval(metricsInterval); + // Clean up the signal file + try { + fs.unlinkSync(shutdownFilePath); + } catch (e) {} + process.exit(0); + } + }, 500); + // Send periodic metrics to parent (if IPC available) const metricsInterval = setInterval(() => { const memUsage = process.memoryUsage(); @@ -82,14 +104,13 @@ async function main() { } }, 1000); - // Listen for shutdown signal from parent (if IPC available) + // Listen for shutdown signal from parent (if IPC available, for non-profiling mode) if (hasIPC) { process.on("message", async (msg: any) => { if (msg.type === "shutdown") { - console.log("Consumer: Received shutdown signal"); + console.log("Consumer: Received IPC shutdown message"); + clearInterval(shutdownCheckInterval); clearInterval(metricsInterval); - await service.shutdown(); - await service.stop(); process.exit(0); } }); diff --git a/apps/webapp/test/performance/consumer.ts b/apps/webapp/test/performance/consumer.ts index 972b5062db..ead4846a74 100644 --- a/apps/webapp/test/performance/consumer.ts +++ b/apps/webapp/test/performance/consumer.ts @@ -1,5 +1,6 @@ import { ChildProcess, spawn } from "child_process"; import path from "path"; +import fs from "fs"; import type { ConsumerConfig, ProfilingConfig } from "./config"; interface ConsumerMetrics { @@ -37,6 +38,7 @@ export class ConsumerProcessManager { const isProfiling = this.profiling.enabled && this.profiling.tool !== "none"; this.process = spawn(args[0], args.slice(1), { + cwd: path.join(__dirname, "../.."), // Run from webapp directory env: { ...process.env, CONSUMER_CONFIG: JSON.stringify(this.config), @@ -99,18 +101,45 @@ export class ConsumerProcessManager { } console.log("Stopping consumer process"); - this.process.send({ type: "shutdown" }); + + const isProfiling = this.profiling.enabled && this.profiling.tool !== "none"; + + if (isProfiling) { + // When profiling, IPC doesn't work - use a shutdown signal file instead + const outputDir = this.config.outputDir || "/tmp"; + const shutdownFilePath = path.join(outputDir, ".shutdown-signal"); + console.log("Creating shutdown signal file for consumer (profiling mode)"); + + // Ensure directory exists + if (!fs.existsSync(outputDir)) { + fs.mkdirSync(outputDir, { recursive: true }); + } + + fs.writeFileSync(shutdownFilePath, "shutdown"); + } else { + // For non-profiling runs, use IPC message + try { + this.process.send({ type: "shutdown" }); + } catch (error) { + console.warn("Could not send shutdown message, process may have already exited"); + } + } // Wait for process to exit await new Promise((resolve) => { + // With shutdown signal file, consumer-runner should exit within a few seconds + // With --collect-only, Clinic.js then quickly packages the data and exits + const timeoutMs = isProfiling ? 15000 : 30000; + const timeout = setTimeout(() => { - console.warn("Consumer process did not exit gracefully, killing"); + console.warn(`Consumer process did not exit after ${timeoutMs}ms, killing`); this.process?.kill("SIGKILL"); resolve(); - }, 30000); // 30 second timeout + }, timeoutMs); - this.process?.on("exit", () => { + this.process?.on("exit", (code, signal) => { clearTimeout(timeout); + console.log(`Consumer process exited with code ${code}, signal ${signal}`); resolve(); }); }); @@ -144,14 +173,21 @@ export class ConsumerProcessManager { const tool = this.profiling.tool === "both" ? "doctor" : this.profiling.tool; const runnerPath = path.join(__dirname, "consumer-runner.ts"); + // Use clinic from node_modules/.bin directly (more reliable than pnpm exec) + const clinicPath = path.join(__dirname, "../../node_modules/.bin/clinic"); + + // Point --dest to the output directory itself + // Clinic.js will create PID.clinic-flame inside this directory + const destPath = path.resolve(this.profiling.outputDir); + // Clinic.js requires node, so use node with tsx/register loader const args = [ - "pnpm", - "exec", - "clinic", + clinicPath, tool, + "--collect-only", // Only collect data, don't generate visualization immediately + "--open=false", // Don't try to open in browser "--dest", - this.profiling.outputDir, + destPath, "--", "node", "--import", @@ -159,6 +195,8 @@ export class ConsumerProcessManager { runnerPath, ]; + console.log(`Clinic.js will save profiling data to: ${destPath}`); + return args; } diff --git a/apps/webapp/test/performance/harness.ts b/apps/webapp/test/performance/harness.ts index a4a155edb1..d49b536012 100644 --- a/apps/webapp/test/performance/harness.ts +++ b/apps/webapp/test/performance/harness.ts @@ -97,6 +97,9 @@ export class RunsReplicationHarness { // 9. Start consumer process console.log("\nStarting consumer process..."); + // Set outputDir for shutdown signal file (needed when IPC isn't available under Clinic.js) + this.config.consumer.outputDir = this.config.profiling.outputDir; + this.consumerProcess = new ConsumerProcessManager( this.config.consumer, this.config.profiling @@ -282,15 +285,59 @@ export class RunsReplicationHarness { ); // Drop existing replication slot if it exists (ensures clean slate) - const slotExists = await this.prisma!.$queryRaw>` - SELECT slot_name FROM pg_replication_slots WHERE slot_name = ${this.config.consumer.slotName}; + const slotExists = await this.prisma!.$queryRaw< + Array<{ slot_name: string; active: boolean; active_pid: number | null }> + >` + SELECT slot_name, active, active_pid FROM pg_replication_slots WHERE slot_name = ${this.config.consumer.slotName}; `; if (slotExists.length > 0) { + const slot = slotExists[0]; console.log(`๐Ÿงน Dropping existing replication slot: ${this.config.consumer.slotName}`); - await this.prisma!.$executeRawUnsafe( - `SELECT pg_drop_replication_slot('${this.config.consumer.slotName}');` - ); + + // If the slot is active, terminate the backend process first + if (slot.active && slot.active_pid) { + console.log( + `โš ๏ธ Replication slot is active for PID ${slot.active_pid}, terminating backend...` + ); + try { + await this.prisma!.$executeRawUnsafe( + `SELECT pg_terminate_backend(${slot.active_pid});` + ); + console.log(`โœ… Terminated backend process ${slot.active_pid}`); + + // Wait a bit for the termination to complete + await new Promise((resolve) => setTimeout(resolve, 1000)); + } catch (error) { + console.warn( + `โš ๏ธ Could not terminate backend ${slot.active_pid}, it may have already exited` + ); + } + } + + // Now try to drop the slot with retry logic + let attempts = 0; + const maxAttempts = 5; + while (attempts < maxAttempts) { + try { + await this.prisma!.$executeRawUnsafe( + `SELECT pg_drop_replication_slot('${this.config.consumer.slotName}');` + ); + console.log(`โœ… Dropped replication slot: ${this.config.consumer.slotName}`); + break; + } catch (error: any) { + attempts++; + if (attempts === maxAttempts) { + throw new Error( + `Failed to drop replication slot after ${maxAttempts} attempts: ${error.message}` + ); + } + console.log( + `โš ๏ธ Slot still active, waiting 2s before retry (attempt ${attempts}/${maxAttempts})...` + ); + await new Promise((resolve) => setTimeout(resolve, 2000)); + } + } } // Drop and recreate publication (ensures clean slate) diff --git a/internal-packages/clickhouse/src/index.ts b/internal-packages/clickhouse/src/index.ts index 03b8b81e13..35cb7dbd0c 100644 --- a/internal-packages/clickhouse/src/index.ts +++ b/internal-packages/clickhouse/src/index.ts @@ -4,7 +4,9 @@ import { ClickhouseReader, ClickhouseWriter } from "./client/types.js"; import { NoopClient } from "./client/noop.js"; import { insertTaskRuns, + insertTaskRunsUnsafe, insertRawTaskRunPayloads, + insertRawTaskRunPayloadsUnsafe, getTaskRunsQueryBuilder, getTaskActivityQueryBuilder, getCurrentRunningStats, @@ -169,7 +171,9 @@ export class ClickHouse { get taskRuns() { return { insert: insertTaskRuns(this.writer), + insertUnsafe: insertTaskRunsUnsafe(this.writer), insertPayloads: insertRawTaskRunPayloads(this.writer), + insertPayloadsUnsafe: insertRawTaskRunPayloadsUnsafe(this.writer), queryBuilder: getTaskRunsQueryBuilder(this.reader), countQueryBuilder: getTaskRunsCountQueryBuilder(this.reader), tagQueryBuilder: getTaskRunTagsQueryBuilder(this.reader), diff --git a/internal-packages/clickhouse/src/taskRuns.ts b/internal-packages/clickhouse/src/taskRuns.ts index d57a8b2a3e..267b0647e5 100644 --- a/internal-packages/clickhouse/src/taskRuns.ts +++ b/internal-packages/clickhouse/src/taskRuns.ts @@ -65,6 +65,18 @@ export function insertTaskRuns(ch: ClickhouseWriter, settings?: ClickHouseSettin }); } +export function insertTaskRunsUnsafe(ch: ClickhouseWriter, settings?: ClickHouseSettings) { + return ch.insertUnsafe({ + name: "insertTaskRunsUnsafe", + table: "trigger_dev.task_runs_v2", + settings: { + enable_json_type: 1, + type_json_skip_duplicated_paths: 1, + ...settings, + }, + }); +} + export const RawTaskRunPayloadV1 = z.object({ run_id: z.string(), created_at: z.number().int(), @@ -90,6 +102,22 @@ export function insertRawTaskRunPayloads(ch: ClickhouseWriter, settings?: ClickH }); } +export function insertRawTaskRunPayloadsUnsafe(ch: ClickhouseWriter, settings?: ClickHouseSettings) { + return ch.insertUnsafe({ + name: "insertRawTaskRunPayloadsUnsafe", + table: "trigger_dev.raw_task_runs_payload_v1", + settings: { + async_insert: 1, + wait_for_async_insert: 0, + async_insert_max_data_size: "1000000", + async_insert_busy_timeout_ms: 1000, + enable_json_type: 1, + type_json_skip_duplicated_paths: 1, + ...settings, + }, + }); +} + export const TaskRunV2QueryResult = z.object({ run_id: z.string(), }); From 03c564aa2b1edcc0e188b9a621aadc259c8ce69a Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Sat, 10 Jan 2026 12:50:34 +0000 Subject: [PATCH 04/17] use compact insert strategy for runs --- .../services/runsReplicationService.server.ts | 173 +++++++++--------- apps/webapp/test/performance/harness.ts | 25 ++- .../test/runsReplicationService.part2.test.ts | 43 ++--- .../clickhouse/src/client/client.ts | 76 +++++++- .../clickhouse/src/client/noop.ts | 29 +++ .../clickhouse/src/client/types.ts | 8 + internal-packages/clickhouse/src/index.ts | 8 + internal-packages/clickhouse/src/taskRuns.ts | 173 ++++++++++++++++++ internal-packages/replication/src/pgoutput.ts | 144 +++++++++++++++ 9 files changed, 558 insertions(+), 121 deletions(-) diff --git a/apps/webapp/app/services/runsReplicationService.server.ts b/apps/webapp/app/services/runsReplicationService.server.ts index b4f8fd8191..6d9b631a0c 100644 --- a/apps/webapp/app/services/runsReplicationService.server.ts +++ b/apps/webapp/app/services/runsReplicationService.server.ts @@ -1,4 +1,5 @@ import type { ClickHouse, RawTaskRunPayloadV1, TaskRunV2 } from "@internal/clickhouse"; +import { TASK_RUN_COLUMNS, PAYLOAD_COLUMNS } from "@internal/clickhouse"; import { type RedisOptions } from "@internal/redis"; import { LogicalReplicationClient, @@ -80,9 +81,7 @@ type TaskRunInsert = { export type RunsReplicationServiceEvents = { message: [{ lsn: string; message: PgoutputMessage; service: RunsReplicationService }]; - batchFlushed: [ - { flushId: string; taskRunInserts: TaskRunV2[]; payloadInserts: RawTaskRunPayloadV1[] } - ]; + batchFlushed: [{ flushId: string; taskRunInserts: any[][]; payloadInserts: any[][] }]; }; export class RunsReplicationService { @@ -171,12 +170,9 @@ export class RunsReplicationService { description: "Insert retry attempts", }); - this._eventsProcessedCounter = this._meter.createCounter( - "runs_replication.events_processed", - { - description: "Replication events processed (inserts, updates, deletes)", - } - ); + this._eventsProcessedCounter = this._meter.createCounter("runs_replication.events_processed", { + description: "Replication events processed (inserts, updates, deletes)", + }); this._flushDurationHistogram = this._meter.createHistogram( "runs_replication.flush_duration_ms", @@ -581,20 +577,25 @@ export class RunsReplicationService { .filter(Boolean) // batch inserts in clickhouse are more performant if the items // are pre-sorted by the primary key + // Array indices: [0]=environment_id, [1]=organization_id, [2]=project_id, [3]=run_id, [5]=created_at .sort((a, b) => { - if (a.organization_id !== b.organization_id) { - return a.organization_id < b.organization_id ? -1 : 1; + if (a[1] !== b[1]) { + // organization_id + return a[1] < b[1] ? -1 : 1; } - if (a.project_id !== b.project_id) { - return a.project_id < b.project_id ? -1 : 1; + if (a[2] !== b[2]) { + // project_id + return a[2] < b[2] ? -1 : 1; } - if (a.environment_id !== b.environment_id) { - return a.environment_id < b.environment_id ? -1 : 1; + if (a[0] !== b[0]) { + // environment_id + return a[0] < b[0] ? -1 : 1; } - if (a.created_at !== b.created_at) { - return a.created_at - b.created_at; + if (a[5] !== b[5]) { + // created_at + return a[5] - b[5]; } - return a.run_id < b.run_id ? -1 : 1; + return a[3] < b[3] ? -1 : 1; // run_id }); const payloadInserts = preparedInserts @@ -602,8 +603,9 @@ export class RunsReplicationService { .filter(Boolean) // batch inserts in clickhouse are more performant if the items // are pre-sorted by the primary key + // Array indices: [0]=run_id .sort((a, b) => { - return a.run_id < b.run_id ? -1 : 1; + return a[0] < b[0] ? -1 : 1; // run_id }); span.setAttribute("task_run_inserts", taskRunInserts.length); @@ -633,7 +635,6 @@ export class RunsReplicationService { this.logger.error("Error inserting task run inserts", { error: taskRunError, flushId, - runIds: taskRunInserts.map((r) => r.run_id), }); recordSpanError(span, taskRunError); } @@ -642,7 +643,6 @@ export class RunsReplicationService { this.logger.error("Error inserting payload inserts", { error: payloadError, flushId, - runIds: payloadInserts.map((r) => r.run_id), }); recordSpanError(span, payloadError); } @@ -770,16 +770,14 @@ export class RunsReplicationService { } } - async #insertTaskRunInserts(taskRunInserts: TaskRunV2[], attempt: number) { + async #insertTaskRunInserts(taskRunInserts: any[][], attempt: number) { return await startSpan(this._tracer, "insertTaskRunsInserts", async (span) => { - const [insertError, insertResult] = await this.options.clickhouse.taskRuns.insertUnsafe( - taskRunInserts, - { + const [insertError, insertResult] = + await this.options.clickhouse.taskRuns.insertCompactArrays(taskRunInserts, { params: { clickhouse_settings: this.#getClickhouseInsertSettings(), }, - } - ); + }); if (insertError) { this.logger.error("Error inserting task run inserts attempt", { @@ -795,16 +793,14 @@ export class RunsReplicationService { }); } - async #insertPayloadInserts(payloadInserts: RawTaskRunPayloadV1[], attempt: number) { + async #insertPayloadInserts(payloadInserts: any[][], attempt: number) { return await startSpan(this._tracer, "insertPayloadInserts", async (span) => { - const [insertError, insertResult] = await this.options.clickhouse.taskRuns.insertPayloadsUnsafe( - payloadInserts, - { + const [insertError, insertResult] = + await this.options.clickhouse.taskRuns.insertPayloadsCompactArrays(payloadInserts, { params: { clickhouse_settings: this.#getClickhouseInsertSettings(), }, - } - ); + }); if (insertError) { this.logger.error("Error inserting payload inserts attempt", { @@ -822,7 +818,7 @@ export class RunsReplicationService { async #prepareRunInserts( batchedRun: TaskRunInsert - ): Promise<{ taskRunInsert?: TaskRunV2; payloadInsert?: RawTaskRunPayloadV1 }> { + ): Promise<{ taskRunInsert?: any[]; payloadInsert?: any[] }> { this.logger.debug("Preparing run", { batchedRun, }); @@ -875,66 +871,67 @@ export class RunsReplicationService { environmentType: string, event: "insert" | "update" | "delete", _version: bigint - ): Promise { + ): Promise { const output = await this.#prepareJson(run.output, run.outputType); - return { - environment_id: run.runtimeEnvironmentId, - organization_id: organizationId, - project_id: run.projectId, - run_id: run.id, - updated_at: run.updatedAt.getTime(), - created_at: run.createdAt.getTime(), - status: run.status, - environment_type: environmentType, - friendly_id: run.friendlyId, - engine: run.engine, - task_identifier: run.taskIdentifier, - queue: run.queue, - span_id: run.spanId, - trace_id: run.traceId, - error: { data: run.error }, - attempt: run.attemptNumber ?? 1, - schedule_id: run.scheduleId ?? "", - batch_id: run.batchId ?? "", - completed_at: run.completedAt?.getTime(), - started_at: run.startedAt?.getTime(), - executed_at: run.executedAt?.getTime(), - delay_until: run.delayUntil?.getTime(), - queued_at: run.queuedAt?.getTime(), - expired_at: run.expiredAt?.getTime(), - usage_duration_ms: run.usageDurationMs, - cost_in_cents: run.costInCents, - base_cost_in_cents: run.baseCostInCents, - tags: run.runTags ?? [], - task_version: run.taskVersion ?? "", - sdk_version: run.sdkVersion ?? "", - cli_version: run.cliVersion ?? "", - machine_preset: run.machinePreset ?? "", - root_run_id: run.rootTaskRunId ?? "", - parent_run_id: run.parentTaskRunId ?? "", - depth: run.depth, - is_test: run.isTest, - idempotency_key: run.idempotencyKey ?? "", - expiration_ttl: run.ttl ?? "", - output, - concurrency_key: run.concurrencyKey ?? "", - bulk_action_group_ids: run.bulkActionGroupIds ?? [], - worker_queue: run.masterQueue, - max_duration_in_seconds: run.maxDurationInSeconds ?? undefined, - _version: _version.toString(), - _is_deleted: event === "delete" ? 1 : 0, - }; + // Return array matching TASK_RUN_COLUMNS order + return [ + run.runtimeEnvironmentId, // environment_id + organizationId, // organization_id + run.projectId, // project_id + run.id, // run_id + run.updatedAt.getTime(), // updated_at + run.createdAt.getTime(), // created_at + run.status, // status + environmentType, // environment_type + run.friendlyId, // friendly_id + run.attemptNumber ?? 1, // attempt + run.engine, // engine + run.taskIdentifier, // task_identifier + run.queue, // queue + run.scheduleId ?? "", // schedule_id + run.batchId ?? "", // batch_id + run.completedAt?.getTime() ?? null, // completed_at + run.startedAt?.getTime() ?? null, // started_at + run.executedAt?.getTime() ?? null, // executed_at + run.delayUntil?.getTime() ?? null, // delay_until + run.queuedAt?.getTime() ?? null, // queued_at + run.expiredAt?.getTime() ?? null, // expired_at + run.usageDurationMs ?? 0, // usage_duration_ms + run.costInCents ?? 0, // cost_in_cents + run.baseCostInCents ?? 0, // base_cost_in_cents + output, // output + { data: run.error }, // error + run.runTags ?? [], // tags + run.taskVersion ?? "", // task_version + run.sdkVersion ?? "", // sdk_version + run.cliVersion ?? "", // cli_version + run.machinePreset ?? "", // machine_preset + run.rootTaskRunId ?? "", // root_run_id + run.parentTaskRunId ?? "", // parent_run_id + run.depth ?? 0, // depth + run.spanId, // span_id + run.traceId, // trace_id + run.idempotencyKey ?? "", // idempotency_key + run.ttl ?? "", // expiration_ttl + run.isTest ?? false, // is_test + run.concurrencyKey ?? "", // concurrency_key + run.bulkActionGroupIds ?? [], // bulk_action_group_ids + run.masterQueue ?? "", // worker_queue + _version.toString(), // _version + event === "delete" ? 1 : 0, // _is_deleted + ]; } - async #preparePayloadInsert(run: TaskRun, _version: bigint): Promise { + async #preparePayloadInsert(run: TaskRun, _version: bigint): Promise { const payload = await this.#prepareJson(run.payload, run.payloadType); - return { - run_id: run.id, - created_at: run.createdAt.getTime(), - payload, - }; + // Return array matching PAYLOAD_COLUMNS order + return [ + run.id, // run_id + run.createdAt.getTime(), // created_at + payload, // payload + ]; } async #prepareJson( diff --git a/apps/webapp/test/performance/harness.ts b/apps/webapp/test/performance/harness.ts index d49b536012..a1503951a5 100644 --- a/apps/webapp/test/performance/harness.ts +++ b/apps/webapp/test/performance/harness.ts @@ -511,6 +511,7 @@ export class RunsReplicationHarness { const clickhouse = new ClickHouse({ url: this.config.infrastructure.clickhouseUrl!, name: "profiling-migrator", + logLevel: "error", // Suppress migration spam - we handle errors ourselves }); try { @@ -523,10 +524,11 @@ export class RunsReplicationHarness { .filter((f) => f.endsWith(".sql")) .sort(); // Ensure numeric ordering - console.log(`Found ${sqlFiles.length} migration files`); + // Suppress verbose output - only show errors + let successCount = 0; + let skippedCount = 0; for (const file of sqlFiles) { - console.log(` Running migration: ${file}`); const sql = await fs.readFile(path.join(migrationsPath, file), "utf-8"); // Parse goose migration file - only execute "up" section @@ -567,21 +569,28 @@ export class RunsReplicationHarness { for (const statement of statements) { try { - console.log(` Executing: ${statement.substring(0, 80)}...`); // Use the underlying client's command method await (clickhouse.writer as any).client.command({ query: statement }); - console.log(` โœ“ Success`); + successCount++; } catch (error: any) { - // Ignore "already exists" errors - if (error.message?.includes("already exists") || error.message?.includes("ALREADY_EXISTS")) { - console.log(` โŠ˜ Skipped (already exists)`); + // Ignore "already exists" errors silently + if ( + error.message?.includes("already exists") || + error.message?.includes("ALREADY_EXISTS") || + error.code === "57" + ) { + skippedCount++; } else { - console.log(` โœ— Error: ${error.message}`); + console.error(`โœ— Migration error in ${file}: ${error.message}`); throw error; } } } } + + if (successCount > 0 || skippedCount > 0) { + console.log(`Migrations: ${successCount} applied, ${skippedCount} skipped`); + } } finally { await clickhouse.close(); } diff --git a/apps/webapp/test/runsReplicationService.part2.test.ts b/apps/webapp/test/runsReplicationService.part2.test.ts index e08b579738..6375adb4b7 100644 --- a/apps/webapp/test/runsReplicationService.part2.test.ts +++ b/apps/webapp/test/runsReplicationService.part2.test.ts @@ -889,18 +889,12 @@ describe("RunsReplicationService (part 2/2)", () => { await setTimeout(1000); expect(batchFlushedEvents?.[0].taskRunInserts).toHaveLength(2); - expect(batchFlushedEvents?.[0].taskRunInserts[0]).toEqual( - expect.objectContaining({ - run_id: run.id, - status: "PENDING_VERSION", - }) - ); - expect(batchFlushedEvents?.[0].taskRunInserts[1]).toEqual( - expect.objectContaining({ - run_id: run.id, - status: "COMPLETED_SUCCESSFULLY", - }) - ); + // taskRunInserts are now arrays, not objects + // Index 3 is run_id, Index 6 is status + expect(batchFlushedEvents?.[0].taskRunInserts[0][3]).toEqual(run.id); // run_id + expect(batchFlushedEvents?.[0].taskRunInserts[0][6]).toEqual("PENDING_VERSION"); // status + expect(batchFlushedEvents?.[0].taskRunInserts[1][3]).toEqual(run.id); // run_id + expect(batchFlushedEvents?.[0].taskRunInserts[1][6]).toEqual("COMPLETED_SUCCESSFULLY"); // status await runsReplicationService.stop(); } @@ -1065,23 +1059,24 @@ describe("RunsReplicationService (part 2/2)", () => { expect(batchFlushedEvents[0]?.payloadInserts.length).toBeGreaterThan(1); // Verify sorting order: organization_id, project_id, environment_id, created_at, run_id + // taskRunInserts are now arrays: [0]=environment_id, [1]=organization_id, [2]=project_id, [3]=run_id, [5]=created_at for (let i = 1; i < batchFlushedEvents[0]?.taskRunInserts.length; i++) { const prev = batchFlushedEvents[0]?.taskRunInserts[i - 1]; const curr = batchFlushedEvents[0]?.taskRunInserts[i]; const prevKey = [ - prev.organization_id, - prev.project_id, - prev.environment_id, - prev.created_at, - prev.run_id, + prev[1], // organization_id + prev[2], // project_id + prev[0], // environment_id + prev[5], // created_at + prev[3], // run_id ]; const currKey = [ - curr.organization_id, - curr.project_id, - curr.environment_id, - curr.created_at, - curr.run_id, + curr[1], // organization_id + curr[2], // project_id + curr[0], // environment_id + curr[5], // created_at + curr[3], // run_id ]; const keysAreEqual = prevKey.every((val, idx) => val === currKey[idx]); @@ -1111,7 +1106,9 @@ describe("RunsReplicationService (part 2/2)", () => { for (let i = 1; i < batchFlushedEvents[0]?.payloadInserts.length; i++) { const prev = batchFlushedEvents[0]?.payloadInserts[i - 1]; const curr = batchFlushedEvents[0]?.payloadInserts[i]; - expect(prev.run_id <= curr.run_id).toBeTruthy(); + // payloadInserts are now arrays, not objects + // Index 0 is run_id + expect(prev[0] <= curr[0]).toBeTruthy(); } await runsReplicationService.stop(); diff --git a/internal-packages/clickhouse/src/client/client.ts b/internal-packages/clickhouse/src/client/client.ts index 0842665c14..b6dc294c79 100644 --- a/internal-packages/clickhouse/src/client/client.ts +++ b/internal-packages/clickhouse/src/client/client.ts @@ -645,6 +645,76 @@ export class ClickhouseClient implements ClickhouseReader, ClickhouseWriter { }; } + public insertCompact>(req: { + name: string; + table: string; + columns: readonly string[]; + toArray: (record: TRecord) => any[]; + settings?: ClickHouseSettings; + }): ClickhouseInsertFunction { + return async (events, options) => { + const queryId = randomUUID(); + + return await startSpan(this.tracer, "insert", async (span) => { + const eventsArray = Array.isArray(events) ? events : [events]; + + this.logger.debug("Inserting into clickhouse (compact)", { + clientName: this.name, + name: req.name, + table: req.table, + events: eventsArray.length, + settings: req.settings, + attributes: options?.attributes, + options, + queryId, + }); + + span.setAttributes({ + "clickhouse.clientName": this.name, + "clickhouse.tableName": req.table, + "clickhouse.operationName": req.name, + "clickhouse.queryId": queryId, + "clickhouse.format": "JSONCompactEachRowWithNames", + ...flattenAttributes(req.settings, "clickhouse.settings"), + ...flattenAttributes(options?.attributes), + }); + + // Build compact format: [columns, ...rows] + const compactData: any[] = [Array.from(req.columns)]; + for (let i = 0; i < eventsArray.length; i++) { + compactData.push(req.toArray(eventsArray[i])); + } + + const [clickhouseError, result] = await tryCatch( + this.client.insert({ + table: req.table, + format: "JSONCompactEachRowWithNames", + values: compactData, + query_id: queryId, + ...options?.params, + clickhouse_settings: { + ...req.settings, + ...options?.params?.clickhouse_settings, + }, + }) + ); + + if (clickhouseError) { + this.logger.error("Error inserting into clickhouse", { + name: req.name, + error: clickhouseError, + table: req.table, + }); + + recordSpanError(span, clickhouseError); + return [new InsertError(clickhouseError.message), null]; + } + + return [null, result]; + }); + }; + } + public insertUnsafe>(req: { name: string; table: string; @@ -654,11 +724,13 @@ export class ClickhouseClient implements ClickhouseReader, ClickhouseWriter { const queryId = randomUUID(); return await startSpan(this.tracer, "insert", async (span) => { + const eventsArray = Array.isArray(events) ? events : [events]; + this.logger.debug("Inserting into clickhouse", { clientName: this.name, name: req.name, table: req.table, - events: Array.isArray(events) ? events.length : 1, + events: eventsArray.length, settings: req.settings, attributes: options?.attributes, options, @@ -678,7 +750,7 @@ export class ClickhouseClient implements ClickhouseReader, ClickhouseWriter { this.client.insert({ table: req.table, format: "JSONEachRow", - values: Array.isArray(events) ? events : [events], + values: eventsArray, query_id: queryId, ...options?.params, clickhouse_settings: { diff --git a/internal-packages/clickhouse/src/client/noop.ts b/internal-packages/clickhouse/src/client/noop.ts index 3509297f9f..0557963b8f 100644 --- a/internal-packages/clickhouse/src/client/noop.ts +++ b/internal-packages/clickhouse/src/client/noop.ts @@ -159,4 +159,33 @@ export class NoopClient implements ClickhouseReader, ClickhouseWriter { ]; }; } + + public insertCompact>(req: { + name: string; + table: string; + columns: readonly string[]; + toArray: (record: TRecord) => any[]; + settings?: ClickHouseSettings; + }): (events: TRecord | TRecord[]) => Promise> { + return async (events: TRecord | TRecord[]) => { + return [ + null, + { + executed: true, + query_id: "noop", + summary: { + read_rows: "0", + read_bytes: "0", + written_rows: "0", + written_bytes: "0", + total_rows_to_read: "0", + result_rows: "0", + result_bytes: "0", + elapsed_ns: "0", + }, + response_headers: {}, + }, + ]; + }; + } } diff --git a/internal-packages/clickhouse/src/client/types.ts b/internal-packages/clickhouse/src/client/types.ts index 25cd2efde0..fc91668372 100644 --- a/internal-packages/clickhouse/src/client/types.ts +++ b/internal-packages/clickhouse/src/client/types.ts @@ -220,5 +220,13 @@ export interface ClickhouseWriter { settings?: ClickHouseSettings; }): ClickhouseInsertFunction; + insertCompact>(req: { + name: string; + table: string; + columns: readonly string[]; + toArray: (record: TRecord) => any[]; + settings?: ClickHouseSettings; + }): ClickhouseInsertFunction; + close(): Promise; } diff --git a/internal-packages/clickhouse/src/index.ts b/internal-packages/clickhouse/src/index.ts index 35cb7dbd0c..692c78f51f 100644 --- a/internal-packages/clickhouse/src/index.ts +++ b/internal-packages/clickhouse/src/index.ts @@ -5,8 +5,12 @@ import { NoopClient } from "./client/noop.js"; import { insertTaskRuns, insertTaskRunsUnsafe, + insertTaskRunsCompact, + insertTaskRunsCompactArrays, insertRawTaskRunPayloads, insertRawTaskRunPayloadsUnsafe, + insertRawTaskRunPayloadsCompact, + insertRawTaskRunPayloadsCompactArrays, getTaskRunsQueryBuilder, getTaskActivityQueryBuilder, getCurrentRunningStats, @@ -172,8 +176,12 @@ export class ClickHouse { return { insert: insertTaskRuns(this.writer), insertUnsafe: insertTaskRunsUnsafe(this.writer), + insertCompact: insertTaskRunsCompact(this.writer), + insertCompactArrays: insertTaskRunsCompactArrays(this.writer), insertPayloads: insertRawTaskRunPayloads(this.writer), insertPayloadsUnsafe: insertRawTaskRunPayloadsUnsafe(this.writer), + insertPayloadsCompact: insertRawTaskRunPayloadsCompact(this.writer), + insertPayloadsCompactArrays: insertRawTaskRunPayloadsCompactArrays(this.writer), queryBuilder: getTaskRunsQueryBuilder(this.reader), countQueryBuilder: getTaskRunsCountQueryBuilder(this.reader), tagQueryBuilder: getTaskRunTagsQueryBuilder(this.reader), diff --git a/internal-packages/clickhouse/src/taskRuns.ts b/internal-packages/clickhouse/src/taskRuns.ts index 267b0647e5..69813c4ace 100644 --- a/internal-packages/clickhouse/src/taskRuns.ts +++ b/internal-packages/clickhouse/src/taskRuns.ts @@ -77,6 +77,131 @@ export function insertTaskRunsUnsafe(ch: ClickhouseWriter, settings?: ClickHouse }); } +// Column order for compact format - must match ClickHouse table schema +export const TASK_RUN_COLUMNS = [ + "environment_id", + "organization_id", + "project_id", + "run_id", + "updated_at", + "created_at", + "status", + "environment_type", + "friendly_id", + "attempt", + "engine", + "task_identifier", + "queue", + "schedule_id", + "batch_id", + "completed_at", + "started_at", + "executed_at", + "delay_until", + "queued_at", + "expired_at", + "usage_duration_ms", + "cost_in_cents", + "base_cost_in_cents", + "output", + "error", + "tags", + "task_version", + "sdk_version", + "cli_version", + "machine_preset", + "root_run_id", + "parent_run_id", + "depth", + "span_id", + "trace_id", + "idempotency_key", + "expiration_ttl", + "is_test", + "concurrency_key", + "bulk_action_group_ids", + "worker_queue", + "_version", + "_is_deleted", +] as const; + +function taskRunToArray(run: TaskRunV2): any[] { + return [ + run.environment_id, + run.organization_id, + run.project_id, + run.run_id, + run.updated_at, + run.created_at, + run.status, + run.environment_type, + run.friendly_id, + run.attempt ?? 1, + run.engine, + run.task_identifier, + run.queue, + run.schedule_id, + run.batch_id, + run.completed_at ?? null, + run.started_at ?? null, + run.executed_at ?? null, + run.delay_until ?? null, + run.queued_at ?? null, + run.expired_at ?? null, + run.usage_duration_ms ?? 0, + run.cost_in_cents ?? 0, + run.base_cost_in_cents ?? 0, + run.output, + run.error, + run.tags ?? [], + run.task_version, + run.sdk_version, + run.cli_version, + run.machine_preset, + run.root_run_id, + run.parent_run_id, + run.depth ?? 0, + run.span_id, + run.trace_id, + run.idempotency_key, + run.expiration_ttl, + run.is_test ?? false, + run.concurrency_key ?? "", + run.bulk_action_group_ids ?? [], + run.worker_queue ?? "", + run._version, + run._is_deleted ?? 0, + ]; +} + +export function insertTaskRunsCompact(ch: ClickhouseWriter, settings?: ClickHouseSettings) { + return ch.insertCompact({ + name: "insertTaskRunsCompact", + table: "trigger_dev.task_runs_v2", + columns: TASK_RUN_COLUMNS as any, + toArray: taskRunToArray, + settings: { + enable_json_type: 1, + type_json_skip_duplicated_paths: 1, + ...settings, + }, + }); +} + +export function insertTaskRunsCompactArrays(ch: ClickhouseWriter, settings?: ClickHouseSettings) { + return ch.insertCompact({ + name: "insertTaskRunsCompactArrays", + table: "trigger_dev.task_runs_v2", + columns: TASK_RUN_COLUMNS as any, + toArray: (arr: any[]) => arr, // Identity function - data is already an array + settings: { + enable_json_type: 1, + type_json_skip_duplicated_paths: 1, + ...settings, + }, + }); +} + export const RawTaskRunPayloadV1 = z.object({ run_id: z.string(), created_at: z.number().int(), @@ -118,6 +243,54 @@ export function insertRawTaskRunPayloadsUnsafe(ch: ClickhouseWriter, settings?: }); } +export const PAYLOAD_COLUMNS = ["run_id", "created_at", "payload"] as const; + +function payloadToArray(payload: RawTaskRunPayloadV1): any[] { + return [payload.run_id, payload.created_at, payload.payload]; +} + +export function insertRawTaskRunPayloadsCompact( + ch: ClickhouseWriter, + settings?: ClickHouseSettings +) { + return ch.insertCompact({ + name: "insertRawTaskRunPayloadsCompact", + table: "trigger_dev.raw_task_runs_payload_v1", + columns: PAYLOAD_COLUMNS, + toArray: payloadToArray, + settings: { + async_insert: 1, + wait_for_async_insert: 0, + async_insert_max_data_size: "1000000", + async_insert_busy_timeout_ms: 1000, + enable_json_type: 1, + type_json_skip_duplicated_paths: 1, + ...settings, + }, + }); +} + +export function insertRawTaskRunPayloadsCompactArrays( + ch: ClickhouseWriter, + settings?: ClickHouseSettings +) { + return ch.insertCompact({ + name: "insertRawTaskRunPayloadsCompactArrays", + table: "trigger_dev.raw_task_runs_payload_v1", + columns: PAYLOAD_COLUMNS, + toArray: (arr: any[]) => arr, // Identity function - data is already an array + settings: { + async_insert: 1, + wait_for_async_insert: 0, + async_insert_max_data_size: "1000000", + async_insert_busy_timeout_ms: 1000, + enable_json_type: 1, + type_json_skip_duplicated_paths: 1, + ...settings, + }, + }); +} + export const TaskRunV2QueryResult = z.object({ run_id: z.string(), }); diff --git a/internal-packages/replication/src/pgoutput.ts b/internal-packages/replication/src/pgoutput.ts index 0e75a697f4..809ad87758 100644 --- a/internal-packages/replication/src/pgoutput.ts +++ b/internal-packages/replication/src/pgoutput.ts @@ -20,6 +20,18 @@ export type PgoutputMessage = | MessageType | MessageUpdate; +export type PgoutputMessageArray = + | MessageBegin + | MessageCommit + | MessageDeleteArray + | MessageInsertArray + | MessageMessage + | MessageOrigin + | MessageRelation + | MessageTruncate + | MessageType + | MessageUpdateArray; + export interface MessageBegin { tag: "begin"; commitLsn: string | null; @@ -95,6 +107,26 @@ export interface MessageUpdate { new: Record; } +// Array variants for zero-copy performance +export interface MessageInsertArray { + tag: "insert"; + relation: MessageRelation; + new: any[]; +} +export interface MessageUpdateArray { + tag: "update"; + relation: MessageRelation; + key: any[] | null; + old: any[] | null; + new: any[]; +} +export interface MessageDeleteArray { + tag: "delete"; + relation: MessageRelation; + key: any[] | null; + old: any[] | null; +} + class BinaryReader { private offset = 0; constructor(private buf: Buffer) {} @@ -193,6 +225,35 @@ export class PgoutputParser { } } + public parseArray(buf: Buffer): PgoutputMessageArray { + const reader = new BinaryReader(buf); + const tag = reader.readUint8(); + switch (tag) { + case 0x42: + return this.msgBegin(reader); + case 0x4f: + return this.msgOrigin(reader); + case 0x59: + return this.msgType(reader); + case 0x52: + return this.msgRelation(reader); + case 0x49: + return this.msgInsertArray(reader); + case 0x55: + return this.msgUpdateArray(reader); + case 0x44: + return this.msgDeleteArray(reader); + case 0x54: + return this.msgTruncate(reader); + case 0x4d: + return this.msgMessage(reader); + case 0x43: + return this.msgCommit(reader); + default: + throw Error("unknown pgoutput message"); + } + } + private msgBegin(reader: BinaryReader): MessageBegin { return { tag: "begin", @@ -312,6 +373,55 @@ export class PgoutputParser { } return { tag: "delete", relation, key, old }; } + + // Array variants - skip object creation for performance + private msgInsertArray(reader: BinaryReader): MessageInsertArray { + const relation = this._relationCache.get(reader.readInt32()); + if (!relation) throw Error("missing relation"); + reader.readUint8(); // consume the 'N' key + return { + tag: "insert", + relation, + new: this.readTupleAsArray(reader, relation), + }; + } + private msgUpdateArray(reader: BinaryReader): MessageUpdateArray { + const relation = this._relationCache.get(reader.readInt32()); + if (!relation) throw Error("missing relation"); + let key: any[] | null = null; + let old: any[] | null = null; + let new_: any[] | null = null; + const subMsgKey = reader.readUint8(); + if (subMsgKey === 0x4b) { + key = this.readTupleAsArray(reader, relation); + reader.readUint8(); + new_ = this.readTupleAsArray(reader, relation); + } else if (subMsgKey === 0x4f) { + old = this.readTupleAsArray(reader, relation); + reader.readUint8(); + new_ = this.readTupleAsArray(reader, relation, old); + } else if (subMsgKey === 0x4e) { + new_ = this.readTupleAsArray(reader, relation); + } else { + throw Error(`unknown submessage key ${String.fromCharCode(subMsgKey)}`); + } + return { tag: "update", relation, key, old, new: new_ }; + } + private msgDeleteArray(reader: BinaryReader): MessageDeleteArray { + const relation = this._relationCache.get(reader.readInt32()); + if (!relation) throw Error("missing relation"); + let key: any[] | null = null; + let old: any[] | null = null; + const subMsgKey = reader.readUint8(); + if (subMsgKey === 0x4b) { + key = this.readTupleAsArray(reader, relation); + } else if (subMsgKey === 0x4f) { + old = this.readTupleAsArray(reader, relation); + } else { + throw Error(`unknown submessage key ${String.fromCharCode(subMsgKey)}`); + } + return { tag: "delete", relation, key, old }; + } private readKeyTuple(reader: BinaryReader, relation: MessageRelation): Record { const tuple = this.readTuple(reader, relation); const key = Object.create(null); @@ -354,6 +464,40 @@ export class PgoutputParser { } return tuple; } + + private readTupleAsArray( + reader: BinaryReader, + { columns }: MessageRelation, + unchangedToastFallback?: any[] | null + ): any[] { + const nfields = reader.readInt16(); + const tuple = new Array(nfields); + for (let i = 0; i < nfields; i++) { + const { parser } = columns[i]; + const kind = reader.readUint8(); + switch (kind) { + case 0x62: // 'b' binary + const bsize = reader.readInt32(); + tuple[i] = reader.read(bsize); + break; + case 0x74: // 't' text + const valsize = reader.readInt32(); + const valbuf = reader.read(valsize); + const valtext = reader.decodeText(valbuf); + tuple[i] = parser(valtext); + break; + case 0x6e: // 'n' null + tuple[i] = null; + break; + case 0x75: // 'u' unchanged toast datum + tuple[i] = unchangedToastFallback?.[i]; + break; + default: + throw Error(`unknown attribute kind ${String.fromCharCode(kind)}`); + } + } + return tuple; + } private msgTruncate(reader: BinaryReader): MessageTruncate { const nrels = reader.readInt32(); const flags = reader.readUint8(); From 90a6034e1df32f072acea7b378dd47fb54654844 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Sat, 10 Jan 2026 12:55:45 +0000 Subject: [PATCH 05/17] added back in max duration in seconds --- apps/webapp/app/services/runsReplicationService.server.ts | 1 + internal-packages/clickhouse/src/taskRuns.ts | 6 +++++- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/apps/webapp/app/services/runsReplicationService.server.ts b/apps/webapp/app/services/runsReplicationService.server.ts index 6d9b631a0c..312550523e 100644 --- a/apps/webapp/app/services/runsReplicationService.server.ts +++ b/apps/webapp/app/services/runsReplicationService.server.ts @@ -918,6 +918,7 @@ export class RunsReplicationService { run.concurrencyKey ?? "", // concurrency_key run.bulkActionGroupIds ?? [], // bulk_action_group_ids run.masterQueue ?? "", // worker_queue + run.maxDurationInSeconds ?? 0, // max_duration_in_seconds _version.toString(), // _version event === "delete" ? 1 : 0, // _is_deleted ]; diff --git a/internal-packages/clickhouse/src/taskRuns.ts b/internal-packages/clickhouse/src/taskRuns.ts index 69813c4ace..39a64c6844 100644 --- a/internal-packages/clickhouse/src/taskRuns.ts +++ b/internal-packages/clickhouse/src/taskRuns.ts @@ -121,6 +121,7 @@ export const TASK_RUN_COLUMNS = [ "concurrency_key", "bulk_action_group_ids", "worker_queue", + "max_duration_in_seconds", "_version", "_is_deleted", ] as const; @@ -227,7 +228,10 @@ export function insertRawTaskRunPayloads(ch: ClickhouseWriter, settings?: ClickH }); } -export function insertRawTaskRunPayloadsUnsafe(ch: ClickhouseWriter, settings?: ClickHouseSettings) { +export function insertRawTaskRunPayloadsUnsafe( + ch: ClickhouseWriter, + settings?: ClickHouseSettings +) { return ch.insertUnsafe({ name: "insertRawTaskRunPayloadsUnsafe", table: "trigger_dev.raw_task_runs_payload_v1", From 05ce130f8cd8ebf428646f9ad2884cc51c09c767 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Sat, 10 Jan 2026 13:51:40 +0000 Subject: [PATCH 06/17] cleanup the types --- .../services/runsReplicationService.server.ts | 6 +- .../clickhouse/src/client/client.ts | 103 +++- .../clickhouse/src/client/noop.ts | 28 ++ .../clickhouse/src/client/types.ts | 13 + internal-packages/clickhouse/src/index.ts | 12 - internal-packages/clickhouse/src/taskRuns.ts | 161 +------ pnpm-lock.yaml | 448 +++++++++--------- 7 files changed, 362 insertions(+), 409 deletions(-) diff --git a/apps/webapp/app/services/runsReplicationService.server.ts b/apps/webapp/app/services/runsReplicationService.server.ts index 312550523e..f0a09c0788 100644 --- a/apps/webapp/app/services/runsReplicationService.server.ts +++ b/apps/webapp/app/services/runsReplicationService.server.ts @@ -1,4 +1,4 @@ -import type { ClickHouse, RawTaskRunPayloadV1, TaskRunV2 } from "@internal/clickhouse"; +import type { ClickHouse } from "@internal/clickhouse"; import { TASK_RUN_COLUMNS, PAYLOAD_COLUMNS } from "@internal/clickhouse"; import { type RedisOptions } from "@internal/redis"; import { @@ -915,12 +915,12 @@ export class RunsReplicationService { run.idempotencyKey ?? "", // idempotency_key run.ttl ?? "", // expiration_ttl run.isTest ?? false, // is_test + _version.toString(), // _version + event === "delete" ? 1 : 0, // _is_deleted run.concurrencyKey ?? "", // concurrency_key run.bulkActionGroupIds ?? [], // bulk_action_group_ids run.masterQueue ?? "", // worker_queue run.maxDurationInSeconds ?? 0, // max_duration_in_seconds - _version.toString(), // _version - event === "delete" ? 1 : 0, // _is_deleted ]; } diff --git a/internal-packages/clickhouse/src/client/client.ts b/internal-packages/clickhouse/src/client/client.ts index b6dc294c79..58e8f0df31 100644 --- a/internal-packages/clickhouse/src/client/client.ts +++ b/internal-packages/clickhouse/src/client/client.ts @@ -6,9 +6,11 @@ import { createClient, type ResultSet, type Row, + type BaseQueryParams, + type InsertResult, } from "@clickhouse/client"; import { recordSpanError, Span, startSpan, trace, Tracer } from "@internal/tracing"; -import { flattenAttributes, tryCatch } from "@trigger.dev/core/v3"; +import { flattenAttributes, tryCatch, type Result } from "@trigger.dev/core/v3"; import { z } from "zod"; import { InsertError, QueryError } from "./errors.js"; import type { @@ -797,6 +799,105 @@ export class ClickhouseClient implements ClickhouseReader, ClickhouseWriter { }); }; } + + public insertCompactRaw(req: { + name: string; + table: string; + columns: readonly string[]; + settings?: ClickHouseSettings; + }): ( + events: readonly any[][] | any[], + options?: { + attributes?: Record; + params?: BaseQueryParams; + } + ) => Promise> { + return async (events, options) => { + const queryId = randomUUID(); + + return await startSpan(this.tracer, "insert", async (span) => { + // Check if events is a single row (array) or multiple rows (array of arrays) + // If first element is not an array, treat as single row + const isSingleRow = events.length > 0 && !Array.isArray(events[0]); + const eventsArray: readonly any[][] = isSingleRow + ? [events as any[]] + : (events as readonly any[][]); + + this.logger.debug("Inserting into clickhouse (compact raw)", { + clientName: this.name, + name: req.name, + table: req.table, + events: eventsArray.length, + settings: req.settings, + attributes: options?.attributes, + options, + queryId, + }); + + span.setAttributes({ + "clickhouse.clientName": this.name, + "clickhouse.tableName": req.table, + "clickhouse.operationName": req.name, + "clickhouse.queryId": queryId, + "clickhouse.format": "JSONCompactEachRowWithNames", + ...flattenAttributes(req.settings, "clickhouse.settings"), + ...flattenAttributes(options?.attributes), + }); + + // Build compact format: [columns, ...rows] + // Data is already in array format, no conversion needed + const compactData: any[] = [Array.from(req.columns), ...eventsArray]; + + const [clickhouseError, result] = await tryCatch( + this.client.insert({ + table: req.table, + format: "JSONCompactEachRowWithNames", + values: compactData, + query_id: queryId, + ...options?.params, + clickhouse_settings: { + ...req.settings, + ...options?.params?.clickhouse_settings, + }, + }) + ); + + if (clickhouseError) { + this.logger.error("Error inserting into clickhouse", { + name: req.name, + error: clickhouseError, + table: req.table, + }); + + recordClickhouseError(span, clickhouseError); + return [new InsertError(clickhouseError.message), null]; + } + + this.logger.debug("Inserted into clickhouse", { + clientName: this.name, + name: req.name, + table: req.table, + result, + queryId, + }); + + span.setAttributes({ + "clickhouse.query_id": result.query_id, + "clickhouse.executed": result.executed, + "clickhouse.summary.read_rows": result.summary?.read_rows, + "clickhouse.summary.read_bytes": result.summary?.read_bytes, + "clickhouse.summary.written_rows": result.summary?.written_rows, + "clickhouse.summary.written_bytes": result.summary?.written_bytes, + "clickhouse.summary.total_rows_to_read": result.summary?.total_rows_to_read, + "clickhouse.summary.result_rows": result.summary?.result_rows, + "clickhouse.summary.result_bytes": result.summary?.result_bytes, + "clickhouse.summary.elapsed_ns": result.summary?.elapsed_ns, + }); + + return [null, result]; + }); + }; + } } function recordClickhouseError(span: Span, error: Error) { diff --git a/internal-packages/clickhouse/src/client/noop.ts b/internal-packages/clickhouse/src/client/noop.ts index 0557963b8f..e0872cada6 100644 --- a/internal-packages/clickhouse/src/client/noop.ts +++ b/internal-packages/clickhouse/src/client/noop.ts @@ -188,4 +188,32 @@ export class NoopClient implements ClickhouseReader, ClickhouseWriter { ]; }; } + + public insertCompactRaw(req: { + name: string; + table: string; + columns: readonly string[]; + settings?: ClickHouseSettings; + }): (events: readonly any[][] | any[]) => Promise> { + return async (events: readonly any[][] | any[]) => { + return [ + null, + { + executed: true, + query_id: "noop", + summary: { + read_rows: "0", + read_bytes: "0", + written_rows: "0", + written_bytes: "0", + total_rows_to_read: "0", + result_rows: "0", + result_bytes: "0", + elapsed_ns: "0", + }, + response_headers: {}, + }, + ]; + }; + } } diff --git a/internal-packages/clickhouse/src/client/types.ts b/internal-packages/clickhouse/src/client/types.ts index fc91668372..7120422508 100644 --- a/internal-packages/clickhouse/src/client/types.ts +++ b/internal-packages/clickhouse/src/client/types.ts @@ -228,5 +228,18 @@ export interface ClickhouseWriter { settings?: ClickHouseSettings; }): ClickhouseInsertFunction; + insertCompactRaw(req: { + name: string; + table: string; + columns: readonly string[]; + settings?: ClickHouseSettings; + }): ( + events: readonly any[][] | any[], + options?: { + attributes?: Record; + params?: BaseQueryParams; + } + ) => Promise>; + close(): Promise; } diff --git a/internal-packages/clickhouse/src/index.ts b/internal-packages/clickhouse/src/index.ts index 692c78f51f..cd498651f1 100644 --- a/internal-packages/clickhouse/src/index.ts +++ b/internal-packages/clickhouse/src/index.ts @@ -3,13 +3,7 @@ import { ClickhouseClient } from "./client/client.js"; import { ClickhouseReader, ClickhouseWriter } from "./client/types.js"; import { NoopClient } from "./client/noop.js"; import { - insertTaskRuns, - insertTaskRunsUnsafe, - insertTaskRunsCompact, insertTaskRunsCompactArrays, - insertRawTaskRunPayloads, - insertRawTaskRunPayloadsUnsafe, - insertRawTaskRunPayloadsCompact, insertRawTaskRunPayloadsCompactArrays, getTaskRunsQueryBuilder, getTaskActivityQueryBuilder, @@ -174,13 +168,7 @@ export class ClickHouse { get taskRuns() { return { - insert: insertTaskRuns(this.writer), - insertUnsafe: insertTaskRunsUnsafe(this.writer), - insertCompact: insertTaskRunsCompact(this.writer), insertCompactArrays: insertTaskRunsCompactArrays(this.writer), - insertPayloads: insertRawTaskRunPayloads(this.writer), - insertPayloadsUnsafe: insertRawTaskRunPayloadsUnsafe(this.writer), - insertPayloadsCompact: insertRawTaskRunPayloadsCompact(this.writer), insertPayloadsCompactArrays: insertRawTaskRunPayloadsCompactArrays(this.writer), queryBuilder: getTaskRunsQueryBuilder(this.reader), countQueryBuilder: getTaskRunsCountQueryBuilder(this.reader), diff --git a/internal-packages/clickhouse/src/taskRuns.ts b/internal-packages/clickhouse/src/taskRuns.ts index 39a64c6844..7f9d736150 100644 --- a/internal-packages/clickhouse/src/taskRuns.ts +++ b/internal-packages/clickhouse/src/taskRuns.ts @@ -52,31 +52,6 @@ export const TaskRunV2 = z.object({ export type TaskRunV2 = z.input; -export function insertTaskRuns(ch: ClickhouseWriter, settings?: ClickHouseSettings) { - return ch.insert({ - name: "insertTaskRuns", - table: "trigger_dev.task_runs_v2", - schema: TaskRunV2, - settings: { - enable_json_type: 1, - type_json_skip_duplicated_paths: 1, - ...settings, - }, - }); -} - -export function insertTaskRunsUnsafe(ch: ClickhouseWriter, settings?: ClickHouseSettings) { - return ch.insertUnsafe({ - name: "insertTaskRunsUnsafe", - table: "trigger_dev.task_runs_v2", - settings: { - enable_json_type: 1, - type_json_skip_duplicated_paths: 1, - ...settings, - }, - }); -} - // Column order for compact format - must match ClickHouse table schema export const TASK_RUN_COLUMNS = [ "environment_id", @@ -118,83 +93,19 @@ export const TASK_RUN_COLUMNS = [ "idempotency_key", "expiration_ttl", "is_test", + "_version", + "_is_deleted", "concurrency_key", "bulk_action_group_ids", "worker_queue", "max_duration_in_seconds", - "_version", - "_is_deleted", ] as const; -function taskRunToArray(run: TaskRunV2): any[] { - return [ - run.environment_id, - run.organization_id, - run.project_id, - run.run_id, - run.updated_at, - run.created_at, - run.status, - run.environment_type, - run.friendly_id, - run.attempt ?? 1, - run.engine, - run.task_identifier, - run.queue, - run.schedule_id, - run.batch_id, - run.completed_at ?? null, - run.started_at ?? null, - run.executed_at ?? null, - run.delay_until ?? null, - run.queued_at ?? null, - run.expired_at ?? null, - run.usage_duration_ms ?? 0, - run.cost_in_cents ?? 0, - run.base_cost_in_cents ?? 0, - run.output, - run.error, - run.tags ?? [], - run.task_version, - run.sdk_version, - run.cli_version, - run.machine_preset, - run.root_run_id, - run.parent_run_id, - run.depth ?? 0, - run.span_id, - run.trace_id, - run.idempotency_key, - run.expiration_ttl, - run.is_test ?? false, - run.concurrency_key ?? "", - run.bulk_action_group_ids ?? [], - run.worker_queue ?? "", - run._version, - run._is_deleted ?? 0, - ]; -} - -export function insertTaskRunsCompact(ch: ClickhouseWriter, settings?: ClickHouseSettings) { - return ch.insertCompact({ - name: "insertTaskRunsCompact", - table: "trigger_dev.task_runs_v2", - columns: TASK_RUN_COLUMNS as any, - toArray: taskRunToArray, - settings: { - enable_json_type: 1, - type_json_skip_duplicated_paths: 1, - ...settings, - }, - }); -} - export function insertTaskRunsCompactArrays(ch: ClickhouseWriter, settings?: ClickHouseSettings) { - return ch.insertCompact({ + return ch.insertCompactRaw({ name: "insertTaskRunsCompactArrays", table: "trigger_dev.task_runs_v2", - columns: TASK_RUN_COLUMNS as any, - toArray: (arr: any[]) => arr, // Identity function - data is already an array + columns: TASK_RUN_COLUMNS, settings: { enable_json_type: 1, type_json_skip_duplicated_paths: 1, @@ -211,78 +122,16 @@ export const RawTaskRunPayloadV1 = z.object({ export type RawTaskRunPayloadV1 = z.infer; -export function insertRawTaskRunPayloads(ch: ClickhouseWriter, settings?: ClickHouseSettings) { - return ch.insert({ - name: "insertRawTaskRunPayloads", - table: "trigger_dev.raw_task_runs_payload_v1", - schema: RawTaskRunPayloadV1, - settings: { - async_insert: 1, - wait_for_async_insert: 0, - async_insert_max_data_size: "1000000", - async_insert_busy_timeout_ms: 1000, - enable_json_type: 1, - type_json_skip_duplicated_paths: 1, - ...settings, - }, - }); -} - -export function insertRawTaskRunPayloadsUnsafe( - ch: ClickhouseWriter, - settings?: ClickHouseSettings -) { - return ch.insertUnsafe({ - name: "insertRawTaskRunPayloadsUnsafe", - table: "trigger_dev.raw_task_runs_payload_v1", - settings: { - async_insert: 1, - wait_for_async_insert: 0, - async_insert_max_data_size: "1000000", - async_insert_busy_timeout_ms: 1000, - enable_json_type: 1, - type_json_skip_duplicated_paths: 1, - ...settings, - }, - }); -} - export const PAYLOAD_COLUMNS = ["run_id", "created_at", "payload"] as const; -function payloadToArray(payload: RawTaskRunPayloadV1): any[] { - return [payload.run_id, payload.created_at, payload.payload]; -} - -export function insertRawTaskRunPayloadsCompact( - ch: ClickhouseWriter, - settings?: ClickHouseSettings -) { - return ch.insertCompact({ - name: "insertRawTaskRunPayloadsCompact", - table: "trigger_dev.raw_task_runs_payload_v1", - columns: PAYLOAD_COLUMNS, - toArray: payloadToArray, - settings: { - async_insert: 1, - wait_for_async_insert: 0, - async_insert_max_data_size: "1000000", - async_insert_busy_timeout_ms: 1000, - enable_json_type: 1, - type_json_skip_duplicated_paths: 1, - ...settings, - }, - }); -} - export function insertRawTaskRunPayloadsCompactArrays( ch: ClickhouseWriter, settings?: ClickHouseSettings ) { - return ch.insertCompact({ + return ch.insertCompactRaw({ name: "insertRawTaskRunPayloadsCompactArrays", table: "trigger_dev.raw_task_runs_payload_v1", columns: PAYLOAD_COLUMNS, - toArray: (arr: any[]) => arr, // Identity function - data is already an array settings: { async_insert: 1, wait_for_async_insert: 0, diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index aaf883a4da..7b01d2927d 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -431,31 +431,31 @@ importers: version: 3.7.1(react@18.2.0) '@remix-run/express': specifier: 2.1.0 - version: 2.1.0(express@4.20.0)(typescript@5.5.4) + version: 2.1.0(express@4.20.0)(typescript@5.9.3) '@remix-run/node': specifier: 2.1.0 - version: 2.1.0(typescript@5.5.4) + version: 2.1.0(typescript@5.9.3) '@remix-run/react': specifier: 2.1.0 - version: 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4) + version: 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3) '@remix-run/router': specifier: ^1.15.3 version: 1.15.3 '@remix-run/serve': specifier: 2.1.0 - version: 2.1.0(typescript@5.5.4) + version: 2.1.0(typescript@5.9.3) '@remix-run/server-runtime': specifier: 2.1.0 - version: 2.1.0(typescript@5.5.4) + version: 2.1.0(typescript@5.9.3) '@remix-run/v1-meta': specifier: ^0.1.3 - version: 0.1.3(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4)) + version: 0.1.3(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3)) '@s2-dev/streamstore': specifier: ^0.17.2 - version: 0.17.3(typescript@5.5.4) + version: 0.17.3(typescript@5.9.3) '@sentry/remix': specifier: 9.46.0 - version: 9.46.0(patch_hash=146126b032581925294aaed63ab53ce3f5e0356a755f1763d7a9a76b9846943b)(@remix-run/node@2.1.0(typescript@5.5.4))(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(encoding@0.1.13)(react@18.2.0) + version: 9.46.0(patch_hash=146126b032581925294aaed63ab53ce3f5e0356a755f1763d7a9a76b9846943b)(@remix-run/node@2.1.0(typescript@5.9.3))(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(encoding@0.1.13)(react@18.2.0) '@slack/web-api': specifier: 7.9.1 version: 7.9.1 @@ -524,7 +524,7 @@ importers: version: 1.0.18 class-variance-authority: specifier: ^0.5.2 - version: 0.5.2(typescript@5.5.4) + version: 0.5.2(typescript@5.9.3) clsx: specifier: ^1.2.1 version: 1.2.1 @@ -572,7 +572,7 @@ importers: version: 10.12.11(react-dom@18.2.0(react@18.2.0))(react@18.2.0) graphile-worker: specifier: 0.16.6 - version: 0.16.6(patch_hash=798129c99ed02177430fc90a1fdef800ec94e5fd1d491b931297dc52f4c98ab1)(typescript@5.5.4) + version: 0.16.6(patch_hash=798129c99ed02177430fc90a1fdef800ec94e5fd1d491b931297dc52f4c98ab1)(typescript@5.9.3) humanize-duration: specifier: ^3.27.3 version: 3.27.3 @@ -698,22 +698,22 @@ importers: version: 2.0.1 remix-auth: specifier: ^3.6.0 - version: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4)) + version: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3)) remix-auth-email-link: specifier: 2.0.2 - version: 2.0.2(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))) + version: 2.0.2(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))) remix-auth-github: specifier: ^1.6.0 - version: 1.6.0(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))) + version: 1.6.0(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))) remix-auth-google: specifier: ^2.0.0 - version: 2.0.0(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))) + version: 2.0.0(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))) remix-typedjson: specifier: 0.3.1 - version: 0.3.1(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(react@18.2.0) + version: 0.3.1(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(react@18.2.0) remix-utils: specifier: ^7.7.0 - version: 7.7.0(@remix-run/node@2.1.0(typescript@5.5.4))(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/router@1.15.3)(crypto-js@4.2.0)(intl-parse-accept-language@1.0.0)(react@18.2.0)(zod@3.25.76) + version: 7.7.0(@remix-run/node@2.1.0(typescript@5.9.3))(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/router@1.15.3)(crypto-js@4.2.0)(intl-parse-accept-language@1.0.0)(react@18.2.0)(zod@3.25.76) seedrandom: specifier: ^3.0.5 version: 3.0.5 @@ -804,13 +804,13 @@ importers: version: link:../../internal-packages/testcontainers '@remix-run/dev': specifier: 2.1.0 - version: 2.1.0(@remix-run/serve@2.1.0(typescript@5.5.4))(@types/node@22.13.9)(bufferutil@4.0.9)(encoding@0.1.13)(lightningcss@1.29.2)(terser@5.44.1)(typescript@5.5.4) + version: 2.1.0(@remix-run/serve@2.1.0(typescript@5.9.3))(@types/node@22.13.9)(bufferutil@4.0.9)(encoding@0.1.13)(lightningcss@1.29.2)(terser@5.44.1)(typescript@5.9.3) '@remix-run/eslint-config': specifier: 2.1.0 - version: 2.1.0(eslint@8.31.0)(react@18.2.0)(typescript@5.5.4) + version: 2.1.0(eslint@8.31.0)(react@18.2.0)(typescript@5.9.3) '@remix-run/testing': specifier: ^2.1.0 - version: 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4) + version: 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3) '@sentry/cli': specifier: 2.50.2 version: 2.50.2(encoding@0.1.13) @@ -909,10 +909,10 @@ importers: version: 8.5.4 '@typescript-eslint/eslint-plugin': specifier: ^5.59.6 - version: 5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint@8.31.0)(typescript@5.5.4) + version: 5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint@8.31.0)(typescript@5.9.3) '@typescript-eslint/parser': specifier: ^5.59.6 - version: 5.59.6(eslint@8.31.0)(typescript@5.5.4) + version: 5.59.6(eslint@8.31.0)(typescript@5.9.3) autoevals: specifier: ^0.0.130 version: 0.0.130(encoding@0.1.13)(ws@8.12.0(bufferutil@4.0.9)) @@ -945,7 +945,7 @@ importers: version: 8.6.0(eslint@8.31.0) eslint-plugin-import: specifier: ^2.29.1 - version: 2.29.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0) + version: 2.29.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0) eslint-plugin-react-hooks: specifier: ^4.6.2 version: 4.6.2(eslint@8.31.0) @@ -963,7 +963,7 @@ importers: version: 16.0.1(postcss@8.5.6) postcss-loader: specifier: ^8.1.1 - version: 8.1.1(postcss@8.5.6)(typescript@5.5.4)(webpack@5.102.1(@swc/core@1.3.26)(esbuild@0.15.18)) + version: 8.1.1(postcss@8.5.6)(typescript@5.9.3)(webpack@5.102.1(@swc/core@1.3.26)(esbuild@0.15.18)) prettier: specifier: ^2.8.8 version: 2.8.8 @@ -996,7 +996,7 @@ importers: version: 4.20.6 vite-tsconfig-paths: specifier: ^4.0.5 - version: 4.0.5(typescript@5.5.4) + version: 4.0.5(typescript@5.9.3) docs: {} @@ -1685,7 +1685,7 @@ importers: version: 1.36.0 '@s2-dev/streamstore': specifier: 0.17.3 - version: 0.17.3(typescript@5.5.4) + version: 0.17.3(typescript@5.9.3) dequal: specifier: ^2.0.3 version: 2.0.3 @@ -1761,7 +1761,7 @@ importers: version: 4.0.14 ai: specifier: ^3.4.33 - version: 3.4.33(openai@4.97.0(encoding@0.1.13)(ws@8.18.3(bufferutil@4.0.9))(zod@3.25.76))(react@19.1.0)(sswr@2.1.0(svelte@5.43.6))(svelte@5.43.6)(vue@3.5.24(typescript@5.5.4))(zod@3.25.76) + version: 3.4.33(openai@4.97.0(encoding@0.1.13)(ws@8.18.3(bufferutil@4.0.9))(zod@3.25.76))(react@19.1.0)(sswr@2.1.0(svelte@5.43.6))(svelte@5.43.6)(vue@3.5.24(typescript@5.9.3))(zod@3.25.76) defu: specifier: ^6.1.4 version: 6.1.4 @@ -1773,7 +1773,7 @@ importers: version: 3.0.2 ts-essentials: specifier: 10.0.1 - version: 10.0.1(typescript@5.5.4) + version: 10.0.1(typescript@5.9.3) tshy: specifier: ^3.0.2 version: 3.0.2 @@ -4041,9 +4041,6 @@ packages: '@clinic/trace-events-parser@2.0.0': resolution: {integrity: sha512-hXpT4xJED7kW0+BNCSNSFNlYZO0xMYIBbx/lM8kbyW50SemOCk7JP0wEbmYpHNiW1wKT6ICuFaOK742R/w0vTQ==} - '@codemirror/autocomplete@6.19.1': - resolution: {integrity: sha512-q6NenYkEy2fn9+JyjIxMWcNjzTL/IhwqfzOut1/G3PrIFkrbl4AL7Wkse5tLrQUUyqGoAKU5+Pi5jnnXxH5HGw==} - '@codemirror/autocomplete@6.4.0': resolution: {integrity: sha512-HLF2PnZAm1s4kGs30EiqKMgD7XsYaQ0XJnMR0rofEWQ5t5D60SfqpDIkIh1ze5tiEbyUWm8+VJ6W1/erVvBMIA==} peerDependencies: @@ -12560,9 +12557,6 @@ packages: create-hmac@1.1.7: resolution: {integrity: sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==} - crelt@1.0.5: - resolution: {integrity: sha512-+BO9wPPi+DWTDcNYhr/W90myha8ptzftZT+LwcmUbbok0rcP/fequmFYCw8NMoH7pkAZQzU78b3kYrlua5a9eA==} - crelt@1.0.6: resolution: {integrity: sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g==} @@ -13194,6 +13188,9 @@ packages: resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==} engines: {node: '>=8'} + discontinuous-range@1.0.0: + resolution: {integrity: sha512-c68LpLbO+7kP/b1Hr1qs8/BJ09F5khZGTxqxZuhzxpmwJKOgRFHJWIb9/KmqnqHhLdO55aOxFH/EGBvUQbL/RQ==} + distributions@2.2.0: resolution: {integrity: sha512-n7ybud+CRAOZlpg+ETuA0PTiSBfyVNt8Okns5gSK4NvHwj7RamQoufptOucvVcTn9CV4DZ38p1k6TgwMexUNkQ==} @@ -16771,6 +16768,10 @@ packages: ndarray@1.0.19: resolution: {integrity: sha512-B4JHA4vdyZU30ELBw3g7/p9bZupyew5a7tX1Y/gGeF2hafrPaQZhgrGQfsvgfYbgdFZjYwuEcnaobeM/WMW+HQ==} + nearley@2.20.1: + resolution: {integrity: sha512-+Mc8UaAebFzgV+KpI5n7DasuuQCHA89dmwm7JXw3TV43ukfNQ9DnBH3Mdb2g/I4Fdxc26pwimBWvjIw0UAILSQ==} + hasBin: true + negotiator@0.6.3: resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==} engines: {node: '>= 0.6'} @@ -18263,6 +18264,13 @@ packages: resolution: {integrity: sha512-kKr2uQ2AokadPjvTyKJQad9xELbZwYzWlNfI3Uz2j/ib5u6H9lDP7fUUR//rMycd0gv4Z5P1qXMfXR8YpIxrjQ==} hasBin: true + railroad-diagrams@1.0.0: + resolution: {integrity: sha512-cz93DjNeLY0idrCNOH6PviZGRN9GJhsdm9hpn1YCS879fj4W+x5IFJhhkRZcwVgMmFF7R82UA/7Oh+R8lLZg6A==} + + randexp@0.4.6: + resolution: {integrity: sha512-80WNmd9DA0tmZrw9qQa62GPPWfuXJknrmVmLcxvq4uZBdYqb1wYoKTmnlGUchvVWe0XiLupYkBoXVOxz3C8DYQ==} + engines: {node: '>=0.12'} + random-words@2.0.0: resolution: {integrity: sha512-uqpnDqFnYrZajgmvgjmBrSZL2V1UA/9bNPGrilo12CmBeBszoff/avElutUlwWxG12gvmCk/8dUhvHefYxzYjw==} @@ -20925,10 +20933,6 @@ packages: resolution: {integrity: sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==} engines: {node: '>= 0.4'} - which-typed-array@1.1.9: - resolution: {integrity: sha512-w9c4xkx6mPidwp7180ckYWfMmvxpjlZuIudNtDf4N/tTAUB8VJbX25qZoAsrtGuYNnGw3pa0AXgbGKRB8/EceA==} - engines: {node: '>= 0.4'} - which@1.3.1: resolution: {integrity: sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==} hasBin: true @@ -21451,13 +21455,13 @@ snapshots: zod: 3.25.76 zod-to-json-schema: 3.24.6(zod@3.25.76) - '@ai-sdk/vue@0.0.59(vue@3.5.24(typescript@5.5.4))(zod@3.25.76)': + '@ai-sdk/vue@0.0.59(vue@3.5.24(typescript@5.9.3))(zod@3.25.76)': dependencies: '@ai-sdk/provider-utils': 1.0.22(zod@3.25.76) '@ai-sdk/ui-utils': 0.0.50(zod@3.25.76) - swrv: 1.0.4(vue@3.5.24(typescript@5.5.4)) + swrv: 1.0.4(vue@3.5.24(typescript@5.9.3)) optionalDependencies: - vue: 3.5.24(typescript@5.5.4) + vue: 3.5.24(typescript@5.9.3) transitivePeerDependencies: - zod @@ -24087,20 +24091,6 @@ snapshots: dependencies: turbo-json-parse: 2.3.0 - '@codemirror/autocomplete@6.19.1': - dependencies: - '@codemirror/language': 6.11.3 - '@codemirror/state': 6.5.2 - '@codemirror/view': 6.38.7 - '@lezer/common': 1.3.0 - - '@codemirror/autocomplete@6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.0.2)': - dependencies: - '@codemirror/language': 6.3.2 - '@codemirror/state': 6.2.0 - '@codemirror/view': 6.7.2 - '@lezer/common': 1.0.2 - '@codemirror/autocomplete@6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.3.0)': dependencies: '@codemirror/language': 6.3.2 @@ -25669,7 +25659,7 @@ snapshots: json-parse-even-better-errors: 3.0.0 normalize-package-data: 5.0.0 proc-log: 3.0.0 - semver: 7.7.2 + semver: 7.7.3 transitivePeerDependencies: - bluebird @@ -26267,7 +26257,7 @@ snapshots: '@types/shimmer': 1.2.0 import-in-the-middle: 1.11.0 require-in-the-middle: 7.1.1(supports-color@10.0.0) - semver: 7.7.2 + semver: 7.7.3 shimmer: 1.2.1 transitivePeerDependencies: - supports-color @@ -26279,7 +26269,7 @@ snapshots: '@types/shimmer': 1.2.0 import-in-the-middle: 1.11.0 require-in-the-middle: 7.1.1(supports-color@10.0.0) - semver: 7.7.2 + semver: 7.7.3 shimmer: 1.2.1 transitivePeerDependencies: - supports-color @@ -30034,7 +30024,7 @@ snapshots: transitivePeerDependencies: - encoding - '@remix-run/dev@2.1.0(@remix-run/serve@2.1.0(typescript@5.5.4))(@types/node@22.13.9)(bufferutil@4.0.9)(encoding@0.1.13)(lightningcss@1.29.2)(terser@5.44.1)(typescript@5.5.4)': + '@remix-run/dev@2.1.0(@remix-run/serve@2.1.0(typescript@5.9.3))(@types/node@22.13.9)(bufferutil@4.0.9)(encoding@0.1.13)(lightningcss@1.29.2)(terser@5.44.1)(typescript@5.9.3)': dependencies: '@babel/core': 7.22.17 '@babel/generator': 7.24.7 @@ -30045,7 +30035,7 @@ snapshots: '@babel/traverse': 7.24.7 '@mdx-js/mdx': 2.3.0 '@npmcli/package-json': 4.0.1 - '@remix-run/server-runtime': 2.1.0(typescript@5.5.4) + '@remix-run/server-runtime': 2.1.0(typescript@5.9.3) '@types/mdx': 2.0.5 '@vanilla-extract/integration': 6.2.1(@types/node@22.13.9)(lightningcss@1.29.2)(terser@5.44.1) arg: 5.0.2 @@ -30085,8 +30075,8 @@ snapshots: tsconfig-paths: 4.2.0 ws: 7.5.9(bufferutil@4.0.9) optionalDependencies: - '@remix-run/serve': 2.1.0(typescript@5.5.4) - typescript: 5.5.4 + '@remix-run/serve': 2.1.0(typescript@5.9.3) + typescript: 5.9.3 transitivePeerDependencies: - '@types/node' - bluebird @@ -30102,43 +30092,43 @@ snapshots: - ts-node - utf-8-validate - '@remix-run/eslint-config@2.1.0(eslint@8.31.0)(react@18.2.0)(typescript@5.5.4)': + '@remix-run/eslint-config@2.1.0(eslint@8.31.0)(react@18.2.0)(typescript@5.9.3)': dependencies: '@babel/core': 7.22.17 '@babel/eslint-parser': 7.21.8(@babel/core@7.22.17)(eslint@8.31.0) '@babel/preset-react': 7.18.6(@babel/core@7.22.17) '@rushstack/eslint-patch': 1.2.0 - '@typescript-eslint/eslint-plugin': 5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint@8.31.0)(typescript@5.5.4) - '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.5.4) + '@typescript-eslint/eslint-plugin': 5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint@8.31.0)(typescript@5.9.3) + '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.9.3) eslint: 8.31.0 eslint-import-resolver-node: 0.3.7 - eslint-import-resolver-typescript: 3.5.5(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-node@0.3.7)(eslint-plugin-import@2.29.1)(eslint@8.31.0) - eslint-plugin-import: 2.29.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0) - eslint-plugin-jest: 26.9.0(@typescript-eslint/eslint-plugin@5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint@8.31.0)(typescript@5.5.4))(eslint@8.31.0)(typescript@5.5.4) + eslint-import-resolver-typescript: 3.5.5(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-node@0.3.7)(eslint-plugin-import@2.29.1)(eslint@8.31.0) + eslint-plugin-import: 2.29.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0) + eslint-plugin-jest: 26.9.0(@typescript-eslint/eslint-plugin@5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint@8.31.0)(typescript@5.9.3))(eslint@8.31.0)(typescript@5.9.3) eslint-plugin-jest-dom: 4.0.3(eslint@8.31.0) eslint-plugin-jsx-a11y: 6.7.1(eslint@8.31.0) eslint-plugin-node: 11.1.0(eslint@8.31.0) eslint-plugin-react: 7.32.2(eslint@8.31.0) eslint-plugin-react-hooks: 4.6.2(eslint@8.31.0) - eslint-plugin-testing-library: 5.11.0(eslint@8.31.0)(typescript@5.5.4) + eslint-plugin-testing-library: 5.11.0(eslint@8.31.0)(typescript@5.9.3) react: 18.2.0 optionalDependencies: - typescript: 5.5.4 + typescript: 5.9.3 transitivePeerDependencies: - eslint-import-resolver-webpack - jest - supports-color - '@remix-run/express@2.1.0(express@4.20.0)(typescript@5.5.4)': + '@remix-run/express@2.1.0(express@4.20.0)(typescript@5.9.3)': dependencies: - '@remix-run/node': 2.1.0(typescript@5.5.4) + '@remix-run/node': 2.1.0(typescript@5.9.3) express: 4.20.0 optionalDependencies: - typescript: 5.5.4 + typescript: 5.9.3 - '@remix-run/node@2.1.0(typescript@5.5.4)': + '@remix-run/node@2.1.0(typescript@5.9.3)': dependencies: - '@remix-run/server-runtime': 2.1.0(typescript@5.5.4) + '@remix-run/server-runtime': 2.1.0(typescript@5.9.3) '@remix-run/web-fetch': 4.4.1 '@remix-run/web-file': 3.1.0 '@remix-run/web-stream': 1.1.0 @@ -30147,26 +30137,26 @@ snapshots: source-map-support: 0.5.21 stream-slice: 0.1.2 optionalDependencies: - typescript: 5.5.4 + typescript: 5.9.3 - '@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4)': + '@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3)': dependencies: '@remix-run/router': 1.10.0 - '@remix-run/server-runtime': 2.1.0(typescript@5.5.4) + '@remix-run/server-runtime': 2.1.0(typescript@5.9.3) react: 18.2.0 react-dom: 18.2.0(react@18.2.0) react-router-dom: 6.17.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0) optionalDependencies: - typescript: 5.5.4 + typescript: 5.9.3 '@remix-run/router@1.10.0': {} '@remix-run/router@1.15.3': {} - '@remix-run/serve@2.1.0(typescript@5.5.4)': + '@remix-run/serve@2.1.0(typescript@5.9.3)': dependencies: - '@remix-run/express': 2.1.0(express@4.20.0)(typescript@5.5.4) - '@remix-run/node': 2.1.0(typescript@5.5.4) + '@remix-run/express': 2.1.0(express@4.20.0)(typescript@5.9.3) + '@remix-run/node': 2.1.0(typescript@5.9.3) chokidar: 3.6.0 compression: 1.7.4 express: 4.20.0 @@ -30177,7 +30167,7 @@ snapshots: - supports-color - typescript - '@remix-run/server-runtime@2.1.0(typescript@5.5.4)': + '@remix-run/server-runtime@2.1.0(typescript@5.9.3)': dependencies: '@remix-run/router': 1.10.0 '@types/cookie': 0.4.1 @@ -30186,24 +30176,24 @@ snapshots: set-cookie-parser: 2.6.0 source-map: 0.7.4 optionalDependencies: - typescript: 5.5.4 + typescript: 5.9.3 - '@remix-run/testing@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4)': + '@remix-run/testing@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3)': dependencies: - '@remix-run/node': 2.1.0(typescript@5.5.4) - '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4) + '@remix-run/node': 2.1.0(typescript@5.9.3) + '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3) '@remix-run/router': 1.10.0 react: 18.2.0 react-router-dom: 6.17.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0) optionalDependencies: - typescript: 5.5.4 + typescript: 5.9.3 transitivePeerDependencies: - react-dom - '@remix-run/v1-meta@0.1.3(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))': + '@remix-run/v1-meta@0.1.3(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))': dependencies: - '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4) - '@remix-run/server-runtime': 2.1.0(typescript@5.5.4) + '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3) + '@remix-run/server-runtime': 2.1.0(typescript@5.9.3) '@remix-run/web-blob@3.1.0': dependencies: @@ -30298,10 +30288,10 @@ snapshots: '@rushstack/eslint-patch@1.2.0': {} - '@s2-dev/streamstore@0.17.3(typescript@5.5.4)': + '@s2-dev/streamstore@0.17.3(typescript@5.9.3)': dependencies: '@protobuf-ts/runtime': 2.11.1 - typescript: 5.5.4 + typescript: 5.9.3 '@s2-dev/streamstore@0.17.6': dependencies: @@ -30455,15 +30445,15 @@ snapshots: hoist-non-react-statics: 3.3.2 react: 18.2.0 - '@sentry/remix@9.46.0(patch_hash=146126b032581925294aaed63ab53ce3f5e0356a755f1763d7a9a76b9846943b)(@remix-run/node@2.1.0(typescript@5.5.4))(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(encoding@0.1.13)(react@18.2.0)': + '@sentry/remix@9.46.0(patch_hash=146126b032581925294aaed63ab53ce3f5e0356a755f1763d7a9a76b9846943b)(@remix-run/node@2.1.0(typescript@5.9.3))(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(encoding@0.1.13)(react@18.2.0)': dependencies: '@opentelemetry/api': 1.9.0 '@opentelemetry/instrumentation': 0.57.2(@opentelemetry/api@1.9.0) '@opentelemetry/semantic-conventions': 1.36.0 - '@remix-run/node': 2.1.0(typescript@5.5.4) - '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4) + '@remix-run/node': 2.1.0(typescript@5.9.3) + '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3) '@remix-run/router': 1.15.3 - '@remix-run/server-runtime': 2.1.0(typescript@5.5.4) + '@remix-run/server-runtime': 2.1.0(typescript@5.9.3) '@sentry/cli': 2.50.2(encoding@0.1.13) '@sentry/core': 9.46.0 '@sentry/node': 9.46.0 @@ -32382,34 +32372,34 @@ snapshots: '@types/node': 20.14.14 optional: true - '@typescript-eslint/eslint-plugin@5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint@8.31.0)(typescript@5.5.4)': + '@typescript-eslint/eslint-plugin@5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint@8.31.0)(typescript@5.9.3)': dependencies: '@eslint-community/regexpp': 4.5.1 - '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.5.4) + '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.9.3) '@typescript-eslint/scope-manager': 5.59.6 - '@typescript-eslint/type-utils': 5.59.6(eslint@8.31.0)(typescript@5.5.4) - '@typescript-eslint/utils': 5.59.6(eslint@8.31.0)(typescript@5.5.4) + '@typescript-eslint/type-utils': 5.59.6(eslint@8.31.0)(typescript@5.9.3) + '@typescript-eslint/utils': 5.59.6(eslint@8.31.0)(typescript@5.9.3) debug: 4.3.4 eslint: 8.31.0 grapheme-splitter: 1.0.4 ignore: 5.2.4 natural-compare-lite: 1.4.0 semver: 7.6.3 - tsutils: 3.21.0(typescript@5.5.4) + tsutils: 3.21.0(typescript@5.9.3) optionalDependencies: - typescript: 5.5.4 + typescript: 5.9.3 transitivePeerDependencies: - supports-color - '@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4)': + '@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3)': dependencies: '@typescript-eslint/scope-manager': 5.59.6 '@typescript-eslint/types': 5.59.6 - '@typescript-eslint/typescript-estree': 5.59.6(typescript@5.5.4) + '@typescript-eslint/typescript-estree': 5.59.6(typescript@5.9.3) debug: 4.4.0 eslint: 8.31.0 optionalDependencies: - typescript: 5.5.4 + typescript: 5.9.3 transitivePeerDependencies: - supports-color @@ -32418,45 +32408,45 @@ snapshots: '@typescript-eslint/types': 5.59.6 '@typescript-eslint/visitor-keys': 5.59.6 - '@typescript-eslint/type-utils@5.59.6(eslint@8.31.0)(typescript@5.5.4)': + '@typescript-eslint/type-utils@5.59.6(eslint@8.31.0)(typescript@5.9.3)': dependencies: - '@typescript-eslint/typescript-estree': 5.59.6(typescript@5.5.4) - '@typescript-eslint/utils': 5.59.6(eslint@8.31.0)(typescript@5.5.4) + '@typescript-eslint/typescript-estree': 5.59.6(typescript@5.9.3) + '@typescript-eslint/utils': 5.59.6(eslint@8.31.0)(typescript@5.9.3) debug: 4.4.1(supports-color@10.0.0) eslint: 8.31.0 - tsutils: 3.21.0(typescript@5.5.4) + tsutils: 3.21.0(typescript@5.9.3) optionalDependencies: - typescript: 5.5.4 + typescript: 5.9.3 transitivePeerDependencies: - supports-color '@typescript-eslint/types@5.59.6': {} - '@typescript-eslint/typescript-estree@5.59.6(typescript@5.5.4)': + '@typescript-eslint/typescript-estree@5.59.6(typescript@5.9.3)': dependencies: '@typescript-eslint/types': 5.59.6 '@typescript-eslint/visitor-keys': 5.59.6 debug: 4.4.1(supports-color@10.0.0) globby: 11.1.0 is-glob: 4.0.3 - semver: 7.7.2 - tsutils: 3.21.0(typescript@5.5.4) + semver: 7.7.3 + tsutils: 3.21.0(typescript@5.9.3) optionalDependencies: - typescript: 5.5.4 + typescript: 5.9.3 transitivePeerDependencies: - supports-color - '@typescript-eslint/utils@5.59.6(eslint@8.31.0)(typescript@5.5.4)': + '@typescript-eslint/utils@5.59.6(eslint@8.31.0)(typescript@5.9.3)': dependencies: '@eslint-community/eslint-utils': 4.4.0(eslint@8.31.0) '@types/json-schema': 7.0.13 '@types/semver': 7.5.1 '@typescript-eslint/scope-manager': 5.59.6 '@typescript-eslint/types': 5.59.6 - '@typescript-eslint/typescript-estree': 5.59.6(typescript@5.5.4) + '@typescript-eslint/typescript-estree': 5.59.6(typescript@5.9.3) eslint: 8.31.0 eslint-scope: 5.1.1 - semver: 7.7.2 + semver: 7.7.3 transitivePeerDependencies: - supports-color - typescript @@ -32720,11 +32710,11 @@ snapshots: '@vue/shared': 3.5.24 csstype: 3.2.0 - '@vue/server-renderer@3.5.24(vue@3.5.24(typescript@5.5.4))': + '@vue/server-renderer@3.5.24(vue@3.5.24(typescript@5.9.3))': dependencies: '@vue/compiler-ssr': 3.5.24 '@vue/shared': 3.5.24 - vue: 3.5.24(typescript@5.5.4) + vue: 3.5.24(typescript@5.9.3) '@vue/shared@3.5.24': {} @@ -32952,17 +32942,17 @@ snapshots: mime-types: 3.0.0 negotiator: 1.0.0 - acorn-import-assertions@1.9.0(acorn@8.14.1): + acorn-import-assertions@1.9.0(acorn@8.15.0): dependencies: - acorn: 8.14.1 + acorn: 8.15.0 acorn-import-attributes@1.9.5(acorn@8.12.1): dependencies: acorn: 8.12.1 - acorn-import-attributes@1.9.5(acorn@8.14.1): + acorn-import-attributes@1.9.5(acorn@8.15.0): dependencies: - acorn: 8.14.1 + acorn: 8.15.0 acorn-import-phases@1.0.4(acorn@8.15.0): dependencies: @@ -32972,9 +32962,9 @@ snapshots: dependencies: acorn: 8.12.1 - acorn-jsx@5.3.2(acorn@8.14.1): + acorn-jsx@5.3.2(acorn@8.15.0): dependencies: - acorn: 8.14.1 + acorn: 8.15.0 acorn-node@1.8.2: dependencies: @@ -33018,7 +33008,7 @@ snapshots: ahocorasick@1.0.2: {} - ai@3.4.33(openai@4.97.0(encoding@0.1.13)(ws@8.18.3(bufferutil@4.0.9))(zod@3.25.76))(react@19.1.0)(sswr@2.1.0(svelte@5.43.6))(svelte@5.43.6)(vue@3.5.24(typescript@5.5.4))(zod@3.25.76): + ai@3.4.33(openai@4.97.0(encoding@0.1.13)(ws@8.18.3(bufferutil@4.0.9))(zod@3.25.76))(react@19.1.0)(sswr@2.1.0(svelte@5.43.6))(svelte@5.43.6)(vue@3.5.24(typescript@5.9.3))(zod@3.25.76): dependencies: '@ai-sdk/provider': 0.0.26 '@ai-sdk/provider-utils': 1.0.22(zod@3.25.76) @@ -33026,7 +33016,7 @@ snapshots: '@ai-sdk/solid': 0.0.54(zod@3.25.76) '@ai-sdk/svelte': 0.0.57(svelte@5.43.6)(zod@3.25.76) '@ai-sdk/ui-utils': 0.0.50(zod@3.25.76) - '@ai-sdk/vue': 0.0.59(vue@3.5.24(typescript@5.5.4))(zod@3.25.76) + '@ai-sdk/vue': 0.0.59(vue@3.5.24(typescript@5.9.3))(zod@3.25.76) '@opentelemetry/api': 1.9.0 eventsource-parser: 1.1.2 json-schema: 0.4.0 @@ -34093,9 +34083,9 @@ snapshots: cjs-module-lexer@1.2.3: {} - class-variance-authority@0.5.2(typescript@5.5.4): + class-variance-authority@0.5.2(typescript@5.9.3): optionalDependencies: - typescript: 5.5.4 + typescript: 5.9.3 class-variance-authority@0.7.0: dependencies: @@ -34218,8 +34208,6 @@ snapshots: code-point-at@1.1.0: {} - code-point-at@1.1.0: {} - codemirror@6.0.2(@lezer/common@1.3.0): dependencies: '@codemirror/autocomplete': 6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.3.0) @@ -34449,15 +34437,6 @@ snapshots: dependencies: layout-base: 2.0.1 - cosmiconfig@8.3.6(typescript@5.5.4): - dependencies: - import-fresh: 3.3.0 - js-yaml: 4.1.1 - parse-json: 5.2.0 - path-type: 4.0.0 - optionalDependencies: - typescript: 5.5.4 - cosmiconfig@8.3.6(typescript@5.9.3): dependencies: import-fresh: 3.3.0 @@ -34467,14 +34446,14 @@ snapshots: optionalDependencies: typescript: 5.9.3 - cosmiconfig@9.0.0(typescript@5.5.4): + cosmiconfig@9.0.0(typescript@5.9.3): dependencies: env-paths: 2.2.1 import-fresh: 3.3.0 js-yaml: 4.1.1 parse-json: 5.2.0 optionalDependencies: - typescript: 5.5.4 + typescript: 5.9.3 cp-file@10.0.0: dependencies: @@ -34533,8 +34512,6 @@ snapshots: safe-buffer: 5.2.1 sha.js: 2.4.12 - crelt@1.0.5: {} - crelt@1.0.6: {} cron-parser@4.9.0: @@ -35156,6 +35133,8 @@ snapshots: dependencies: path-type: 4.0.0 + discontinuous-range@1.0.0: {} + distributions@2.2.0: dependencies: cephes: 2.0.0 @@ -35916,13 +35895,13 @@ snapshots: transitivePeerDependencies: - supports-color - eslint-import-resolver-typescript@3.5.5(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-node@0.3.7)(eslint-plugin-import@2.29.1)(eslint@8.31.0): + eslint-import-resolver-typescript@3.5.5(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-node@0.3.7)(eslint-plugin-import@2.29.1)(eslint@8.31.0): dependencies: debug: 4.4.1(supports-color@10.0.0) enhanced-resolve: 5.15.0 eslint: 8.31.0 - eslint-module-utils: 2.7.4(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-node@0.3.7)(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0) - eslint-plugin-import: 2.29.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0) + eslint-module-utils: 2.7.4(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-node@0.3.7)(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0) + eslint-plugin-import: 2.29.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0) get-tsconfig: 4.7.2 globby: 13.2.2 is-core-module: 2.14.0 @@ -35934,25 +35913,25 @@ snapshots: - eslint-import-resolver-webpack - supports-color - eslint-module-utils@2.7.4(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-node@0.3.7)(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0): + eslint-module-utils@2.7.4(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-node@0.3.7)(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0): dependencies: debug: 3.2.7 optionalDependencies: - '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.5.4) + '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.9.3) eslint: 8.31.0 eslint-import-resolver-node: 0.3.7 - eslint-import-resolver-typescript: 3.5.5(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-node@0.3.7)(eslint-plugin-import@2.29.1)(eslint@8.31.0) + eslint-import-resolver-typescript: 3.5.5(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-node@0.3.7)(eslint-plugin-import@2.29.1)(eslint@8.31.0) transitivePeerDependencies: - supports-color - eslint-module-utils@2.8.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0): + eslint-module-utils@2.8.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0): dependencies: debug: 3.2.7 optionalDependencies: - '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.5.4) + '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.9.3) eslint: 8.31.0 eslint-import-resolver-node: 0.3.9 - eslint-import-resolver-typescript: 3.5.5(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-node@0.3.7)(eslint-plugin-import@2.29.1)(eslint@8.31.0) + eslint-import-resolver-typescript: 3.5.5(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-node@0.3.7)(eslint-plugin-import@2.29.1)(eslint@8.31.0) transitivePeerDependencies: - supports-color @@ -35962,7 +35941,7 @@ snapshots: eslint-utils: 2.1.0 regexpp: 3.2.0 - eslint-plugin-import@2.29.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0): + eslint-plugin-import@2.29.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0): dependencies: array-includes: 3.1.8 array.prototype.findlastindex: 1.2.5 @@ -35972,7 +35951,7 @@ snapshots: doctrine: 2.1.0 eslint: 8.31.0 eslint-import-resolver-node: 0.3.9 - eslint-module-utils: 2.8.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0) + eslint-module-utils: 2.8.1(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.5.5)(eslint@8.31.0) hasown: 2.0.2 is-core-module: 2.14.0 is-glob: 4.0.3 @@ -35983,7 +35962,7 @@ snapshots: semver: 6.3.1 tsconfig-paths: 3.15.0 optionalDependencies: - '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.5.4) + '@typescript-eslint/parser': 5.59.6(eslint@8.31.0)(typescript@5.9.3) transitivePeerDependencies: - eslint-import-resolver-typescript - eslint-import-resolver-webpack @@ -35996,12 +35975,12 @@ snapshots: eslint: 8.31.0 requireindex: 1.2.0 - eslint-plugin-jest@26.9.0(@typescript-eslint/eslint-plugin@5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint@8.31.0)(typescript@5.5.4))(eslint@8.31.0)(typescript@5.5.4): + eslint-plugin-jest@26.9.0(@typescript-eslint/eslint-plugin@5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint@8.31.0)(typescript@5.9.3))(eslint@8.31.0)(typescript@5.9.3): dependencies: - '@typescript-eslint/utils': 5.59.6(eslint@8.31.0)(typescript@5.5.4) + '@typescript-eslint/utils': 5.59.6(eslint@8.31.0)(typescript@5.9.3) eslint: 8.31.0 optionalDependencies: - '@typescript-eslint/eslint-plugin': 5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.5.4))(eslint@8.31.0)(typescript@5.5.4) + '@typescript-eslint/eslint-plugin': 5.59.6(@typescript-eslint/parser@5.59.6(eslint@8.31.0)(typescript@5.9.3))(eslint@8.31.0)(typescript@5.9.3) transitivePeerDependencies: - supports-color - typescript @@ -36059,9 +36038,9 @@ snapshots: semver: 6.3.1 string.prototype.matchall: 4.0.8 - eslint-plugin-testing-library@5.11.0(eslint@8.31.0)(typescript@5.5.4): + eslint-plugin-testing-library@5.11.0(eslint@8.31.0)(typescript@5.9.3): dependencies: - '@typescript-eslint/utils': 5.59.6(eslint@8.31.0)(typescript@5.5.4) + '@typescript-eslint/utils': 5.59.6(eslint@8.31.0)(typescript@5.9.3) eslint: 8.31.0 transitivePeerDependencies: - supports-color @@ -36165,8 +36144,8 @@ snapshots: espree@9.6.0: dependencies: - acorn: 8.14.1 - acorn-jsx: 5.3.2(acorn@8.14.1) + acorn: 8.15.0 + acorn-jsx: 5.3.2(acorn@8.15.0) eslint-visitor-keys: 3.4.2 esprima@4.0.1: {} @@ -36531,7 +36510,7 @@ snapshots: process-warning: 5.0.0 rfdc: 1.4.1 secure-json-parse: 4.0.0 - semver: 7.7.2 + semver: 7.7.3 toad-cache: 3.7.0 fastq@1.15.0: @@ -37071,28 +37050,12 @@ snapshots: chalk: 4.1.2 debug: 4.4.1(supports-color@10.0.0) interpret: 3.1.1 - semver: 7.7.2 + semver: 7.7.3 tslib: 2.8.1 yargs: 17.7.2 transitivePeerDependencies: - supports-color - graphile-worker@0.16.6(patch_hash=798129c99ed02177430fc90a1fdef800ec94e5fd1d491b931297dc52f4c98ab1)(typescript@5.5.4): - dependencies: - '@graphile/logger': 0.2.0 - '@types/debug': 4.1.12 - '@types/pg': 8.11.6 - cosmiconfig: 8.3.6(typescript@5.5.4) - graphile-config: 0.0.1-beta.8 - json5: 2.2.3 - pg: 8.11.5 - tslib: 2.6.2 - yargs: 17.7.2 - transitivePeerDependencies: - - pg-native - - supports-color - - typescript - graphile-worker@0.16.6(patch_hash=798129c99ed02177430fc90a1fdef800ec94e5fd1d491b931297dc52f4c98ab1)(typescript@5.9.3): dependencies: '@graphile/logger': 0.2.0 @@ -37507,8 +37470,8 @@ snapshots: import-in-the-middle@1.14.2: dependencies: - acorn: 8.14.1 - acorn-import-attributes: 1.9.5(acorn@8.14.1) + acorn: 8.15.0 + acorn-import-attributes: 1.9.5(acorn@8.15.0) cjs-module-lexer: 1.2.3 module-details-from-path: 1.0.3 @@ -37701,8 +37664,6 @@ snapshots: is-buffer@1.1.6: {} - is-buffer@1.1.6: {} - is-buffer@2.0.5: {} is-callable@1.2.7: {} @@ -39041,8 +39002,8 @@ snapshots: micromark-extension-mdxjs@1.0.0: dependencies: - acorn: 8.14.1 - acorn-jsx: 5.3.2(acorn@8.14.1) + acorn: 8.15.0 + acorn-jsx: 5.3.2(acorn@8.15.0) micromark-extension-mdx-expression: 1.0.3 micromark-extension-mdx-jsx: 1.0.3 micromark-extension-mdx-md: 1.0.0 @@ -39670,6 +39631,13 @@ snapshots: iota-array: 1.0.0 is-buffer: 1.1.6 + nearley@2.20.1: + dependencies: + commander: 2.20.3 + moo: 0.5.2 + railroad-diagrams: 1.0.0 + randexp: 0.4.6 + negotiator@0.6.3: {} negotiator@1.0.0: {} @@ -40761,9 +40729,9 @@ snapshots: tsx: 4.17.0 yaml: 2.7.1 - postcss-loader@8.1.1(postcss@8.5.6)(typescript@5.5.4)(webpack@5.102.1(@swc/core@1.3.26)(esbuild@0.15.18)): + postcss-loader@8.1.1(postcss@8.5.6)(typescript@5.9.3)(webpack@5.102.1(@swc/core@1.3.26)(esbuild@0.15.18)): dependencies: - cosmiconfig: 9.0.0(typescript@5.5.4) + cosmiconfig: 9.0.0(typescript@5.9.3) jiti: 1.21.0 postcss: 8.5.6 semver: 7.6.3 @@ -41264,6 +41232,13 @@ snapshots: minimist: 1.2.7 through2: 2.0.5 + railroad-diagrams@1.0.0: {} + + randexp@0.4.6: + dependencies: + discontinuous-range: 1.0.0 + ret: 0.1.15 + random-words@2.0.0: dependencies: seedrandom: 3.0.5 @@ -41987,54 +41962,54 @@ snapshots: mdast-util-to-markdown: 2.1.2 unified: 11.0.5 - remix-auth-email-link@2.0.2(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))): + remix-auth-email-link@2.0.2(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))): dependencies: - '@remix-run/server-runtime': 2.1.0(typescript@5.5.4) + '@remix-run/server-runtime': 2.1.0(typescript@5.9.3) crypto-js: 4.1.1 - remix-auth: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4)) + remix-auth: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3)) - remix-auth-github@1.6.0(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))): + remix-auth-github@1.6.0(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))): dependencies: - '@remix-run/server-runtime': 2.1.0(typescript@5.5.4) - remix-auth: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4)) - remix-auth-oauth2: 1.11.0(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))) + '@remix-run/server-runtime': 2.1.0(typescript@5.9.3) + remix-auth: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3)) + remix-auth-oauth2: 1.11.0(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))) transitivePeerDependencies: - supports-color - remix-auth-google@2.0.0(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))): + remix-auth-google@2.0.0(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))): dependencies: - '@remix-run/server-runtime': 2.1.0(typescript@5.5.4) - remix-auth: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4)) - remix-auth-oauth2: 1.11.0(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))) + '@remix-run/server-runtime': 2.1.0(typescript@5.9.3) + remix-auth: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3)) + remix-auth-oauth2: 1.11.0(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))) transitivePeerDependencies: - supports-color - remix-auth-oauth2@1.11.0(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))): + remix-auth-oauth2@1.11.0(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))): dependencies: - '@remix-run/server-runtime': 2.1.0(typescript@5.5.4) + '@remix-run/server-runtime': 2.1.0(typescript@5.9.3) debug: 4.4.1(supports-color@10.0.0) - remix-auth: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4)) + remix-auth: 3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3)) transitivePeerDependencies: - supports-color - remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4)): + remix-auth@3.6.0(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3)): dependencies: - '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4) - '@remix-run/server-runtime': 2.1.0(typescript@5.5.4) + '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3) + '@remix-run/server-runtime': 2.1.0(typescript@5.9.3) uuid: 8.3.2 - remix-typedjson@0.3.1(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/server-runtime@2.1.0(typescript@5.5.4))(react@18.2.0): + remix-typedjson@0.3.1(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/server-runtime@2.1.0(typescript@5.9.3))(react@18.2.0): dependencies: - '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4) - '@remix-run/server-runtime': 2.1.0(typescript@5.5.4) + '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3) + '@remix-run/server-runtime': 2.1.0(typescript@5.9.3) react: 18.2.0 - remix-utils@7.7.0(@remix-run/node@2.1.0(typescript@5.5.4))(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4))(@remix-run/router@1.15.3)(crypto-js@4.2.0)(intl-parse-accept-language@1.0.0)(react@18.2.0)(zod@3.25.76): + remix-utils@7.7.0(@remix-run/node@2.1.0(typescript@5.9.3))(@remix-run/react@2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3))(@remix-run/router@1.15.3)(crypto-js@4.2.0)(intl-parse-accept-language@1.0.0)(react@18.2.0)(zod@3.25.76): dependencies: type-fest: 4.33.0 optionalDependencies: - '@remix-run/node': 2.1.0(typescript@5.5.4) - '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.5.4) + '@remix-run/node': 2.1.0(typescript@5.9.3) + '@remix-run/react': 2.1.0(react-dom@18.2.0(react@18.2.0))(react@18.2.0)(typescript@5.9.3) '@remix-run/router': 1.15.3 crypto-js: 4.2.0 intl-parse-accept-language: 1.0.0 @@ -43294,9 +43269,9 @@ snapshots: swrev@4.0.0: {} - swrv@1.0.4(vue@3.5.24(typescript@5.5.4)): + swrv@1.0.4(vue@3.5.24(typescript@5.9.3)): dependencies: - vue: 3.5.24(typescript@5.5.4) + vue: 3.5.24(typescript@5.9.3) sync-content@2.0.1: dependencies: @@ -43779,10 +43754,6 @@ snapshots: ts-easing@0.2.0: {} - ts-essentials@10.0.1(typescript@5.5.4): - optionalDependencies: - typescript: 5.5.4 - ts-essentials@10.0.1(typescript@5.9.3): optionalDependencies: typescript: 5.9.3 @@ -43813,6 +43784,10 @@ snapshots: optionalDependencies: typescript: 5.5.4 + tsconfck@2.1.2(typescript@5.9.3): + optionalDependencies: + typescript: 5.9.3 + tsconfck@3.1.3(typescript@5.9.3): optionalDependencies: typescript: 5.9.3 @@ -43889,10 +43864,10 @@ snapshots: - tsx - yaml - tsutils@3.21.0(typescript@5.5.4): + tsutils@3.21.0(typescript@5.9.3): dependencies: tslib: 1.14.1 - typescript: 5.5.4 + typescript: 5.9.3 tsx@3.12.2: dependencies: @@ -44090,8 +44065,7 @@ snapshots: typescript@5.5.4: {} - typescript@5.9.3: - optional: true + typescript@5.9.3: {} ufo@1.5.4: {} @@ -44551,6 +44525,15 @@ snapshots: - supports-color - typescript + vite-tsconfig-paths@4.0.5(typescript@5.9.3): + dependencies: + debug: 4.3.7(supports-color@10.0.0) + globrex: 0.1.2 + tsconfck: 2.1.2(typescript@5.9.3) + transitivePeerDependencies: + - supports-color + - typescript + vite@4.4.9(@types/node@22.13.9)(lightningcss@1.29.2)(terser@5.44.1): dependencies: esbuild: 0.18.11 @@ -44629,15 +44612,15 @@ snapshots: vscode-uri@3.0.8: {} - vue@3.5.24(typescript@5.5.4): + vue@3.5.24(typescript@5.9.3): dependencies: '@vue/compiler-dom': 3.5.24 '@vue/compiler-sfc': 3.5.24 '@vue/runtime-dom': 3.5.24 - '@vue/server-renderer': 3.5.24(vue@3.5.24(typescript@5.5.4)) + '@vue/server-renderer': 3.5.24(vue@3.5.24(typescript@5.9.3)) '@vue/shared': 3.5.24 optionalDependencies: - typescript: 5.5.4 + typescript: 5.9.3 w3c-keyname@2.2.8: {} @@ -44682,7 +44665,7 @@ snapshots: webpack-bundle-analyzer@4.10.1(bufferutil@4.0.9): dependencies: '@discoveryjs/json-ext': 0.5.7 - acorn: 8.14.1 + acorn: 8.15.0 acorn-walk: 8.3.2 commander: 7.2.0 debounce: 1.2.1 @@ -44741,8 +44724,8 @@ snapshots: '@webassemblyjs/ast': 1.11.5 '@webassemblyjs/wasm-edit': 1.11.5 '@webassemblyjs/wasm-parser': 1.11.5 - acorn: 8.14.1 - acorn-import-assertions: 1.9.0(acorn@8.14.1) + acorn: 8.15.0 + acorn-import-assertions: 1.9.0(acorn@8.15.0) browserslist: 4.24.4 chrome-trace-event: 1.0.3 enhanced-resolve: 5.18.3 @@ -44809,15 +44792,6 @@ snapshots: gopd: 1.2.0 has-tostringtag: 1.0.2 - which-typed-array@1.1.9: - dependencies: - available-typed-arrays: 1.0.5 - call-bind: 1.0.7 - for-each: 0.3.3 - gopd: 1.2.0 - has-tostringtag: 1.0.0 - is-typed-array: 1.1.10 - which@1.3.1: dependencies: isexe: 2.0.0 From ff1aa00193dea8f8eb7e365ba9149769412c0637 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Sat, 10 Jan 2026 19:00:32 +0000 Subject: [PATCH 07/17] simplify --- .../services/runsReplicationService.server.ts | 39 ++++++------------- .../clickhouse/src/client/client.ts | 12 ++---- 2 files changed, 14 insertions(+), 37 deletions(-) diff --git a/apps/webapp/app/services/runsReplicationService.server.ts b/apps/webapp/app/services/runsReplicationService.server.ts index f0a09c0788..af78b73f23 100644 --- a/apps/webapp/app/services/runsReplicationService.server.ts +++ b/apps/webapp/app/services/runsReplicationService.server.ts @@ -1,5 +1,4 @@ import type { ClickHouse } from "@internal/clickhouse"; -import { TASK_RUN_COLUMNS, PAYLOAD_COLUMNS } from "@internal/clickhouse"; import { type RedisOptions } from "@internal/redis"; import { LogicalReplicationClient, @@ -760,14 +759,14 @@ export class RunsReplicationService { #getClickhouseInsertSettings() { if (this._insertStrategy === "insert") { return {}; - } else if (this._insertStrategy === "insert_async") { - return { - async_insert: 1 as const, - async_insert_max_data_size: "1000000", - async_insert_busy_timeout_ms: 1000, - wait_for_async_insert: this.options.waitForAsyncInsert ? (1 as const) : (0 as const), - }; } + + return { + async_insert: 1 as const, + async_insert_max_data_size: "1000000", + async_insert_busy_timeout_ms: 1000, + wait_for_async_insert: this.options.waitForAsyncInsert ? (1 as const) : (0 as const), + }; } async #insertTaskRunInserts(taskRunInserts: any[][], attempt: number) { @@ -825,18 +824,8 @@ export class RunsReplicationService { const { run, _version, event } = batchedRun; - if (!run.environmentType) { - return { - taskRunInsert: undefined, - payloadInsert: undefined, - }; - } - - if (!run.organizationId) { - return { - taskRunInsert: undefined, - payloadInsert: undefined, - }; + if (!run.environmentType || !run.organizationId) { + return {}; } if (event === "update" || event === "delete" || this._disablePayloadInsert) { @@ -848,10 +837,7 @@ export class RunsReplicationService { _version ); - return { - taskRunInsert, - payloadInsert: undefined, - }; + return { taskRunInsert }; } const [taskRunInsert, payloadInsert] = await Promise.all([ @@ -859,10 +845,7 @@ export class RunsReplicationService { this.#preparePayloadInsert(run, _version), ]); - return { - taskRunInsert, - payloadInsert, - }; + return { taskRunInsert, payloadInsert }; } async #prepareTaskRunInsert( diff --git a/internal-packages/clickhouse/src/client/client.ts b/internal-packages/clickhouse/src/client/client.ts index 58e8f0df31..f87251fceb 100644 --- a/internal-packages/clickhouse/src/client/client.ts +++ b/internal-packages/clickhouse/src/client/client.ts @@ -900,24 +900,18 @@ export class ClickhouseClient implements ClickhouseReader, ClickhouseWriter { } } -function recordClickhouseError(span: Span, error: Error) { +function recordClickhouseError(span: Span, error: Error): void { if (error instanceof ClickHouseError) { span.setAttributes({ "clickhouse.error.code": error.code, "clickhouse.error.message": error.message, "clickhouse.error.type": error.type, }); - recordSpanError(span, error); - } else { - recordSpanError(span, error); } + recordSpanError(span, error); } -function convertLogLevelToClickhouseLogLevel(logLevel?: LogLevel) { - if (!logLevel) { - return ClickHouseLogLevel.INFO; - } - +function convertLogLevelToClickhouseLogLevel(logLevel?: LogLevel): ClickHouseLogLevel { switch (logLevel) { case "debug": return ClickHouseLogLevel.DEBUG; From d2082f68e4228035cae89e08a378ce9d6232a3d6 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Sat, 10 Jan 2026 22:03:10 +0000 Subject: [PATCH 08/17] much better type safety --- .../services/runsReplicationService.server.ts | 43 +++--- .../test/runsReplicationService.part2.test.ts | 17 ++- internal-packages/clickhouse/src/index.ts | 8 + internal-packages/clickhouse/src/taskRuns.ts | 137 ++++++++++++++++++ 4 files changed, 175 insertions(+), 30 deletions(-) diff --git a/apps/webapp/app/services/runsReplicationService.server.ts b/apps/webapp/app/services/runsReplicationService.server.ts index af78b73f23..727d13f8b6 100644 --- a/apps/webapp/app/services/runsReplicationService.server.ts +++ b/apps/webapp/app/services/runsReplicationService.server.ts @@ -1,4 +1,5 @@ -import type { ClickHouse } from "@internal/clickhouse"; +import type { ClickHouse, TaskRunInsertArray, PayloadInsertArray } from "@internal/clickhouse"; +import { TASK_RUN_INDEX, PAYLOAD_INDEX } from "@internal/clickhouse"; import { type RedisOptions } from "@internal/redis"; import { LogicalReplicationClient, @@ -80,7 +81,9 @@ type TaskRunInsert = { export type RunsReplicationServiceEvents = { message: [{ lsn: string; message: PgoutputMessage; service: RunsReplicationService }]; - batchFlushed: [{ flushId: string; taskRunInserts: any[][]; payloadInserts: any[][] }]; + batchFlushed: [ + { flushId: string; taskRunInserts: TaskRunInsertArray[]; payloadInserts: PayloadInsertArray[] }, + ]; }; export class RunsReplicationService { @@ -576,25 +579,20 @@ export class RunsReplicationService { .filter(Boolean) // batch inserts in clickhouse are more performant if the items // are pre-sorted by the primary key - // Array indices: [0]=environment_id, [1]=organization_id, [2]=project_id, [3]=run_id, [5]=created_at .sort((a, b) => { - if (a[1] !== b[1]) { - // organization_id - return a[1] < b[1] ? -1 : 1; + if (a[TASK_RUN_INDEX.organization_id] !== b[TASK_RUN_INDEX.organization_id]) { + return a[TASK_RUN_INDEX.organization_id] < b[TASK_RUN_INDEX.organization_id] ? -1 : 1; } - if (a[2] !== b[2]) { - // project_id - return a[2] < b[2] ? -1 : 1; + if (a[TASK_RUN_INDEX.project_id] !== b[TASK_RUN_INDEX.project_id]) { + return a[TASK_RUN_INDEX.project_id] < b[TASK_RUN_INDEX.project_id] ? -1 : 1; } - if (a[0] !== b[0]) { - // environment_id - return a[0] < b[0] ? -1 : 1; + if (a[TASK_RUN_INDEX.environment_id] !== b[TASK_RUN_INDEX.environment_id]) { + return a[TASK_RUN_INDEX.environment_id] < b[TASK_RUN_INDEX.environment_id] ? -1 : 1; } - if (a[5] !== b[5]) { - // created_at - return a[5] - b[5]; + if (a[TASK_RUN_INDEX.created_at] !== b[TASK_RUN_INDEX.created_at]) { + return a[TASK_RUN_INDEX.created_at] - b[TASK_RUN_INDEX.created_at]; } - return a[3] < b[3] ? -1 : 1; // run_id + return a[TASK_RUN_INDEX.run_id] < b[TASK_RUN_INDEX.run_id] ? -1 : 1; }); const payloadInserts = preparedInserts @@ -602,9 +600,8 @@ export class RunsReplicationService { .filter(Boolean) // batch inserts in clickhouse are more performant if the items // are pre-sorted by the primary key - // Array indices: [0]=run_id .sort((a, b) => { - return a[0] < b[0] ? -1 : 1; // run_id + return a[PAYLOAD_INDEX.run_id] < b[PAYLOAD_INDEX.run_id] ? -1 : 1; }); span.setAttribute("task_run_inserts", taskRunInserts.length); @@ -769,7 +766,7 @@ export class RunsReplicationService { }; } - async #insertTaskRunInserts(taskRunInserts: any[][], attempt: number) { + async #insertTaskRunInserts(taskRunInserts: TaskRunInsertArray[], attempt: number) { return await startSpan(this._tracer, "insertTaskRunsInserts", async (span) => { const [insertError, insertResult] = await this.options.clickhouse.taskRuns.insertCompactArrays(taskRunInserts, { @@ -792,7 +789,7 @@ export class RunsReplicationService { }); } - async #insertPayloadInserts(payloadInserts: any[][], attempt: number) { + async #insertPayloadInserts(payloadInserts: PayloadInsertArray[], attempt: number) { return await startSpan(this._tracer, "insertPayloadInserts", async (span) => { const [insertError, insertResult] = await this.options.clickhouse.taskRuns.insertPayloadsCompactArrays(payloadInserts, { @@ -817,7 +814,7 @@ export class RunsReplicationService { async #prepareRunInserts( batchedRun: TaskRunInsert - ): Promise<{ taskRunInsert?: any[]; payloadInsert?: any[] }> { + ): Promise<{ taskRunInsert?: TaskRunInsertArray; payloadInsert?: PayloadInsertArray }> { this.logger.debug("Preparing run", { batchedRun, }); @@ -854,7 +851,7 @@ export class RunsReplicationService { environmentType: string, event: "insert" | "update" | "delete", _version: bigint - ): Promise { + ): Promise { const output = await this.#prepareJson(run.output, run.outputType); // Return array matching TASK_RUN_COLUMNS order @@ -907,7 +904,7 @@ export class RunsReplicationService { ]; } - async #preparePayloadInsert(run: TaskRun, _version: bigint): Promise { + async #preparePayloadInsert(run: TaskRun, _version: bigint): Promise { const payload = await this.#prepareJson(run.payload, run.payloadType); // Return array matching PAYLOAD_COLUMNS order diff --git a/apps/webapp/test/runsReplicationService.part2.test.ts b/apps/webapp/test/runsReplicationService.part2.test.ts index 6375adb4b7..e7198bafe5 100644 --- a/apps/webapp/test/runsReplicationService.part2.test.ts +++ b/apps/webapp/test/runsReplicationService.part2.test.ts @@ -1,4 +1,4 @@ -import { ClickHouse } from "@internal/clickhouse"; +import { ClickHouse, TASK_RUN_INDEX } from "@internal/clickhouse"; import { containerTest } from "@internal/testcontainers"; import { Logger } from "@trigger.dev/core/logger"; import { readFile } from "node:fs/promises"; @@ -889,12 +889,15 @@ describe("RunsReplicationService (part 2/2)", () => { await setTimeout(1000); expect(batchFlushedEvents?.[0].taskRunInserts).toHaveLength(2); - // taskRunInserts are now arrays, not objects - // Index 3 is run_id, Index 6 is status - expect(batchFlushedEvents?.[0].taskRunInserts[0][3]).toEqual(run.id); // run_id - expect(batchFlushedEvents?.[0].taskRunInserts[0][6]).toEqual("PENDING_VERSION"); // status - expect(batchFlushedEvents?.[0].taskRunInserts[1][3]).toEqual(run.id); // run_id - expect(batchFlushedEvents?.[0].taskRunInserts[1][6]).toEqual("COMPLETED_SUCCESSFULLY"); // status + // Use TASK_RUN_INDEX for type-safe array access + expect(batchFlushedEvents?.[0].taskRunInserts[0][TASK_RUN_INDEX.run_id]).toEqual(run.id); + expect(batchFlushedEvents?.[0].taskRunInserts[0][TASK_RUN_INDEX.status]).toEqual( + "PENDING_VERSION" + ); + expect(batchFlushedEvents?.[0].taskRunInserts[1][TASK_RUN_INDEX.run_id]).toEqual(run.id); + expect(batchFlushedEvents?.[0].taskRunInserts[1][TASK_RUN_INDEX.status]).toEqual( + "COMPLETED_SUCCESSFULLY" + ); await runsReplicationService.stop(); } diff --git a/internal-packages/clickhouse/src/index.ts b/internal-packages/clickhouse/src/index.ts index cd498651f1..08be47f629 100644 --- a/internal-packages/clickhouse/src/index.ts +++ b/internal-packages/clickhouse/src/index.ts @@ -31,6 +31,14 @@ export type * from "./taskRuns.js"; export type * from "./taskEvents.js"; export type * from "./client/queryBuilder.js"; +// Re-export column constants and indices for type-safe array access +export { + TASK_RUN_COLUMNS, + TASK_RUN_INDEX, + PAYLOAD_COLUMNS, + PAYLOAD_INDEX, +} from "./taskRuns.js"; + // TSQL query execution export { executeTSQL, diff --git a/internal-packages/clickhouse/src/taskRuns.ts b/internal-packages/clickhouse/src/taskRuns.ts index 7f9d736150..d8e8f0450b 100644 --- a/internal-packages/clickhouse/src/taskRuns.ts +++ b/internal-packages/clickhouse/src/taskRuns.ts @@ -101,6 +101,72 @@ export const TASK_RUN_COLUMNS = [ "max_duration_in_seconds", ] as const; +// Type-safe column indices derived from TASK_RUN_COLUMNS +// This ensures indices stay in sync with column order +export const TASK_RUN_INDEX = { + environment_id: 0, + organization_id: 1, + project_id: 2, + run_id: 3, + updated_at: 4, + created_at: 5, + status: 6, + environment_type: 7, + friendly_id: 8, + attempt: 9, + engine: 10, + task_identifier: 11, + queue: 12, + schedule_id: 13, + batch_id: 14, + completed_at: 15, + started_at: 16, + executed_at: 17, + delay_until: 18, + queued_at: 19, + expired_at: 20, + usage_duration_ms: 21, + cost_in_cents: 22, + base_cost_in_cents: 23, + output: 24, + error: 25, + tags: 26, + task_version: 27, + sdk_version: 28, + cli_version: 29, + machine_preset: 30, + root_run_id: 31, + parent_run_id: 32, + depth: 33, + span_id: 34, + trace_id: 35, + idempotency_key: 36, + expiration_ttl: 37, + is_test: 38, + _version: 39, + _is_deleted: 40, + concurrency_key: 41, + bulk_action_group_ids: 42, + worker_queue: 43, + max_duration_in_seconds: 44, +} as const satisfies Record<(typeof TASK_RUN_COLUMNS)[number], number>; + +export type TaskRunColumnName = (typeof TASK_RUN_COLUMNS)[number]; + +// Runtime assertion to verify TASK_RUN_INDEX matches TASK_RUN_COLUMNS order +// This will throw at module load time if there's a mismatch +(function verifyTaskRunColumnIndices() { + for (let i = 0; i < TASK_RUN_COLUMNS.length; i++) { + const column = TASK_RUN_COLUMNS[i]; + const index = TASK_RUN_INDEX[column]; + if (index !== i) { + throw new Error( + `TASK_RUN_INDEX mismatch: column "${column}" has index ${index} but should be ${i}` + ); + } + } +})(); + export function insertTaskRunsCompactArrays(ch: ClickhouseWriter, settings?: ClickHouseSettings) { return ch.insertCompactRaw({ name: "insertTaskRunsCompactArrays", @@ -124,6 +190,77 @@ export type RawTaskRunPayloadV1 = z.infer; export const PAYLOAD_COLUMNS = ["run_id", "created_at", "payload"] as const; +// Type-safe column indices for payload columns +export const PAYLOAD_INDEX = { + run_id: 0, + created_at: 1, + payload: 2, +} as const satisfies Record<(typeof PAYLOAD_COLUMNS)[number], number>; + +export type PayloadColumnName = (typeof PAYLOAD_COLUMNS)[number]; + +/** + * Type-safe tuple representing a task run insert array. + * Order matches TASK_RUN_COLUMNS exactly. + */ +export type TaskRunInsertArray = [ + environment_id: string, + organization_id: string, + project_id: string, + run_id: string, + updated_at: number, + created_at: number, + status: string, + environment_type: string, + friendly_id: string, + attempt: number, + engine: string, + task_identifier: string, + queue: string, + schedule_id: string, + batch_id: string, + completed_at: number | null, + started_at: number | null, + executed_at: number | null, + delay_until: number | null, + queued_at: number | null, + expired_at: number | null, + usage_duration_ms: number, + cost_in_cents: number, + base_cost_in_cents: number, + output: { data: unknown }, + error: { data: unknown }, + tags: string[], + task_version: string, + sdk_version: string, + cli_version: string, + machine_preset: string, + root_run_id: string, + parent_run_id: string, + depth: number, + span_id: string, + trace_id: string, + idempotency_key: string, + expiration_ttl: string, + is_test: boolean, + _version: string, + _is_deleted: number, + concurrency_key: string, + bulk_action_group_ids: string[], + worker_queue: string, + max_duration_in_seconds: number | null, +]; + +/** + * Type-safe tuple representing a payload insert array. + * Order matches PAYLOAD_COLUMNS exactly. + */ +export type PayloadInsertArray = [ + run_id: string, + created_at: number, + payload: { data: unknown }, +]; + export function insertRawTaskRunPayloadsCompactArrays( ch: ClickhouseWriter, settings?: ClickHouseSettings From c3d5469692ad74f748e06437ae3e080f10d02b6a Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Sun, 11 Jan 2026 07:05:24 +0000 Subject: [PATCH 09/17] fixed types --- .../scripts/profile-runs-replication.ts | 2 +- .../test/performance/clickhouse-mock.ts | 78 ++++++++++++++++--- apps/webapp/test/performance/config.ts | 2 +- .../test/performance/consumer-runner.ts | 14 ++-- apps/webapp/test/performance/consumer.ts | 4 +- .../webapp/test/performance/data-generator.ts | 23 +++--- apps/webapp/test/performance/harness.ts | 7 +- .../test/performance/producer-runner.ts | 2 +- 8 files changed, 96 insertions(+), 36 deletions(-) diff --git a/apps/webapp/scripts/profile-runs-replication.ts b/apps/webapp/scripts/profile-runs-replication.ts index 4b89cc5361..baaef30a65 100644 --- a/apps/webapp/scripts/profile-runs-replication.ts +++ b/apps/webapp/scripts/profile-runs-replication.ts @@ -33,7 +33,7 @@ async function loadConfig(options: any): Promise { if (options.config) { console.log(`Loading config from: ${options.config}`); const configFile = await fs.readFile(options.config, "utf-8"); - const fileConfig = JSON.parse(configFile); + const fileConfig = JSON.parse(configFile) as Partial; config = { ...config, ...fileConfig }; } diff --git a/apps/webapp/test/performance/clickhouse-mock.ts b/apps/webapp/test/performance/clickhouse-mock.ts index 53a2e010a3..b98344c26e 100644 --- a/apps/webapp/test/performance/clickhouse-mock.ts +++ b/apps/webapp/test/performance/clickhouse-mock.ts @@ -1,4 +1,21 @@ -import type { RawTaskRunPayloadV1, TaskRunV2 } from "@internal/clickhouse"; +import type { ClickHouse, TaskRunInsertArray, PayloadInsertArray } from "@internal/clickhouse"; + +// Minimal InsertResult type to avoid dependency on @clickhouse/client +interface InsertResult { + executed: boolean; + query_id: string; + summary?: { + read_rows: string; + read_bytes: string; + written_rows: string; + written_bytes: string; + total_rows_to_read: string; + result_rows: string; + result_bytes: string; + elapsed_ns: string; + }; + response_headers: Record; +} /** * Mock ClickHouse client for CPU-only profiling. @@ -12,30 +29,64 @@ export class MockClickHouse { constructor(private readonly insertDelayMs: number = 0) {} taskRuns = { - insert: async ( - runs: TaskRunV2[], + insertCompactArrays: async ( + rows: TaskRunInsertArray[], options?: any - ): Promise<[Error | null, { rows: number } | null]> => { + ): Promise<[Error | null, InsertResult | null]> => { if (this.insertDelayMs > 0) { await new Promise((resolve) => setTimeout(resolve, this.insertDelayMs)); } - this.insertCount += runs.length; + this.insertCount += rows.length; - return [null, { rows: runs.length }]; + return [ + null, + { + executed: true, + query_id: "mock", + summary: { + read_rows: "0", + read_bytes: "0", + written_rows: String(rows.length), + written_bytes: "0", + total_rows_to_read: "0", + result_rows: "0", + result_bytes: "0", + elapsed_ns: "0", + }, + response_headers: {}, + }, + ]; }, - insertPayloads: async ( - payloads: RawTaskRunPayloadV1[], + insertPayloadsCompactArrays: async ( + rows: PayloadInsertArray[], options?: any - ): Promise<[Error | null, { rows: number } | null]> => { + ): Promise<[Error | null, InsertResult | null]> => { if (this.insertDelayMs > 0) { await new Promise((resolve) => setTimeout(resolve, this.insertDelayMs)); } - this.payloadInsertCount += payloads.length; + this.payloadInsertCount += rows.length; - return [null, { rows: payloads.length }]; + return [ + null, + { + executed: true, + query_id: "mock", + summary: { + read_rows: "0", + read_bytes: "0", + written_rows: String(rows.length), + written_bytes: "0", + total_rows_to_read: "0", + result_rows: "0", + result_bytes: "0", + elapsed_ns: "0", + }, + response_headers: {}, + }, + ]; }, }; @@ -51,3 +102,8 @@ export class MockClickHouse { this.payloadInsertCount = 0; } } + +// Type assertion helper for use with RunsReplicationService +export function asMockClickHouse(mock: MockClickHouse): Pick { + return mock as unknown as Pick; +} diff --git a/apps/webapp/test/performance/config.ts b/apps/webapp/test/performance/config.ts index 56292b2d6c..e99a6f8bd7 100644 --- a/apps/webapp/test/performance/config.ts +++ b/apps/webapp/test/performance/config.ts @@ -1,5 +1,5 @@ import { RedisOptions } from "ioredis"; -import { RuntimeEnvironmentType } from "~/database-types"; +import type { RuntimeEnvironmentType } from "@trigger.dev/database"; import { config as loadEnv } from "dotenv"; import path from "path"; diff --git a/apps/webapp/test/performance/consumer-runner.ts b/apps/webapp/test/performance/consumer-runner.ts index cd9b4b078b..0bad856453 100644 --- a/apps/webapp/test/performance/consumer-runner.ts +++ b/apps/webapp/test/performance/consumer-runner.ts @@ -1,7 +1,8 @@ #!/usr/bin/env tsx +import type { ClickHouse } from "@internal/clickhouse"; import { RunsReplicationService } from "~/services/runsReplicationService.server"; -import { MockClickHouse } from "./clickhouse-mock"; +import { MockClickHouse, asMockClickHouse } from "./clickhouse-mock"; import type { ConsumerConfig } from "./config"; import fs from "fs"; import path from "path"; @@ -16,7 +17,7 @@ async function main() { } // Parse configuration from environment variable - const config: ConsumerConfig = JSON.parse(process.env.CONSUMER_CONFIG!); + const config = JSON.parse(process.env.CONSUMER_CONFIG!) as ConsumerConfig; // Create shutdown signal file path const shutdownFilePath = path.join(config.outputDir || "/tmp", ".shutdown-signal"); @@ -29,9 +30,9 @@ async function main() { }); // Create ClickHouse client (real or mocked) - let clickhouse; + let clickhouse: Pick; if (config.useMockClickhouse) { - clickhouse = new MockClickHouse(config.mockClickhouseDelay); + clickhouse = asMockClickHouse(new MockClickHouse(config.mockClickhouseDelay)); } else { // Use dynamic import to avoid module resolution issues with tsx const { ClickHouse } = await import("@internal/clickhouse"); @@ -47,7 +48,7 @@ async function main() { // Create replication service const service = new RunsReplicationService({ - clickhouse, + clickhouse: clickhouse as ClickHouse, pgConnectionUrl: config.pgConnectionUrl, serviceName: "runs-replication-profiling", slotName: config.slotName, @@ -89,7 +90,8 @@ async function main() { // Send periodic metrics to parent (if IPC available) const metricsInterval = setInterval(() => { const memUsage = process.memoryUsage(); - const elu = performance.eventLoopUtilization(); + const { eventLoopUtilization } = require("perf_hooks").performance; + const elu = eventLoopUtilization ? eventLoopUtilization() : { utilization: 0 }; if (hasIPC) { process.send!({ diff --git a/apps/webapp/test/performance/consumer.ts b/apps/webapp/test/performance/consumer.ts index ead4846a74..88452e7f3b 100644 --- a/apps/webapp/test/performance/consumer.ts +++ b/apps/webapp/test/performance/consumer.ts @@ -52,7 +52,7 @@ export class ConsumerProcessManager { if (isProfiling && this.process.stdout) { this.process.stdout.on("data", (data: Buffer) => { const output = data.toString(); - process.stdout.write(data); // Still show output + process.stdout.write(output); // Still show output if (output.includes("Consumer process ready")) { this.ready = true; console.log("Consumer process is ready (detected from stdout)"); @@ -62,7 +62,7 @@ export class ConsumerProcessManager { if (isProfiling && this.process.stderr) { this.process.stderr.on("data", (data: Buffer) => { - process.stderr.write(data); // Show stderr + process.stderr.write(data.toString()); // Show stderr }); } diff --git a/apps/webapp/test/performance/data-generator.ts b/apps/webapp/test/performance/data-generator.ts index c46df1c157..f2e19eb60d 100644 --- a/apps/webapp/test/performance/data-generator.ts +++ b/apps/webapp/test/performance/data-generator.ts @@ -1,6 +1,5 @@ -import { Prisma } from "@trigger.dev/database"; +import { Prisma, RuntimeEnvironmentType, TaskRunStatus } from "@trigger.dev/database"; import { nanoid } from "nanoid"; -import { RuntimeEnvironmentType, TaskRunStatus } from "~/database-types"; import superjson from "superjson"; export interface DataGeneratorOptions { @@ -41,15 +40,15 @@ export class TaskRunDataGenerator { constructor(private readonly options: DataGeneratorOptions) {} - generateBatch(count: number): Prisma.TaskRunCreateInput[] { - const batch: Prisma.TaskRunCreateInput[] = []; + generateBatch(count: number): Prisma.TaskRunCreateManyInput[] { + const batch: Prisma.TaskRunCreateManyInput[] = []; for (let i = 0; i < count; i++) { batch.push(this.generateInsert()); } return batch; } - generateInsert(): Prisma.TaskRunCreateInput { + generateInsert(): Prisma.TaskRunCreateManyInput { this.counter++; const id = nanoid(); const friendlyId = `run_${this.counter}_${nanoid(8)}`; @@ -59,17 +58,19 @@ export class TaskRunDataGenerator { const workerQueue = this.workerQueues[Math.floor(Math.random() * this.workerQueues.length)]; const payload = this.generatePayload(); - const payloadType = this.options.includeComplexPayloads && Math.random() > 0.7 - ? "application/super+json" - : "application/json"; + const payloadType = + this.options.includeComplexPayloads && Math.random() > 0.7 + ? "application/super+json" + : "application/json"; return { id, friendlyId, taskIdentifier, - payload: payloadType === "application/super+json" - ? superjson.stringify(payload) - : JSON.stringify(payload), + payload: + payloadType === "application/super+json" + ? superjson.stringify(payload) + : JSON.stringify(payload), payloadType, traceId: nanoid(), spanId: nanoid(), diff --git a/apps/webapp/test/performance/harness.ts b/apps/webapp/test/performance/harness.ts index a1503951a5..1cf52b4aba 100644 --- a/apps/webapp/test/performance/harness.ts +++ b/apps/webapp/test/performance/harness.ts @@ -267,9 +267,10 @@ export class RunsReplicationHarness { const cleanProfilingUrl = this.profilingDatabaseUrl.split("?")[0]; // Dump schema only (no data) from main database - execSync(`pg_dump "${cleanBaseUrl}" --schema-only --no-owner --no-acl | psql "${cleanProfilingUrl}" > /dev/null 2>&1`, { - shell: true, - }); + execSync( + `pg_dump "${cleanBaseUrl}" --schema-only --no-owner --no-acl | psql "${cleanProfilingUrl}" > /dev/null 2>&1`, + { shell: "/bin/bash" } + ); console.log("โœ… Schema copied successfully"); } catch (error) { diff --git a/apps/webapp/test/performance/producer-runner.ts b/apps/webapp/test/performance/producer-runner.ts index 3963c6050d..10de2f4cc3 100644 --- a/apps/webapp/test/performance/producer-runner.ts +++ b/apps/webapp/test/performance/producer-runner.ts @@ -11,7 +11,7 @@ async function main() { } // Parse configuration from environment variable - const config: ProducerConfig = JSON.parse(process.env.PRODUCER_CONFIG!); + const config = JSON.parse(process.env.PRODUCER_CONFIG!) as ProducerConfig; console.log("Producer process starting with config:", { targetThroughput: config.targetThroughput, From d667aae66cdb563b2e1c9da7069645445ee78497 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Sun, 11 Jan 2026 07:33:56 +0000 Subject: [PATCH 10/17] fix clickhouse tests --- .../clickhouse/src/taskRuns.test.ts | 429 ++++++++++-------- 1 file changed, 231 insertions(+), 198 deletions(-) diff --git a/internal-packages/clickhouse/src/taskRuns.test.ts b/internal-packages/clickhouse/src/taskRuns.test.ts index b51c9f38c0..11be065e70 100644 --- a/internal-packages/clickhouse/src/taskRuns.test.ts +++ b/internal-packages/clickhouse/src/taskRuns.test.ts @@ -1,7 +1,15 @@ import { clickhouseTest } from "@internal/testcontainers"; import { z } from "zod"; import { ClickhouseClient } from "./client/client.js"; -import { getTaskRunsQueryBuilder, insertRawTaskRunPayloads, insertTaskRuns } from "./taskRuns.js"; +import { + getTaskRunsQueryBuilder, + insertRawTaskRunPayloadsCompactArrays, + insertTaskRunsCompactArrays, + TASK_RUN_COLUMNS, + PAYLOAD_COLUMNS, + type TaskRunInsertArray, + type PayloadInsertArray, +} from "./taskRuns.js"; describe("Task Runs V2", () => { clickhouseTest("should be able to insert task runs", async ({ clickhouseContainer }) => { @@ -11,61 +19,64 @@ describe("Task Runs V2", () => { logLevel: "debug", }); - const insert = insertTaskRuns(client, { + const insert = insertTaskRunsCompactArrays(client, { async_insert: 0, // turn off async insert for this test }); - const insertPayloads = insertRawTaskRunPayloads(client, { + const insertPayloads = insertRawTaskRunPayloadsCompactArrays(client, { async_insert: 0, // turn off async insert for this test }); - const [insertError, insertResult] = await insert([ - { - environment_id: "env_1234", - environment_type: "DEVELOPMENT", - organization_id: "org_1234", - project_id: "project_1234", - run_id: "run_1234", - friendly_id: "friendly_1234", - attempt: 1, - engine: "V2", - status: "PENDING", - task_identifier: "my-task", - queue: "my-queue", - schedule_id: "schedule_1234", - batch_id: "batch_1234", - created_at: Date.now(), - updated_at: Date.now(), - completed_at: undefined, - tags: ["tag1", "tag2"], - output: { - key: "value", - }, - error: { - type: "BUILT_IN_ERROR", - name: "Error", - message: "error", - stackTrace: "stack trace", - }, - usage_duration_ms: 1000, - cost_in_cents: 100, - task_version: "1.0.0", - sdk_version: "1.0.0", - cli_version: "1.0.0", - machine_preset: "small-1x", - is_test: true, - span_id: "span_1234", - trace_id: "trace_1234", - idempotency_key: "idempotency_key_1234", - expiration_ttl: "1h", - root_run_id: "root_run_1234", - parent_run_id: "parent_run_1234", - depth: 1, - concurrency_key: "concurrency_key_1234", - bulk_action_group_ids: ["bulk_action_group_id_1234", "bulk_action_group_id_1235"], - _version: "1", - }, - ]); + const now = Date.now(); + const taskRunData: TaskRunInsertArray = [ + "env_1234", // environment_id + "org_1234", // organization_id + "project_1234", // project_id + "run_1234", // run_id + now, // updated_at + now, // created_at + "PENDING", // status + "DEVELOPMENT", // environment_type + "friendly_1234", // friendly_id + 1, // attempt + "V2", // engine + "my-task", // task_identifier + "my-queue", // queue + "schedule_1234", // schedule_id + "batch_1234", // batch_id + null, // completed_at + null, // started_at + null, // executed_at + null, // delay_until + null, // queued_at + null, // expired_at + 1000, // usage_duration_ms + 100, // cost_in_cents + 0, // base_cost_in_cents + { data: { key: "value" } }, // output + { data: { type: "BUILT_IN_ERROR", name: "Error", message: "error", stackTrace: "stack trace" } }, // error + ["tag1", "tag2"], // tags + "1.0.0", // task_version + "1.0.0", // sdk_version + "1.0.0", // cli_version + "small-1x", // machine_preset + "root_run_1234", // root_run_id + "parent_run_1234", // parent_run_id + 1, // depth + "span_1234", // span_id + "trace_1234", // trace_id + "idempotency_key_1234", // idempotency_key + "1h", // expiration_ttl + true, // is_test + "1", // _version + 0, // _is_deleted + "concurrency_key_1234", // concurrency_key + ["bulk_action_group_id_1234", "bulk_action_group_id_1235"], // bulk_action_group_ids + "", // worker_queue + null, // max_duration_in_seconds + ]; + + const [insertError, insertResult] = await insert([taskRunData]); expect(insertError).toBeNull(); expect(insertResult).toEqual(expect.objectContaining({ executed: true })); @@ -99,15 +110,13 @@ describe("Task Runs V2", () => { ]) ); - const [insertPayloadsError, insertPayloadsResult] = await insertPayloads([ - { - run_id: "run_1234", - created_at: Date.now(), - payload: { - key: "value", - }, - }, - ]); + const payloadData: PayloadInsertArray = [ + "run_1234", // run_id + Date.now(), // created_at + { data: { key: "value" } }, // payload + ]; + + const [insertPayloadsError, insertPayloadsResult] = await insertPayloads([payloadData]); expect(insertPayloadsError).toBeNull(); expect(insertPayloadsResult).toEqual(expect.objectContaining({ executed: true })); @@ -137,96 +146,110 @@ describe("Task Runs V2", () => { url: clickhouseContainer.getConnectionUrl(), }); - const insert = insertTaskRuns(client, { + const insert = insertTaskRunsCompactArrays(client, { async_insert: 0, // turn off async insert for this test }); - const [insertError, insertResult] = await insert([ - { - environment_id: "cm9kddfcs01zqdy88ld9mmrli", - organization_id: "cm8zs78wb0002dy616dg75tv3", - project_id: "cm9kddfbz01zpdy88t9dstecu", - run_id: "cma45oli70002qrdy47w0j4n7", - environment_type: "PRODUCTION", - friendly_id: "run_cma45oli70002qrdy47w0j4n7", - attempt: 1, - engine: "V2", - status: "PENDING", - task_identifier: "retry-task", - queue: "task/retry-task", - schedule_id: "", - batch_id: "", - root_run_id: "", - parent_run_id: "", - depth: 0, - span_id: "538677637f937f54", - trace_id: "20a28486b0b9f50c647b35e8863e36a5", - idempotency_key: "", - created_at: new Date("2025-04-30 16:34:04.312").getTime(), - updated_at: new Date("2025-04-30 16:34:04.312").getTime(), - started_at: null, - executed_at: null, - completed_at: null, - delay_until: null, - queued_at: new Date("2025-04-30 16:34:04.311").getTime(), - expired_at: null, - expiration_ttl: "", - usage_duration_ms: 0, - cost_in_cents: 0, - base_cost_in_cents: 0, - output: null, - error: null, - tags: [], - task_version: "", - sdk_version: "", - cli_version: "", - machine_preset: "", - is_test: true, - _version: "1", - }, - { - environment_id: "cm9kddfcs01zqdy88ld9mmrli", - organization_id: "cm8zs78wb0002dy616dg75tv3", - project_id: "cm9kddfbz01zpdy88t9dstecu", - run_id: "cma45oli70002qrdy47w0j4n7", - environment_type: "PRODUCTION", - friendly_id: "run_cma45oli70002qrdy47w0j4n7", - attempt: 1, - engine: "V2", - status: "COMPLETED_SUCCESSFULLY", - task_identifier: "retry-task", - queue: "task/retry-task", - schedule_id: "", - batch_id: "", - root_run_id: "", - parent_run_id: "", - depth: 0, - span_id: "538677637f937f54", - trace_id: "20a28486b0b9f50c647b35e8863e36a5", - idempotency_key: "", - created_at: new Date("2025-04-30 16:34:04.312").getTime(), - updated_at: new Date("2025-04-30 16:34:04.312").getTime(), - started_at: null, - executed_at: null, - completed_at: null, - delay_until: null, - queued_at: new Date("2025-04-30 16:34:04.311").getTime(), - expired_at: null, - expiration_ttl: "", - usage_duration_ms: 0, - cost_in_cents: 0, - base_cost_in_cents: 0, - output: null, - error: null, - tags: [], - task_version: "", - sdk_version: "", - cli_version: "", - machine_preset: "", - is_test: true, - _version: "2", - }, - ]); + const createdAt = new Date("2025-04-30 16:34:04.312").getTime(); + const queuedAt = new Date("2025-04-30 16:34:04.311").getTime(); + + const run1: TaskRunInsertArray = [ + "cm9kddfcs01zqdy88ld9mmrli", // environment_id + "cm8zs78wb0002dy616dg75tv3", // organization_id + "cm9kddfbz01zpdy88t9dstecu", // project_id + "cma45oli70002qrdy47w0j4n7", // run_id + createdAt, // updated_at + createdAt, // created_at + "PENDING", // status + "PRODUCTION", // environment_type + "run_cma45oli70002qrdy47w0j4n7", // friendly_id + 1, // attempt + "V2", // engine + "retry-task", // task_identifier + "task/retry-task", // queue + "", // schedule_id + "", // batch_id + null, // completed_at + null, // started_at + null, // executed_at + null, // delay_until + queuedAt, // queued_at + null, // expired_at + 0, // usage_duration_ms + 0, // cost_in_cents + 0, // base_cost_in_cents + { data: null }, // output + { data: null }, // error + [], // tags + "", // task_version + "", // sdk_version + "", // cli_version + "", // machine_preset + "", // root_run_id + "", // parent_run_id + 0, // depth + "538677637f937f54", // span_id + "20a28486b0b9f50c647b35e8863e36a5", // trace_id + "", // idempotency_key + "", // expiration_ttl + true, // is_test + "1", // _version + 0, // _is_deleted + "", // concurrency_key + [], // bulk_action_group_ids + "", // worker_queue + null, // max_duration_in_seconds + ]; + + const run2: TaskRunInsertArray = [ + "cm9kddfcs01zqdy88ld9mmrli", // environment_id + "cm8zs78wb0002dy616dg75tv3", // organization_id + "cm9kddfbz01zpdy88t9dstecu", // project_id + "cma45oli70002qrdy47w0j4n7", // run_id + createdAt, // updated_at + createdAt, // created_at + "COMPLETED_SUCCESSFULLY", // status + "PRODUCTION", // environment_type + "run_cma45oli70002qrdy47w0j4n7", // friendly_id + 1, // attempt + "V2", // engine + "retry-task", // task_identifier + "task/retry-task", // queue + "", // schedule_id + "", // batch_id + null, // completed_at + null, // started_at + null, // executed_at + null, // delay_until + queuedAt, // queued_at + null, // expired_at + 0, // usage_duration_ms + 0, // cost_in_cents + 0, // base_cost_in_cents + { data: null }, // output + { data: null }, // error + [], // tags + "", // task_version + "", // sdk_version + "", // cli_version + "", // machine_preset + "", // root_run_id + "", // parent_run_id + 0, // depth + "538677637f937f54", // span_id + "20a28486b0b9f50c647b35e8863e36a5", // trace_id + "", // idempotency_key + "", // expiration_ttl + true, // is_test + "2", // _version + 0, // _is_deleted + "", // concurrency_key + [], // bulk_action_group_ids + "", // worker_queue + null, // max_duration_in_seconds + ]; + + const [insertError, insertResult] = await insert([run1, run2]); expect(insertError).toBeNull(); expect(insertResult).toEqual(expect.objectContaining({ executed: true })); @@ -266,54 +289,62 @@ describe("Task Runs V2", () => { url: clickhouseContainer.getConnectionUrl(), }); - const insert = insertTaskRuns(client, { + const insert = insertTaskRunsCompactArrays(client, { async_insert: 0, // turn off async insert for this test }); - const [insertError, insertResult] = await insert([ - { - environment_id: "cm9kddfcs01zqdy88ld9mmrli", - organization_id: "cm8zs78wb0002dy616dg75tv3", - project_id: "cm9kddfbz01zpdy88t9dstecu", - run_id: "cma45oli70002qrdy47w0j4n7", - environment_type: "PRODUCTION", - friendly_id: "run_cma45oli70002qrdy47w0j4n7", - attempt: 1, - engine: "V2", - status: "PENDING", - task_identifier: "retry-task", - queue: "task/retry-task", - schedule_id: "", - batch_id: "", - root_run_id: "", - parent_run_id: "", - depth: 0, - span_id: "538677637f937f54", - trace_id: "20a28486b0b9f50c647b35e8863e36a5", - idempotency_key: "", - created_at: new Date("2025-04-30 16:34:04.312").getTime(), - updated_at: new Date("2025-04-30 16:34:04.312").getTime(), - started_at: null, - executed_at: null, - completed_at: null, - delay_until: null, - queued_at: new Date("2025-04-30 16:34:04.311").getTime(), - expired_at: null, - expiration_ttl: "", - usage_duration_ms: 0, - cost_in_cents: 0, - base_cost_in_cents: 0, - output: null, - error: null, - tags: [], - task_version: "", - sdk_version: "", - cli_version: "", - machine_preset: "", - is_test: true, - _version: "1", - }, - ]); + const createdAt = new Date("2025-04-30 16:34:04.312").getTime(); + const queuedAt = new Date("2025-04-30 16:34:04.311").getTime(); + + const taskRun: TaskRunInsertArray = [ + "cm9kddfcs01zqdy88ld9mmrli", // environment_id + "cm8zs78wb0002dy616dg75tv3", // organization_id + "cm9kddfbz01zpdy88t9dstecu", // project_id + "cma45oli70002qrdy47w0j4n7", // run_id + createdAt, // updated_at + createdAt, // created_at + "PENDING", // status + "PRODUCTION", // environment_type + "run_cma45oli70002qrdy47w0j4n7", // friendly_id + 1, // attempt + "V2", // engine + "retry-task", // task_identifier + "task/retry-task", // queue + "", // schedule_id + "", // batch_id + null, // completed_at + null, // started_at + null, // executed_at + null, // delay_until + queuedAt, // queued_at + null, // expired_at + 0, // usage_duration_ms + 0, // cost_in_cents + 0, // base_cost_in_cents + { data: null }, // output + { data: null }, // error + [], // tags + "", // task_version + "", // sdk_version + "", // cli_version + "", // machine_preset + "", // root_run_id + "", // parent_run_id + 0, // depth + "538677637f937f54", // span_id + "20a28486b0b9f50c647b35e8863e36a5", // trace_id + "", // idempotency_key + "", // expiration_ttl + true, // is_test + "1", // _version + 0, // _is_deleted + "", // concurrency_key + [], // bulk_action_group_ids + "", // worker_queue + null, // max_duration_in_seconds + ]; + + const [insertError, insertResult] = await insert([taskRun]); const queryBuilder = getTaskRunsQueryBuilder(client)(); queryBuilder.where("environment_id = {environmentId: String}", { @@ -360,15 +391,15 @@ describe("Task Runs V2", () => { url: clickhouseContainer.getConnectionUrl(), }); - const insertPayloads = insertRawTaskRunPayloads(client, { + const insertPayloads = insertRawTaskRunPayloadsCompactArrays(client, { async_insert: 0, // turn off async insert for this test }); - const [insertPayloadsError, insertPayloadsResult] = await insertPayloads([ + const payloadData: PayloadInsertArray = [ + "run_1234", // run_id + Date.now(), // created_at { - run_id: "run_1234", - created_at: Date.now(), - payload: { + data: { data: { title: { id: "123", @@ -376,8 +407,10 @@ describe("Task Runs V2", () => { "title.id": 123, }, }, - }, - ]); + }, // payload + ]; + + const [insertPayloadsError, insertPayloadsResult] = await insertPayloads([payloadData]); expect(insertPayloadsError).toBeNull(); expect(insertPayloadsResult).toEqual(expect.objectContaining({ executed: true })); From 2c0f9dc6f9cdd6542e9b1eca1a11082810c359e3 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Sun, 11 Jan 2026 07:51:25 +0000 Subject: [PATCH 11/17] really fix clickhouse tests --- .../clickhouse/src/taskRuns.test.ts | 2 -- internal-packages/clickhouse/src/taskRuns.ts | 32 +++++++++++++++++++ 2 files changed, 32 insertions(+), 2 deletions(-) diff --git a/internal-packages/clickhouse/src/taskRuns.test.ts b/internal-packages/clickhouse/src/taskRuns.test.ts index 11be065e70..feecb63a00 100644 --- a/internal-packages/clickhouse/src/taskRuns.test.ts +++ b/internal-packages/clickhouse/src/taskRuns.test.ts @@ -5,8 +5,6 @@ import { getTaskRunsQueryBuilder, insertRawTaskRunPayloadsCompactArrays, insertTaskRunsCompactArrays, - TASK_RUN_COLUMNS, - PAYLOAD_COLUMNS, type TaskRunInsertArray, type PayloadInsertArray, } from "./taskRuns.js"; diff --git a/internal-packages/clickhouse/src/taskRuns.ts b/internal-packages/clickhouse/src/taskRuns.ts index d8e8f0450b..1757eae941 100644 --- a/internal-packages/clickhouse/src/taskRuns.ts +++ b/internal-packages/clickhouse/src/taskRuns.ts @@ -180,6 +180,20 @@ export function insertTaskRunsCompactArrays(ch: ClickhouseWriter, settings?: Cli }); } +// Object-based insert function for tests and non-performance-critical code +export function insertTaskRuns(ch: ClickhouseWriter, settings?: ClickHouseSettings) { + return ch.insert({ + name: "insertTaskRuns", + table: "trigger_dev.task_runs_v2", + schema: TaskRunV2, + settings: { + enable_json_type: 1, + type_json_skip_duplicated_paths: 1, + ...settings, + }, + }); +} + export const RawTaskRunPayloadV1 = z.object({ run_id: z.string(), created_at: z.number().int(), @@ -281,6 +295,24 @@ export function insertRawTaskRunPayloadsCompactArrays( }); } +// Object-based insert function for tests and non-performance-critical code +export function insertRawTaskRunPayloads(ch: ClickhouseWriter, settings?: ClickHouseSettings) { + return ch.insert({ + name: "insertRawTaskRunPayloads", + table: "trigger_dev.raw_task_runs_payload_v1", + schema: RawTaskRunPayloadV1, + settings: { + async_insert: 1, + wait_for_async_insert: 0, + async_insert_max_data_size: "1000000", + async_insert_busy_timeout_ms: 1000, + enable_json_type: 1, + type_json_skip_duplicated_paths: 1, + ...settings, + }, + }); +} + export const TaskRunV2QueryResult = z.object({ run_id: z.string(), }); From a66bb6fd9befced2240a2ac5f0ceaefa09d2bba8 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Sun, 11 Jan 2026 11:18:25 +0000 Subject: [PATCH 12/17] Add object-based insert functions and fix index generation - Add back insertTaskRuns and insertRawTaskRunPayloads for tsql tests - Generate TASK_RUN_INDEX and PAYLOAD_INDEX programmatically from column arrays - Fix maxDurationInSeconds default from 0 to null - Update runsReplicationService.part2.test.ts to use index constants Co-Authored-By: Claude Opus 4.5 --- .../services/runsReplicationService.server.ts | 2 +- .../test/runsReplicationService.part2.test.ts | 27 +++---- internal-packages/clickhouse/src/taskRuns.ts | 80 +++---------------- 3 files changed, 23 insertions(+), 86 deletions(-) diff --git a/apps/webapp/app/services/runsReplicationService.server.ts b/apps/webapp/app/services/runsReplicationService.server.ts index 727d13f8b6..c409b0621c 100644 --- a/apps/webapp/app/services/runsReplicationService.server.ts +++ b/apps/webapp/app/services/runsReplicationService.server.ts @@ -900,7 +900,7 @@ export class RunsReplicationService { run.concurrencyKey ?? "", // concurrency_key run.bulkActionGroupIds ?? [], // bulk_action_group_ids run.masterQueue ?? "", // worker_queue - run.maxDurationInSeconds ?? 0, // max_duration_in_seconds + run.maxDurationInSeconds ?? null, // max_duration_in_seconds ]; } diff --git a/apps/webapp/test/runsReplicationService.part2.test.ts b/apps/webapp/test/runsReplicationService.part2.test.ts index e7198bafe5..718875491e 100644 --- a/apps/webapp/test/runsReplicationService.part2.test.ts +++ b/apps/webapp/test/runsReplicationService.part2.test.ts @@ -1,4 +1,4 @@ -import { ClickHouse, TASK_RUN_INDEX } from "@internal/clickhouse"; +import { ClickHouse, TASK_RUN_INDEX, PAYLOAD_INDEX } from "@internal/clickhouse"; import { containerTest } from "@internal/testcontainers"; import { Logger } from "@trigger.dev/core/logger"; import { readFile } from "node:fs/promises"; @@ -1062,24 +1062,23 @@ describe("RunsReplicationService (part 2/2)", () => { expect(batchFlushedEvents[0]?.payloadInserts.length).toBeGreaterThan(1); // Verify sorting order: organization_id, project_id, environment_id, created_at, run_id - // taskRunInserts are now arrays: [0]=environment_id, [1]=organization_id, [2]=project_id, [3]=run_id, [5]=created_at for (let i = 1; i < batchFlushedEvents[0]?.taskRunInserts.length; i++) { const prev = batchFlushedEvents[0]?.taskRunInserts[i - 1]; const curr = batchFlushedEvents[0]?.taskRunInserts[i]; const prevKey = [ - prev[1], // organization_id - prev[2], // project_id - prev[0], // environment_id - prev[5], // created_at - prev[3], // run_id + prev[TASK_RUN_INDEX.organization_id], + prev[TASK_RUN_INDEX.project_id], + prev[TASK_RUN_INDEX.environment_id], + prev[TASK_RUN_INDEX.created_at], + prev[TASK_RUN_INDEX.run_id], ]; const currKey = [ - curr[1], // organization_id - curr[2], // project_id - curr[0], // environment_id - curr[5], // created_at - curr[3], // run_id + curr[TASK_RUN_INDEX.organization_id], + curr[TASK_RUN_INDEX.project_id], + curr[TASK_RUN_INDEX.environment_id], + curr[TASK_RUN_INDEX.created_at], + curr[TASK_RUN_INDEX.run_id], ]; const keysAreEqual = prevKey.every((val, idx) => val === currKey[idx]); @@ -1109,9 +1108,7 @@ describe("RunsReplicationService (part 2/2)", () => { for (let i = 1; i < batchFlushedEvents[0]?.payloadInserts.length; i++) { const prev = batchFlushedEvents[0]?.payloadInserts[i - 1]; const curr = batchFlushedEvents[0]?.payloadInserts[i]; - // payloadInserts are now arrays, not objects - // Index 0 is run_id - expect(prev[0] <= curr[0]).toBeTruthy(); + expect(prev[PAYLOAD_INDEX.run_id] <= curr[PAYLOAD_INDEX.run_id]).toBeTruthy(); } await runsReplicationService.stop(); diff --git a/internal-packages/clickhouse/src/taskRuns.ts b/internal-packages/clickhouse/src/taskRuns.ts index 1757eae941..f24bd9e45d 100644 --- a/internal-packages/clickhouse/src/taskRuns.ts +++ b/internal-packages/clickhouse/src/taskRuns.ts @@ -101,71 +101,13 @@ export const TASK_RUN_COLUMNS = [ "max_duration_in_seconds", ] as const; -// Type-safe column indices derived from TASK_RUN_COLUMNS -// This ensures indices stay in sync with column order -export const TASK_RUN_INDEX = { - environment_id: 0, - organization_id: 1, - project_id: 2, - run_id: 3, - updated_at: 4, - created_at: 5, - status: 6, - environment_type: 7, - friendly_id: 8, - attempt: 9, - engine: 10, - task_identifier: 11, - queue: 12, - schedule_id: 13, - batch_id: 14, - completed_at: 15, - started_at: 16, - executed_at: 17, - delay_until: 18, - queued_at: 19, - expired_at: 20, - usage_duration_ms: 21, - cost_in_cents: 22, - base_cost_in_cents: 23, - output: 24, - error: 25, - tags: 26, - task_version: 27, - sdk_version: 28, - cli_version: 29, - machine_preset: 30, - root_run_id: 31, - parent_run_id: 32, - depth: 33, - span_id: 34, - trace_id: 35, - idempotency_key: 36, - expiration_ttl: 37, - is_test: 38, - _version: 39, - _is_deleted: 40, - concurrency_key: 41, - bulk_action_group_ids: 42, - worker_queue: 43, - max_duration_in_seconds: 44, -} as const satisfies Record<(typeof TASK_RUN_COLUMNS)[number], number>; - export type TaskRunColumnName = (typeof TASK_RUN_COLUMNS)[number]; -// Runtime assertion to verify TASK_RUN_INDEX matches TASK_RUN_COLUMNS order -// This will throw at module load time if there's a mismatch -(function verifyTaskRunColumnIndices() { - for (let i = 0; i < TASK_RUN_COLUMNS.length; i++) { - const column = TASK_RUN_COLUMNS[i]; - const index = TASK_RUN_INDEX[column]; - if (index !== i) { - throw new Error( - `TASK_RUN_INDEX mismatch: column "${column}" has index ${index} but should be ${i}` - ); - } - } -})(); +// Type-safe column indices generated from TASK_RUN_COLUMNS +// This ensures indices stay in sync with column order automatically +export const TASK_RUN_INDEX = Object.fromEntries( + TASK_RUN_COLUMNS.map((col, idx) => [col, idx]) +) as { readonly [K in TaskRunColumnName]: number }; export function insertTaskRunsCompactArrays(ch: ClickhouseWriter, settings?: ClickHouseSettings) { return ch.insertCompactRaw({ @@ -204,15 +146,13 @@ export type RawTaskRunPayloadV1 = z.infer; export const PAYLOAD_COLUMNS = ["run_id", "created_at", "payload"] as const; -// Type-safe column indices for payload columns -export const PAYLOAD_INDEX = { - run_id: 0, - created_at: 1, - payload: 2, -} as const satisfies Record<(typeof PAYLOAD_COLUMNS)[number], number>; - export type PayloadColumnName = (typeof PAYLOAD_COLUMNS)[number]; +// Type-safe column indices generated from PAYLOAD_COLUMNS +export const PAYLOAD_INDEX = Object.fromEntries( + PAYLOAD_COLUMNS.map((col, idx) => [col, idx]) +) as { readonly [K in PayloadColumnName]: number }; + /** * Type-safe tuple representing a task run insert array. * Order matches TASK_RUN_COLUMNS exactly. From c22c2cfb6a8467f175d7b83dbe97a96d5ea651f0 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Sun, 11 Jan 2026 11:44:19 +0000 Subject: [PATCH 13/17] Fix TypeScript errors in sort functions - Add type predicates to filter functions for proper type narrowing - Add type assertions for tuple index accesses in sort comparisons Co-Authored-By: Claude Opus 4.5 --- .../services/runsReplicationService.server.ts | 36 ++++++++++++------- 1 file changed, 24 insertions(+), 12 deletions(-) diff --git a/apps/webapp/app/services/runsReplicationService.server.ts b/apps/webapp/app/services/runsReplicationService.server.ts index c409b0621c..8dca8e7a85 100644 --- a/apps/webapp/app/services/runsReplicationService.server.ts +++ b/apps/webapp/app/services/runsReplicationService.server.ts @@ -576,32 +576,44 @@ export class RunsReplicationService { const taskRunInserts = preparedInserts .map(({ taskRunInsert }) => taskRunInsert) - .filter(Boolean) + .filter((x): x is TaskRunInsertArray => Boolean(x)) // batch inserts in clickhouse are more performant if the items // are pre-sorted by the primary key .sort((a, b) => { - if (a[TASK_RUN_INDEX.organization_id] !== b[TASK_RUN_INDEX.organization_id]) { - return a[TASK_RUN_INDEX.organization_id] < b[TASK_RUN_INDEX.organization_id] ? -1 : 1; + const aOrgId = a[TASK_RUN_INDEX.organization_id] as string; + const bOrgId = b[TASK_RUN_INDEX.organization_id] as string; + if (aOrgId !== bOrgId) { + return aOrgId < bOrgId ? -1 : 1; } - if (a[TASK_RUN_INDEX.project_id] !== b[TASK_RUN_INDEX.project_id]) { - return a[TASK_RUN_INDEX.project_id] < b[TASK_RUN_INDEX.project_id] ? -1 : 1; + const aProjId = a[TASK_RUN_INDEX.project_id] as string; + const bProjId = b[TASK_RUN_INDEX.project_id] as string; + if (aProjId !== bProjId) { + return aProjId < bProjId ? -1 : 1; } - if (a[TASK_RUN_INDEX.environment_id] !== b[TASK_RUN_INDEX.environment_id]) { - return a[TASK_RUN_INDEX.environment_id] < b[TASK_RUN_INDEX.environment_id] ? -1 : 1; + const aEnvId = a[TASK_RUN_INDEX.environment_id] as string; + const bEnvId = b[TASK_RUN_INDEX.environment_id] as string; + if (aEnvId !== bEnvId) { + return aEnvId < bEnvId ? -1 : 1; } - if (a[TASK_RUN_INDEX.created_at] !== b[TASK_RUN_INDEX.created_at]) { - return a[TASK_RUN_INDEX.created_at] - b[TASK_RUN_INDEX.created_at]; + const aCreatedAt = a[TASK_RUN_INDEX.created_at] as number; + const bCreatedAt = b[TASK_RUN_INDEX.created_at] as number; + if (aCreatedAt !== bCreatedAt) { + return aCreatedAt - bCreatedAt; } - return a[TASK_RUN_INDEX.run_id] < b[TASK_RUN_INDEX.run_id] ? -1 : 1; + const aRunId = a[TASK_RUN_INDEX.run_id] as string; + const bRunId = b[TASK_RUN_INDEX.run_id] as string; + return aRunId < bRunId ? -1 : 1; }); const payloadInserts = preparedInserts .map(({ payloadInsert }) => payloadInsert) - .filter(Boolean) + .filter((x): x is PayloadInsertArray => Boolean(x)) // batch inserts in clickhouse are more performant if the items // are pre-sorted by the primary key .sort((a, b) => { - return a[PAYLOAD_INDEX.run_id] < b[PAYLOAD_INDEX.run_id] ? -1 : 1; + const aRunId = a[PAYLOAD_INDEX.run_id] as string; + const bRunId = b[PAYLOAD_INDEX.run_id] as string; + return aRunId < bRunId ? -1 : 1; }); span.setAttribute("task_run_inserts", taskRunInserts.length); From 004e9860d74b3108c247c496bd256df9fcb66e70 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Sun, 11 Jan 2026 12:10:16 +0000 Subject: [PATCH 14/17] Fix sort comparators to return 0 for equal values Co-Authored-By: Claude Opus 4.5 --- apps/webapp/app/services/runsReplicationService.server.ts | 2 ++ 1 file changed, 2 insertions(+) diff --git a/apps/webapp/app/services/runsReplicationService.server.ts b/apps/webapp/app/services/runsReplicationService.server.ts index 8dca8e7a85..5127b479c0 100644 --- a/apps/webapp/app/services/runsReplicationService.server.ts +++ b/apps/webapp/app/services/runsReplicationService.server.ts @@ -602,6 +602,7 @@ export class RunsReplicationService { } const aRunId = a[TASK_RUN_INDEX.run_id] as string; const bRunId = b[TASK_RUN_INDEX.run_id] as string; + if (aRunId === bRunId) return 0; return aRunId < bRunId ? -1 : 1; }); @@ -613,6 +614,7 @@ export class RunsReplicationService { .sort((a, b) => { const aRunId = a[PAYLOAD_INDEX.run_id] as string; const bRunId = b[PAYLOAD_INDEX.run_id] as string; + if (aRunId === bRunId) return 0; return aRunId < bRunId ? -1 : 1; }); From 4d0e16ab588de2bf4f5cde1f39405feb2d24dc08 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Sun, 11 Jan 2026 12:43:34 +0000 Subject: [PATCH 15/17] Remove performance test harness Moving to a separate PR. Co-Authored-By: Claude Opus 4.5 --- apps/webapp/test/performance/README.md | 435 ------------- .../test/performance/clickhouse-mock.ts | 109 ---- apps/webapp/test/performance/config.ts | 163 ----- .../test/performance/consumer-runner.ts | 157 ----- apps/webapp/test/performance/consumer.ts | 318 --------- .../webapp/test/performance/data-generator.ts | 143 ----- apps/webapp/test/performance/harness.ts | 603 ------------------ .../test/performance/metrics-collector.ts | 217 ------- .../test/performance/producer-runner.ts | 116 ---- apps/webapp/test/performance/producer.ts | 191 ------ 10 files changed, 2452 deletions(-) delete mode 100644 apps/webapp/test/performance/README.md delete mode 100644 apps/webapp/test/performance/clickhouse-mock.ts delete mode 100644 apps/webapp/test/performance/config.ts delete mode 100644 apps/webapp/test/performance/consumer-runner.ts delete mode 100644 apps/webapp/test/performance/consumer.ts delete mode 100644 apps/webapp/test/performance/data-generator.ts delete mode 100644 apps/webapp/test/performance/harness.ts delete mode 100644 apps/webapp/test/performance/metrics-collector.ts delete mode 100644 apps/webapp/test/performance/producer-runner.ts delete mode 100644 apps/webapp/test/performance/producer.ts diff --git a/apps/webapp/test/performance/README.md b/apps/webapp/test/performance/README.md deleted file mode 100644 index 3eebbe5d9b..0000000000 --- a/apps/webapp/test/performance/README.md +++ /dev/null @@ -1,435 +0,0 @@ -# RunsReplicationService Performance Test Harness - -A comprehensive test harness for profiling the `RunsReplicationService` to identify CPU and event loop bottlenecks during high-throughput replication from PostgreSQL to ClickHouse. - -## Overview - -This harness helps you: - -- **Profile CPU usage** and identify hot code paths with Clinic.js flamegraphs -- **Measure event loop utilization** to find bottlenecks -- **Test at scale** from 1k to 20k+ records/second -- **Isolate bottlenecks** by testing with real or mocked ClickHouse -- **Track metrics** across multiple test phases - -## Architecture - -The harness uses a **multi-process architecture** to prevent CPU interference: - -``` -Main Orchestrator Process -โ”œโ”€โ”€ Producer Process (writes to PostgreSQL) -โ”‚ โ””โ”€โ”€ Reports metrics via IPC -โ”œโ”€โ”€ Consumer Process (RunsReplicationService) -โ”‚ โ””โ”€โ”€ Optional: Wrapped by Clinic.js for profiling -โ”‚ โ””โ”€โ”€ Reports metrics via IPC -โ””โ”€โ”€ Metrics Collector (aggregates data) -``` - -**Key Features:** - -- Producer and consumer run in **separate Node.js processes** -- Real PostgreSQL writes trigger actual WAL-based logical replication -- Configurable ClickHouse mode: real writes or mocked (CPU-only profiling) -- Clinic.js integration for Doctor (event loop) and Flame (flamegraph) profiling -- Phase-based testing with detailed metrics per phase - -## Quick Start - -### 1. Configure Local Credentials - -The harness uses `test/performance/.env.local` (git-ignored) for credentials: - -```bash -# PostgreSQL (local instance) -DATABASE_URL=postgresql://postgres:postgres@localhost:5432/postgres?schema=public - -# Redis (local instance) -REDIS_URL=redis://localhost:6379 - -# ClickHouse Cloud -CLICKHOUSE_URL=https://your-instance.clickhouse.cloud:8443?username=default&password=YOUR_PASSWORD -``` - -**Note:** `.env.local` is automatically created with current credentials. Edit if you need to change them. - -### 2. Basic CPU Profiling (Mock ClickHouse) - -Profile at 10k records/sec with mocked ClickHouse to isolate CPU bottlenecks: - -```bash -pnpm tsx scripts/profile-runs-replication.ts \ - --mock-clickhouse \ - --throughput 10000 \ - --duration 60 \ - --profile flame -``` - -### 3. Full Stack Profiling (Real ClickHouse) - -Test the complete stack including real ClickHouse Cloud writes: - -```bash -pnpm tsx scripts/profile-runs-replication.ts \ - --throughput 5000 \ - --duration 60 -``` - -**Note:** The harness automatically runs ClickHouse migrations from `internal-packages/clickhouse/schema/` when using real ClickHouse. - -### Multi-Phase Testing - -Create a config file for complex test scenarios: - -```json -{ - "phases": [ - { "name": "warmup", "durationSec": 30, "targetThroughput": 1000 }, - { "name": "baseline", "durationSec": 60, "targetThroughput": 5000 }, - { "name": "stress", "durationSec": 120, "targetThroughput": 10000 }, - { "name": "peak", "durationSec": 60, "targetThroughput": 15000 } - ], - "profiling": { "enabled": true, "tool": "flame" }, - "consumer": { - "useMockClickhouse": true, - "flushBatchSize": 50, - "flushIntervalMs": 100, - "maxFlushConcurrency": 100 - } -} -``` - -Run with config file: - -```bash -pnpm tsx scripts/profile-runs-replication.ts --config config.json -``` - -## CLI Options - -``` -Usage: profile-runs-replication [options] - -Options: - -c, --config Config file path (JSON) - -t, --throughput Target throughput (records/sec) (default: 5000) - -d, --duration Test duration per phase (seconds) (default: 60) - --mock-clickhouse Use mock ClickHouse (CPU-only profiling) - --profile Profiling tool: doctor, flame, both, none (default: none) - --output Output directory (default: ./profiling-results) - -v, --verbose Verbose logging - -h, --help Display help -``` - -### Database Setup - -The harness creates a **separate database** (`trigger_profiling`) on your local PostgreSQL server: - -- โœ… Isolated from your main development database -- โœ… Schema copied from main database using `pg_dump` -- โœ… Preserved after tests for inspection -- โœ… Reuses existing org/project/environment records -- โš ๏ธ Requires local PostgreSQL with logical replication enabled (`wal_level = logical`) - -To clean up: `DROP DATABASE trigger_profiling;` - -## Configuration - -### Test Phases - -Define multiple test phases with different throughput targets: - -```typescript -{ - "phases": [ - { - "name": "warmup", - "durationSec": 30, - "targetThroughput": 1000 - }, - { - "name": "sustained", - "durationSec": 120, - "targetThroughput": 10000 - } - ] -} -``` - -### Producer Configuration - -```typescript -{ - "producer": { - "targetThroughput": 5000, // records/sec - "insertUpdateRatio": 0.8, // 80% inserts, 20% updates - "batchSize": 100, // records per batch write - "payloadSizeKB": 1 // average payload size - } -} -``` - -### Consumer Configuration - -```typescript -{ - "consumer": { - "flushBatchSize": 50, // batch size for ClickHouse writes - "flushIntervalMs": 100, // flush interval - "maxFlushConcurrency": 100, // concurrent flush operations - "useMockClickhouse": false, // true for CPU-only profiling - "mockClickhouseDelay": 0 // simulated network delay (ms) - } -} -``` - -### Profiling Configuration - -```typescript -{ - "profiling": { - "enabled": true, - "tool": "flame", // doctor, flame, both, none - "outputDir": "./profiling-results" - } -} -``` - -## Output and Metrics - -### Metrics Collected - -For each test phase: - -- **Producer Metrics:** - - Total inserts and updates - - Actual throughput (records/sec) - - Write latency (p50, p95, p99) - - Error count - -- **Consumer Metrics:** - - Batches flushed - - Records consumed - - Consumer throughput - - Replication lag (p50, p95, p99) - - Event loop utilization - - Heap memory usage - -### Output Files - -``` -profiling-results/ -โ””โ”€โ”€ 2026-01-09/ - โ”œโ”€โ”€ metrics.json # Detailed metrics for all phases - โ”œโ”€โ”€ .clinic-flame/ # Flamegraph (if enabled) - โ”‚ โ””โ”€โ”€ index.html - โ””โ”€โ”€ .clinic-doctor/ # Event loop analysis (if enabled) - โ””โ”€โ”€ index.html -``` - -### Viewing Profiling Results - -**Flamegraph (CPU hotspots):** -```bash -open profiling-results/2026-01-09/.clinic-flame/index.html -``` - -**Doctor (Event loop analysis):** -```bash -open profiling-results/2026-01-09/.clinic-doctor/index.html -``` - -## Common Use Cases - -### 1. Identify CPU Bottlenecks - -Use mocked ClickHouse to eliminate I/O overhead: - -```bash -pnpm tsx scripts/profile-runs-replication.ts \ - --mock-clickhouse \ - --throughput 10000 \ - --profile flame -``` - -**What to look for in flamegraph:** -- Hot functions consuming most CPU time -- JSON parsing overhead -- LSN conversion operations -- Array sorting/merging operations - -### 2. Measure Event Loop Saturation - -Use Clinic.js Doctor to analyze event loop health: - -```bash -pnpm tsx scripts/profile-runs-replication.ts \ - --mock-clickhouse \ - --throughput 15000 \ - --profile doctor -``` - -**What to look for in Doctor analysis:** -- Event loop delay spikes -- I/O vs CPU time breakdown -- Event loop utilization percentage - -### 3. Compare Configuration Changes - -Test different batch sizes to find optimal configuration: - -```bash -# Test with batch size 50 -pnpm tsx scripts/profile-runs-replication.ts \ - --throughput 8000 -d 60 --output ./results/batch-50 - -# Edit config and test with batch size 100 -pnpm tsx scripts/profile-runs-replication.ts \ - --throughput 8000 -d 60 --output ./results/batch-100 -``` - -### 4. Stress Test to Find Breaking Point - -Incrementally increase throughput to find maximum capacity: - -```json -{ - "phases": [ - { "name": "5k", "durationSec": 60, "targetThroughput": 5000 }, - { "name": "10k", "durationSec": 60, "targetThroughput": 10000 }, - { "name": "15k", "durationSec": 60, "targetThroughput": 15000 }, - { "name": "20k", "durationSec": 60, "targetThroughput": 20000 } - ] -} -``` - -### 5. Compare I/O vs CPU Overhead - -Run twice - once with real ClickHouse, once with mock: - -```bash -# With mock (CPU-only) -pnpm tsx scripts/profile-runs-replication.ts \ - --mock-clickhouse --throughput 8000 -d 60 \ - --output ./results/cpu-only - -# With real ClickHouse Cloud (requires CLICKHOUSE_URL in .env.local) -pnpm tsx scripts/profile-runs-replication.ts \ - --throughput 8000 -d 60 \ - --output ./results/full-stack -``` - -Compare event loop utilization to understand I/O impact. - -## Prerequisites - -### PostgreSQL Setup - -Ensure your local PostgreSQL has logical replication enabled: - -**1. Check your postgresql.conf:** -```ini -wal_level = logical -``` - -**2. Restart PostgreSQL if you changed the config:** -```bash -# macOS (Homebrew) -brew services restart postgresql - -# Linux -sudo systemctl restart postgresql -``` - -**3. Verify .env.local is configured:** -The harness loads credentials from `test/performance/.env.local`: -```bash -DATABASE_URL=postgresql://postgres:postgres@localhost:5432/postgres?schema=public -REDIS_URL=redis://localhost:6379 -CLICKHOUSE_URL=https://your-instance.clickhouse.cloud:8443?username=default&password=YOUR_PASSWORD -``` - -**4. The harness will automatically:** -- Create `trigger_profiling` database (separate from main DB) -- Copy schema from main database using `pg_dump` -- Configure REPLICA IDENTITY FULL on TaskRun table -- Create replication slot (`profiling_slot`) -- Create publication (`profiling_publication`) -- Run ClickHouse migrations (when using real ClickHouse) -- Reuse or create test org/project/environment - -## Troubleshooting - -### Producer/Consumer Out of Sync - -If consumer can't keep up with producer: - -1. Increase `flushBatchSize` for better throughput -2. Increase `maxFlushConcurrency` if ClickHouse can handle it -3. Reduce `targetThroughput` to sustainable level - -### Docker Container Startup Failures - -Ensure Docker is running and has sufficient resources: - -```bash -docker info # Check Docker status -``` - -Increase Docker memory/CPU limits if needed. - -### Process Not Exiting Cleanly - -If processes hang during shutdown: - -1. Check for unhandled promises -2. Ensure all intervals/timeouts are cleared -3. Force kill with Ctrl+C (process will be killed automatically after 30s) - -### High Memory Usage - -If heap usage grows excessively: - -1. Reduce payload size: `payloadSizeKB: 0.5` -2. Reduce batch sizes -3. Check for memory leaks in flamegraph (repeated allocations) - -## Architecture Details - -### Producer Process - -- Runs in isolated Node.js process -- Writes TaskRun records to PostgreSQL using Prisma -- Throttles to maintain exact target throughput -- Tracks insert/update latencies -- Reports metrics to orchestrator via IPC - -### Consumer Process - -- Runs in isolated Node.js process (optionally wrapped by Clinic.js) -- Executes RunsReplicationService -- Consumes PostgreSQL logical replication stream -- Writes to ClickHouse (real or mocked) -- Reports batch flush events and metrics via IPC - -### Orchestrator Process - -- Manages Docker containers (PostgreSQL, Redis, ClickHouse) -- Spawns producer and consumer processes -- Coordinates test phases -- Aggregates metrics -- Generates reports - -## Next Steps - -After running profiling: - -1. **Analyze flamegraphs** to identify top CPU consumers -2. **Check event loop utilization** - target <80% for headroom -3. **Optimize identified bottlenecks** in the code -4. **Re-run harness** to validate improvements -5. **Document findings** and optimal configuration - -## Examples from Plan - -See `/Users/eric/.claude/plans/elegant-humming-moler.md` for the complete implementation plan and additional context. diff --git a/apps/webapp/test/performance/clickhouse-mock.ts b/apps/webapp/test/performance/clickhouse-mock.ts deleted file mode 100644 index b98344c26e..0000000000 --- a/apps/webapp/test/performance/clickhouse-mock.ts +++ /dev/null @@ -1,109 +0,0 @@ -import type { ClickHouse, TaskRunInsertArray, PayloadInsertArray } from "@internal/clickhouse"; - -// Minimal InsertResult type to avoid dependency on @clickhouse/client -interface InsertResult { - executed: boolean; - query_id: string; - summary?: { - read_rows: string; - read_bytes: string; - written_rows: string; - written_bytes: string; - total_rows_to_read: string; - result_rows: string; - result_bytes: string; - elapsed_ns: string; - }; - response_headers: Record; -} - -/** - * Mock ClickHouse client for CPU-only profiling. - * Implements the minimal interface needed by RunsReplicationService - * without actually writing to ClickHouse. - */ -export class MockClickHouse { - private insertCount = 0; - private payloadInsertCount = 0; - - constructor(private readonly insertDelayMs: number = 0) {} - - taskRuns = { - insertCompactArrays: async ( - rows: TaskRunInsertArray[], - options?: any - ): Promise<[Error | null, InsertResult | null]> => { - if (this.insertDelayMs > 0) { - await new Promise((resolve) => setTimeout(resolve, this.insertDelayMs)); - } - - this.insertCount += rows.length; - - return [ - null, - { - executed: true, - query_id: "mock", - summary: { - read_rows: "0", - read_bytes: "0", - written_rows: String(rows.length), - written_bytes: "0", - total_rows_to_read: "0", - result_rows: "0", - result_bytes: "0", - elapsed_ns: "0", - }, - response_headers: {}, - }, - ]; - }, - - insertPayloadsCompactArrays: async ( - rows: PayloadInsertArray[], - options?: any - ): Promise<[Error | null, InsertResult | null]> => { - if (this.insertDelayMs > 0) { - await new Promise((resolve) => setTimeout(resolve, this.insertDelayMs)); - } - - this.payloadInsertCount += rows.length; - - return [ - null, - { - executed: true, - query_id: "mock", - summary: { - read_rows: "0", - read_bytes: "0", - written_rows: String(rows.length), - written_bytes: "0", - total_rows_to_read: "0", - result_rows: "0", - result_bytes: "0", - elapsed_ns: "0", - }, - response_headers: {}, - }, - ]; - }, - }; - - getStats() { - return { - totalInserts: this.insertCount, - totalPayloadInserts: this.payloadInsertCount, - }; - } - - reset() { - this.insertCount = 0; - this.payloadInsertCount = 0; - } -} - -// Type assertion helper for use with RunsReplicationService -export function asMockClickHouse(mock: MockClickHouse): Pick { - return mock as unknown as Pick; -} diff --git a/apps/webapp/test/performance/config.ts b/apps/webapp/test/performance/config.ts deleted file mode 100644 index e99a6f8bd7..0000000000 --- a/apps/webapp/test/performance/config.ts +++ /dev/null @@ -1,163 +0,0 @@ -import { RedisOptions } from "ioredis"; -import type { RuntimeEnvironmentType } from "@trigger.dev/database"; -import { config as loadEnv } from "dotenv"; -import path from "path"; - -// Load local environment variables for profiling (override existing vars) -loadEnv({ path: path.join(__dirname, ".env.local"), override: true }); - -export interface TestPhase { - name: string; - durationSec: number; - targetThroughput: number; // records/sec -} - -export interface ProducerConfig { - enabled: boolean; - workerCount: number; // Number of parallel producer processes - workerId?: string; // Unique identifier for this specific worker - targetThroughput: number; - insertUpdateRatio: number; // 0.0-1.0, e.g. 0.8 = 80% inserts, 20% updates - batchSize: number; - payloadSizeKB: number; - databaseUrl: string; - organizationId: string; - projectId: string; - runtimeEnvironmentId: string; - environmentType: RuntimeEnvironmentType; -} - -export interface ConsumerConfig { - flushBatchSize: number; - flushIntervalMs: number; - maxFlushConcurrency: number; - useMockClickhouse: boolean; - mockClickhouseDelay: number; // milliseconds - pgConnectionUrl: string; - clickhouseUrl?: string; - redisOptions: RedisOptions; - slotName: string; - publicationName: string; - outputDir?: string; // For shutdown signal file -} - -export interface ProfilingConfig { - enabled: boolean; - tool: "doctor" | "flame" | "both" | "none"; - outputDir: string; -} - -export interface OutputConfig { - metricsFile: string; - verbose: boolean; -} - -export interface InfrastructureConfig { - databaseUrl: string; - profilingDatabaseName?: string; // Defaults to "trigger_profiling" - redisUrl?: string; - clickhouseUrl?: string; -} - -export interface HarnessConfig { - runName: string; // Short identifier for this run (e.g. "baseline", "optimized-v1") - runDescription?: string; // Optional longer description of what this run is testing - phases: TestPhase[]; - producer: ProducerConfig; - consumer: ConsumerConfig; - profiling: ProfilingConfig; - output: OutputConfig; - infrastructure: InfrastructureConfig; -} - -export function getDefaultConfig(): Partial { - return { - runName: "default", - runDescription: undefined, - phases: [ - { - name: "warmup", - durationSec: 30, - targetThroughput: 1000, - }, - { - name: "baseline", - durationSec: 60, - targetThroughput: 5000, - }, - ], - producer: { - enabled: true, - workerCount: 1, - targetThroughput: 5000, - insertUpdateRatio: 0.8, - batchSize: 500, - payloadSizeKB: 1, - databaseUrl: "", - organizationId: "", - projectId: "", - runtimeEnvironmentId: "", - environmentType: "DEVELOPMENT", - }, - consumer: { - flushBatchSize: 50, - flushIntervalMs: 100, - maxFlushConcurrency: 100, - useMockClickhouse: false, - mockClickhouseDelay: 0, - pgConnectionUrl: "", - slotName: "profiling_slot", - publicationName: "profiling_publication", - redisOptions: {}, - }, - profiling: { - enabled: false, - tool: "none", - outputDir: "./profiling-results", - }, - output: { - metricsFile: "metrics.json", - verbose: false, - }, - infrastructure: { - databaseUrl: process.env.DATABASE_URL || "postgresql://postgres:postgres@localhost:5432/postgres", - profilingDatabaseName: "trigger_profiling", - redisUrl: process.env.REDIS_URL || "redis://localhost:6379", - clickhouseUrl: process.env.CLICKHOUSE_URL, - }, - }; -} - -export interface ProducerMetrics { - workerId?: string; // Unique identifier for this producer worker - totalInserts: number; - totalUpdates: number; - actualThroughput: number; - errors: number; - latencies: number[]; // for calculating percentiles -} - -export interface PhaseMetrics { - phase: string; - durationMs: number; - - // Producer - recordsProduced: number; - producerThroughput: number; - - // Consumer - batchesFlushed: number; - recordsConsumed: number; - consumerThroughput: number; - replicationLagP50: number; - replicationLagP95: number; - replicationLagP99: number; - - // Performance - eventLoopUtilization: number; - flushDurationP50: number; - - // Memory - heapUsedMB: number; - heapTotalMB: number; -} diff --git a/apps/webapp/test/performance/consumer-runner.ts b/apps/webapp/test/performance/consumer-runner.ts deleted file mode 100644 index 0bad856453..0000000000 --- a/apps/webapp/test/performance/consumer-runner.ts +++ /dev/null @@ -1,157 +0,0 @@ -#!/usr/bin/env tsx - -import type { ClickHouse } from "@internal/clickhouse"; -import { RunsReplicationService } from "~/services/runsReplicationService.server"; -import { MockClickHouse, asMockClickHouse } from "./clickhouse-mock"; -import type { ConsumerConfig } from "./config"; -import fs from "fs"; -import path from "path"; - -async function main() { - const hasIPC = !!process.send; - - if (!hasIPC) { - console.log( - "Warning: IPC not available (likely running under profiler) - metrics will not be sent to parent" - ); - } - - // Parse configuration from environment variable - const config = JSON.parse(process.env.CONSUMER_CONFIG!) as ConsumerConfig; - - // Create shutdown signal file path - const shutdownFilePath = path.join(config.outputDir || "/tmp", ".shutdown-signal"); - - console.log("Consumer process starting with config:", { - useMockClickhouse: config.useMockClickhouse, - flushBatchSize: config.flushBatchSize, - flushIntervalMs: config.flushIntervalMs, - maxFlushConcurrency: config.maxFlushConcurrency, - }); - - // Create ClickHouse client (real or mocked) - let clickhouse: Pick; - if (config.useMockClickhouse) { - clickhouse = asMockClickHouse(new MockClickHouse(config.mockClickhouseDelay)); - } else { - // Use dynamic import to avoid module resolution issues with tsx - const { ClickHouse } = await import("@internal/clickhouse"); - clickhouse = new ClickHouse({ - url: config.clickhouseUrl!, - name: "runs-replication-profiling", - compression: { - request: true, - }, - logLevel: "info", - }); - } - - // Create replication service - const service = new RunsReplicationService({ - clickhouse: clickhouse as ClickHouse, - pgConnectionUrl: config.pgConnectionUrl, - serviceName: "runs-replication-profiling", - slotName: config.slotName, - publicationName: config.publicationName, - redisOptions: config.redisOptions, - flushBatchSize: config.flushBatchSize, - flushIntervalMs: config.flushIntervalMs, - maxFlushConcurrency: config.maxFlushConcurrency, - logLevel: "error", // Only log errors to reduce CPU overhead - }); - - console.log("Consumer: Starting RunsReplicationService"); - await service.start(); - - // Send batch flush events to parent via IPC (if available) - if (hasIPC) { - service.events.on("batchFlushed", (data) => { - process.send!({ - type: "batchFlushed", - data, - }); - }); - } - - // Watch for shutdown signal file (works even when IPC is unavailable) - const shutdownCheckInterval = setInterval(() => { - if (fs.existsSync(shutdownFilePath)) { - console.log("Consumer: Shutdown signal file detected, exiting..."); - clearInterval(shutdownCheckInterval); - clearInterval(metricsInterval); - // Clean up the signal file - try { - fs.unlinkSync(shutdownFilePath); - } catch (e) {} - process.exit(0); - } - }, 500); - - // Send periodic metrics to parent (if IPC available) - const metricsInterval = setInterval(() => { - const memUsage = process.memoryUsage(); - const { eventLoopUtilization } = require("perf_hooks").performance; - const elu = eventLoopUtilization ? eventLoopUtilization() : { utilization: 0 }; - - if (hasIPC) { - process.send!({ - type: "metrics", - data: { - heapUsed: memUsage.heapUsed, - heapTotal: memUsage.heapTotal, - rss: memUsage.rss, - eventLoopUtilization: elu.utilization, - }, - }); - } - }, 1000); - - // Listen for shutdown signal from parent (if IPC available, for non-profiling mode) - if (hasIPC) { - process.on("message", async (msg: any) => { - if (msg.type === "shutdown") { - console.log("Consumer: Received IPC shutdown message"); - clearInterval(shutdownCheckInterval); - clearInterval(metricsInterval); - process.exit(0); - } - }); - } - - // Handle uncaught errors - process.on("uncaughtException", (error) => { - console.error("Uncaught exception in consumer:", error); - if (hasIPC) { - process.send!({ - type: "error", - error: error.message, - }); - } - process.exit(1); - }); - - process.on("unhandledRejection", (reason) => { - console.error("Unhandled rejection in consumer:", reason); - if (hasIPC) { - process.send!({ - type: "error", - error: String(reason), - }); - } - process.exit(1); - }); - - // Signal ready to parent (if IPC available) - console.log("Consumer process ready"); - if (hasIPC) { - process.send!({ type: "ready" }); - } else { - // When profiling without IPC, just run indefinitely - console.log("Running in profiling mode - press Ctrl+C to stop"); - } -} - -main().catch((error) => { - console.error("Fatal error in consumer process:", error); - process.exit(1); -}); diff --git a/apps/webapp/test/performance/consumer.ts b/apps/webapp/test/performance/consumer.ts deleted file mode 100644 index 88452e7f3b..0000000000 --- a/apps/webapp/test/performance/consumer.ts +++ /dev/null @@ -1,318 +0,0 @@ -import { ChildProcess, spawn } from "child_process"; -import path from "path"; -import fs from "fs"; -import type { ConsumerConfig, ProfilingConfig } from "./config"; - -interface ConsumerMetrics { - heapUsed: number; - heapTotal: number; - rss: number; - eventLoopUtilization: number; -} - -interface BatchFlushedEvent { - flushId: string; - taskRunInserts: any[]; - payloadInserts: any[]; -} - -export class ConsumerProcessManager { - private process: ChildProcess | null = null; - private ready = false; - private onMetrics?: (metrics: ConsumerMetrics) => void; - private onBatchFlushed?: (event: BatchFlushedEvent) => void; - private onError?: (error: string) => void; - - constructor( - private readonly config: ConsumerConfig, - private readonly profiling: ProfilingConfig - ) {} - - async start(): Promise { - const args = this.profiling.enabled && this.profiling.tool !== "none" - ? this.buildClinicArgs() - : this.buildDirectArgs(); - - console.log("Starting consumer process:", args.join(" ")); - - const isProfiling = this.profiling.enabled && this.profiling.tool !== "none"; - - this.process = spawn(args[0], args.slice(1), { - cwd: path.join(__dirname, "../.."), // Run from webapp directory - env: { - ...process.env, - CONSUMER_CONFIG: JSON.stringify(this.config), - }, - stdio: isProfiling - ? ["ignore", "pipe", "pipe", "ipc"] // Capture stdout/stderr when profiling to detect readiness - : ["ignore", "inherit", "inherit", "ipc"], - }); - - // When profiling, watch stdout for readiness message since IPC might not work - if (isProfiling && this.process.stdout) { - this.process.stdout.on("data", (data: Buffer) => { - const output = data.toString(); - process.stdout.write(output); // Still show output - if (output.includes("Consumer process ready")) { - this.ready = true; - console.log("Consumer process is ready (detected from stdout)"); - } - }); - } - - if (isProfiling && this.process.stderr) { - this.process.stderr.on("data", (data: Buffer) => { - process.stderr.write(data.toString()); // Show stderr - }); - } - - // Handle messages from child process (works when IPC is available) - this.process.on("message", (msg: any) => { - if (msg.type === "ready") { - this.ready = true; - console.log("Consumer process is ready"); - } else if (msg.type === "metrics" && this.onMetrics) { - this.onMetrics(msg.data); - } else if (msg.type === "batchFlushed" && this.onBatchFlushed) { - this.onBatchFlushed(msg.data); - } else if (msg.type === "error" && this.onError) { - this.onError(msg.error); - } - }); - - this.process.on("error", (error) => { - console.error("Consumer process error:", error); - if (this.onError) { - this.onError(error.message); - } - }); - - this.process.on("exit", (code, signal) => { - console.log(`Consumer process exited with code ${code}, signal ${signal}`); - }); - - // Wait for ready signal - await this.waitForReady(); - } - - async stop(): Promise { - if (!this.process) { - return; - } - - console.log("Stopping consumer process"); - - const isProfiling = this.profiling.enabled && this.profiling.tool !== "none"; - - if (isProfiling) { - // When profiling, IPC doesn't work - use a shutdown signal file instead - const outputDir = this.config.outputDir || "/tmp"; - const shutdownFilePath = path.join(outputDir, ".shutdown-signal"); - console.log("Creating shutdown signal file for consumer (profiling mode)"); - - // Ensure directory exists - if (!fs.existsSync(outputDir)) { - fs.mkdirSync(outputDir, { recursive: true }); - } - - fs.writeFileSync(shutdownFilePath, "shutdown"); - } else { - // For non-profiling runs, use IPC message - try { - this.process.send({ type: "shutdown" }); - } catch (error) { - console.warn("Could not send shutdown message, process may have already exited"); - } - } - - // Wait for process to exit - await new Promise((resolve) => { - // With shutdown signal file, consumer-runner should exit within a few seconds - // With --collect-only, Clinic.js then quickly packages the data and exits - const timeoutMs = isProfiling ? 15000 : 30000; - - const timeout = setTimeout(() => { - console.warn(`Consumer process did not exit after ${timeoutMs}ms, killing`); - this.process?.kill("SIGKILL"); - resolve(); - }, timeoutMs); - - this.process?.on("exit", (code, signal) => { - clearTimeout(timeout); - console.log(`Consumer process exited with code ${code}, signal ${signal}`); - resolve(); - }); - }); - - this.process = null; - this.ready = false; - } - - setOnMetrics(callback: (metrics: ConsumerMetrics) => void): void { - this.onMetrics = callback; - } - - setOnBatchFlushed(callback: (event: BatchFlushedEvent) => void): void { - this.onBatchFlushed = callback; - } - - setOnError(callback: (error: string) => void): void { - this.onError = callback; - } - - isReady(): boolean { - return this.ready; - } - - private buildDirectArgs(): string[] { - const runnerPath = path.join(__dirname, "consumer-runner.ts"); - return ["tsx", runnerPath]; - } - - private buildClinicArgs(): string[] { - const tool = this.profiling.tool === "both" ? "doctor" : this.profiling.tool; - const runnerPath = path.join(__dirname, "consumer-runner.ts"); - - // Use clinic from node_modules/.bin directly (more reliable than pnpm exec) - const clinicPath = path.join(__dirname, "../../node_modules/.bin/clinic"); - - // Point --dest to the output directory itself - // Clinic.js will create PID.clinic-flame inside this directory - const destPath = path.resolve(this.profiling.outputDir); - - // Clinic.js requires node, so use node with tsx/register loader - const args = [ - clinicPath, - tool, - "--collect-only", // Only collect data, don't generate visualization immediately - "--open=false", // Don't try to open in browser - "--dest", - destPath, - "--", - "node", - "--import", - "tsx", - runnerPath, - ]; - - console.log(`Clinic.js will save profiling data to: ${destPath}`); - - return args; - } - - private async waitForReady(timeoutMs: number = 30000): Promise { - const start = Date.now(); - while (!this.ready) { - if (Date.now() - start > timeoutMs) { - throw new Error("Consumer process did not become ready within timeout"); - } - await new Promise((resolve) => setTimeout(resolve, 100)); - } - } -} - -export class ProducerProcessManager { - private process: ChildProcess | null = null; - private ready = false; - private onMetrics?: (metrics: any) => void; - private onError?: (error: string) => void; - - constructor(private readonly config: any) {} - - async start(): Promise { - const runnerPath = path.join(__dirname, "producer-runner.ts"); - const args = ["tsx", runnerPath]; - - console.log("Starting producer process:", args.join(" ")); - - this.process = spawn(args[0], args.slice(1), { - env: { - ...process.env, - PRODUCER_CONFIG: JSON.stringify(this.config), - }, - stdio: ["ignore", "inherit", "inherit", "ipc"], - }); - - this.process.on("message", (msg: any) => { - if (msg.type === "ready") { - this.ready = true; - console.log("Producer process is ready"); - } else if (msg.type === "metrics" && this.onMetrics) { - this.onMetrics(msg.data); - } else if (msg.type === "started") { - console.log("Producer has started production"); - } else if (msg.type === "stopped") { - console.log("Producer has stopped production"); - } else if (msg.type === "error" && this.onError) { - this.onError(msg.error); - } - }); - - this.process.on("error", (error) => { - console.error("Producer process error:", error); - if (this.onError) { - this.onError(error.message); - } - }); - - this.process.on("exit", (code, signal) => { - console.log(`Producer process exited with code ${code}, signal ${signal}`); - }); - - await this.waitForReady(); - } - - async stop(): Promise { - if (!this.process) { - return; - } - - console.log("Stopping producer process"); - this.process.send({ type: "shutdown" }); - - await new Promise((resolve) => { - const timeout = setTimeout(() => { - console.warn("Producer process did not exit gracefully, killing"); - this.process?.kill("SIGKILL"); - resolve(); - }, 10000); - - this.process?.on("exit", () => { - clearTimeout(timeout); - resolve(); - }); - }); - - this.process = null; - this.ready = false; - } - - send(message: any): void { - if (!this.process) { - throw new Error("Producer process not started"); - } - this.process.send(message); - } - - setOnMetrics(callback: (metrics: any) => void): void { - this.onMetrics = callback; - } - - setOnError(callback: (error: string) => void): void { - this.onError = callback; - } - - isReady(): boolean { - return this.ready; - } - - private async waitForReady(timeoutMs: number = 30000): Promise { - const start = Date.now(); - while (!this.ready) { - if (Date.now() - start > timeoutMs) { - throw new Error("Producer process did not become ready within timeout"); - } - await new Promise((resolve) => setTimeout(resolve, 100)); - } - } -} diff --git a/apps/webapp/test/performance/data-generator.ts b/apps/webapp/test/performance/data-generator.ts deleted file mode 100644 index f2e19eb60d..0000000000 --- a/apps/webapp/test/performance/data-generator.ts +++ /dev/null @@ -1,143 +0,0 @@ -import { Prisma, RuntimeEnvironmentType, TaskRunStatus } from "@trigger.dev/database"; -import { nanoid } from "nanoid"; -import superjson from "superjson"; - -export interface DataGeneratorOptions { - organizationId: string; - projectId: string; - runtimeEnvironmentId: string; - environmentType: RuntimeEnvironmentType; - payloadSizeKB: number; - includeComplexPayloads?: boolean; -} - -export class TaskRunDataGenerator { - private readonly taskIdentifiers = [ - "send-email", - "process-payment", - "generate-report", - "sync-data", - "backup-database", - "send-notification", - "process-image", - "validate-user", - "cleanup-temp-files", - "update-analytics", - ]; - - private readonly queues = ["default", "high-priority", "low-priority", "background"]; - - private readonly workerQueues = ["main", "worker-1", "worker-2", "worker-3"]; - - private readonly statuses: TaskRunStatus[] = [ - "PENDING", - "EXECUTING", - "COMPLETED_SUCCESSFULLY", - "COMPLETED_WITH_ERRORS", - ]; - - private counter = 0; - - constructor(private readonly options: DataGeneratorOptions) {} - - generateBatch(count: number): Prisma.TaskRunCreateManyInput[] { - const batch: Prisma.TaskRunCreateManyInput[] = []; - for (let i = 0; i < count; i++) { - batch.push(this.generateInsert()); - } - return batch; - } - - generateInsert(): Prisma.TaskRunCreateManyInput { - this.counter++; - const id = nanoid(); - const friendlyId = `run_${this.counter}_${nanoid(8)}`; - const taskIdentifier = - this.taskIdentifiers[Math.floor(Math.random() * this.taskIdentifiers.length)]; - const queue = this.queues[Math.floor(Math.random() * this.queues.length)]; - const workerQueue = this.workerQueues[Math.floor(Math.random() * this.workerQueues.length)]; - - const payload = this.generatePayload(); - const payloadType = - this.options.includeComplexPayloads && Math.random() > 0.7 - ? "application/super+json" - : "application/json"; - - return { - id, - friendlyId, - taskIdentifier, - payload: - payloadType === "application/super+json" - ? superjson.stringify(payload) - : JSON.stringify(payload), - payloadType, - traceId: nanoid(), - spanId: nanoid(), - queue, - workerQueue, - runtimeEnvironmentId: this.options.runtimeEnvironmentId, - projectId: this.options.projectId, - organizationId: this.options.organizationId, - environmentType: this.options.environmentType, - status: "PENDING", - engine: "V2", - }; - } - - generateUpdate(runId: string): Prisma.TaskRunUpdateInput { - const status = this.statuses[Math.floor(Math.random() * this.statuses.length)]; - - const update: Prisma.TaskRunUpdateInput = { - status, - updatedAt: new Date(), - }; - - // Add timestamps based on status - if (status === "EXECUTING") { - update.startedAt = new Date(); - update.executedAt = new Date(); - } else if (status === "COMPLETED_SUCCESSFULLY") { - update.completedAt = new Date(); - update.usageDurationMs = Math.floor(Math.random() * 10000) + 1000; - } else if (status === "COMPLETED_WITH_ERRORS") { - update.completedAt = new Date(); - update.usageDurationMs = Math.floor(Math.random() * 10000) + 1000; - } - - return update; - } - - private generatePayload(): any { - const targetBytes = this.options.payloadSizeKB * 1024; - const basePayload: any = { - taskId: nanoid(), - timestamp: new Date().toISOString(), - userId: `user_${Math.floor(Math.random() * 10000)}`, - }; - - // Pad the payload to reach target size (do this before adding complex types that can't be JSON.stringified) - const currentSize = JSON.stringify(basePayload).length; - if (currentSize < targetBytes) { - const paddingSize = targetBytes - currentSize; - basePayload.padding = "x".repeat(paddingSize); - } - - if (this.options.includeComplexPayloads && Math.random() > 0.5) { - // Add complex types for superjson (after padding calculation) - basePayload.bigint = BigInt(Math.floor(Math.random() * 1000000)); - basePayload.date = new Date(); - basePayload.map = new Map([ - ["key1", "value1"], - ["key2", "value2"], - ]); - basePayload.set = new Set([1, 2, 3, 4, 5]); - } - - return basePayload; - } - - reset(): void { - this.counter = 0; - } -} diff --git a/apps/webapp/test/performance/harness.ts b/apps/webapp/test/performance/harness.ts deleted file mode 100644 index 1cf52b4aba..0000000000 --- a/apps/webapp/test/performance/harness.ts +++ /dev/null @@ -1,603 +0,0 @@ -import { PrismaClient } from "@trigger.dev/database"; -import { ConsumerProcessManager, ProducerProcessManager } from "./consumer"; -import { MetricsCollector } from "./metrics-collector"; -import type { HarnessConfig, PhaseMetrics } from "./config"; -import { execSync } from "child_process"; -import fs from "fs/promises"; -import path from "path"; - -export class RunsReplicationHarness { - private prisma: PrismaClient | null = null; - private adminPrisma: PrismaClient | null = null; - private producerProcesses: ProducerProcessManager[] = []; - private consumerProcess: ConsumerProcessManager | null = null; - private metricsCollector: MetricsCollector; - - private organizationId: string = ""; - private projectId: string = ""; - private runtimeEnvironmentId: string = ""; - private profilingDatabaseUrl: string = ""; - - constructor(private readonly config: HarnessConfig) { - this.metricsCollector = new MetricsCollector(); - } - - async setup(): Promise { - console.log("\n๐Ÿš€ Setting up profiling database...\n"); - - const dbName = this.config.infrastructure.profilingDatabaseName || "trigger_profiling"; - - // 1. Create profiling database - console.log(`Creating database: ${dbName}...`); - await this.createProfilingDatabase(dbName); - - // 2. Build profiling database URL - this.profilingDatabaseUrl = this.buildProfilingDatabaseUrl( - this.config.infrastructure.databaseUrl, - dbName - ); - console.log(`Profiling database URL: ${this.maskPassword(this.profilingDatabaseUrl)}`); - - // 3. Initialize Prisma for profiling database - console.log("Initializing Prisma..."); - this.prisma = new PrismaClient({ - datasources: { - db: { - url: this.profilingDatabaseUrl, - }, - }, - }); - - // 4. Run migrations - console.log("Running database migrations..."); - await this.runMigrations(); - - // 5. Truncate existing TaskRun data for clean slate - console.log("Truncating existing TaskRun data..."); - await this.prisma!.$executeRawUnsafe(`TRUNCATE TABLE public."TaskRun" CASCADE;`); - console.log("โœ… TaskRun table truncated"); - - // 6. Configure replication - console.log("Configuring logical replication..."); - await this.setupReplication(); - - // 7. Set up test fixtures - console.log("Setting up test fixtures..."); - await this.setupTestFixtures(); - - // 7. Parse Redis URL - const redisUrl = this.config.infrastructure.redisUrl || "redis://localhost:6379"; - const parsedRedis = this.parseRedisUrl(redisUrl); - - // 8. Update config - this.config.producer.databaseUrl = this.profilingDatabaseUrl; - this.config.producer.organizationId = this.organizationId; - this.config.producer.projectId = this.projectId; - this.config.producer.runtimeEnvironmentId = this.runtimeEnvironmentId; - - this.config.consumer.pgConnectionUrl = this.profilingDatabaseUrl; - this.config.consumer.redisOptions = parsedRedis; - - if (!this.config.consumer.useMockClickhouse) { - if (!this.config.infrastructure.clickhouseUrl) { - throw new Error( - "Real ClickHouse mode requires clickhouseUrl in config or CLICKHOUSE_URL env var" - ); - } - this.config.consumer.clickhouseUrl = this.config.infrastructure.clickhouseUrl; - console.log("ClickHouse URL:", this.maskPassword(this.config.consumer.clickhouseUrl)); - - // Run ClickHouse migrations - console.log("Running ClickHouse migrations..."); - await this.runClickHouseMigrations(); - console.log("โœ… ClickHouse migrations completed"); - } else { - console.log("Using mock ClickHouse (CPU-only profiling)"); - } - - // 9. Start consumer process - console.log("\nStarting consumer process..."); - // Set outputDir for shutdown signal file (needed when IPC isn't available under Clinic.js) - this.config.consumer.outputDir = this.config.profiling.outputDir; - - this.consumerProcess = new ConsumerProcessManager( - this.config.consumer, - this.config.profiling - ); - - this.consumerProcess.setOnMetrics((metrics) => { - this.metricsCollector.recordConsumerMetrics(metrics); - }); - - this.consumerProcess.setOnBatchFlushed((event) => { - this.metricsCollector.recordBatchFlushed(event); - }); - - this.consumerProcess.setOnError((error) => { - console.error("Consumer error:", error); - }); - - await this.consumerProcess.start(); - - // 10. Start producer processes (multiple workers for high throughput) - const workerCount = this.config.producer.workerCount; - console.log(`Starting ${workerCount} producer process(es)...`); - - for (let i = 0; i < workerCount; i++) { - const workerConfig = { ...this.config.producer }; - // Each worker gets a unique ID and a portion of the total throughput - workerConfig.workerId = `worker-${i + 1}`; - workerConfig.targetThroughput = this.config.producer.targetThroughput / workerCount; - - const producerProcess = new ProducerProcessManager(workerConfig); - - producerProcess.setOnMetrics((metrics) => { - this.metricsCollector.recordProducerMetrics(metrics); - }); - - producerProcess.setOnError((error) => { - console.error(`Producer worker ${i + 1} error:`, error); - }); - - await producerProcess.start(); - this.producerProcesses.push(producerProcess); - - console.log(` โœ“ Producer worker ${i + 1}/${workerCount} started (target: ${workerConfig.targetThroughput.toFixed(0)} rec/sec)`); - } - - console.log("\nโœ… Profiling environment ready!\n"); - } - - async run(): Promise { - console.log("\nโ–ถ๏ธ Starting test phases...\n"); - - for (const phase of this.config.phases) { - console.log(`\n${"=".repeat(60)}`); - console.log(`Phase: ${phase.name}`); - console.log(`Duration: ${phase.durationSec}s | Target: ${phase.targetThroughput} rec/sec`); - console.log(`${"=".repeat(60)}\n`); - - this.metricsCollector.startPhase(phase.name); - - // Start all producer workers - const perWorkerThroughput = phase.targetThroughput / this.producerProcesses.length; - for (const producer of this.producerProcesses) { - producer.send({ - type: "start", - throughput: perWorkerThroughput, - }); - } - - // Wait for phase duration - await this.waitWithProgress(phase.durationSec * 1000); - - // Stop all producer workers - for (const producer of this.producerProcesses) { - producer.send({ type: "stop" }); - } - console.log("\nAll producers stopped, waiting for consumer to catch up..."); - - // Wait for consumer to catch up - await this.waitForReplicationLag(100, 60000); - - this.metricsCollector.endPhase(phase.name); - - // Small pause between phases - await new Promise((resolve) => setTimeout(resolve, 2000)); - } - - console.log("\nโœ… All phases completed!\n"); - return this.metricsCollector.getAllPhases(); - } - - async teardown(): Promise { - console.log("\n๐Ÿงน Tearing down...\n"); - - if (this.producerProcesses.length > 0) { - console.log(`Stopping ${this.producerProcesses.length} producer process(es)...`); - await Promise.all(this.producerProcesses.map((p) => p.stop())); - } - - if (this.consumerProcess) { - console.log("Stopping consumer process..."); - await this.consumerProcess.stop(); - } - - if (this.prisma) { - console.log("Disconnecting Prisma..."); - await this.prisma.$disconnect(); - } - - if (this.adminPrisma) { - await this.adminPrisma.$disconnect(); - } - - console.log("\nโœ… Teardown complete!\n"); - console.log(`๐Ÿ’ก Profiling database '${this.config.infrastructure.profilingDatabaseName}' is preserved for inspection.`); - console.log(` To clean up: DROP DATABASE ${this.config.infrastructure.profilingDatabaseName};`); - } - - async exportMetrics(filePath: string): Promise { - await this.metricsCollector.exportToJSON(filePath); - } - - private async createProfilingDatabase(dbName: string): Promise { - // Connect to default database to create profiling database - const baseUrl = this.config.infrastructure.databaseUrl; - - this.adminPrisma = new PrismaClient({ - datasources: { - db: { - url: baseUrl, - }, - }, - }); - - // Check if database exists - const exists = await this.adminPrisma.$queryRaw>` - SELECT datname FROM pg_database WHERE datname = ${dbName}; - `; - - if (exists.length === 0) { - // Create database - await this.adminPrisma.$executeRawUnsafe(`CREATE DATABASE ${dbName};`); - console.log(`โœ… Created database: ${dbName}`); - } else { - console.log(`โœ… Database already exists: ${dbName}`); - } - } - - private buildProfilingDatabaseUrl(baseUrl: string, dbName: string): string { - // Parse the base URL and replace the database name - const url = new URL(baseUrl); - url.pathname = `/${dbName}`; - return url.toString(); - } - - private async runMigrations(): Promise { - try { - // Use pg_dump to copy schema from main database to profiling database - const baseUrl = this.config.infrastructure.databaseUrl; - const dbName = this.config.infrastructure.profilingDatabaseName || "trigger_profiling"; - - console.log("Copying schema from main database to profiling database..."); - - // Strip query parameters from URLs (pg_dump doesn't support them) - const cleanBaseUrl = baseUrl.split("?")[0]; - const cleanProfilingUrl = this.profilingDatabaseUrl.split("?")[0]; - - // Dump schema only (no data) from main database - execSync( - `pg_dump "${cleanBaseUrl}" --schema-only --no-owner --no-acl | psql "${cleanProfilingUrl}" > /dev/null 2>&1`, - { shell: "/bin/bash" } - ); - - console.log("โœ… Schema copied successfully"); - } catch (error) { - console.error("โŒ Schema copy failed:", error); - throw error; - } - } - - private async setupReplication(): Promise { - // Set REPLICA IDENTITY FULL - await this.prisma!.$executeRawUnsafe( - `ALTER TABLE public."TaskRun" REPLICA IDENTITY FULL;` - ); - - // Drop existing replication slot if it exists (ensures clean slate) - const slotExists = await this.prisma!.$queryRaw< - Array<{ slot_name: string; active: boolean; active_pid: number | null }> - >` - SELECT slot_name, active, active_pid FROM pg_replication_slots WHERE slot_name = ${this.config.consumer.slotName}; - `; - - if (slotExists.length > 0) { - const slot = slotExists[0]; - console.log(`๐Ÿงน Dropping existing replication slot: ${this.config.consumer.slotName}`); - - // If the slot is active, terminate the backend process first - if (slot.active && slot.active_pid) { - console.log( - `โš ๏ธ Replication slot is active for PID ${slot.active_pid}, terminating backend...` - ); - try { - await this.prisma!.$executeRawUnsafe( - `SELECT pg_terminate_backend(${slot.active_pid});` - ); - console.log(`โœ… Terminated backend process ${slot.active_pid}`); - - // Wait a bit for the termination to complete - await new Promise((resolve) => setTimeout(resolve, 1000)); - } catch (error) { - console.warn( - `โš ๏ธ Could not terminate backend ${slot.active_pid}, it may have already exited` - ); - } - } - - // Now try to drop the slot with retry logic - let attempts = 0; - const maxAttempts = 5; - while (attempts < maxAttempts) { - try { - await this.prisma!.$executeRawUnsafe( - `SELECT pg_drop_replication_slot('${this.config.consumer.slotName}');` - ); - console.log(`โœ… Dropped replication slot: ${this.config.consumer.slotName}`); - break; - } catch (error: any) { - attempts++; - if (attempts === maxAttempts) { - throw new Error( - `Failed to drop replication slot after ${maxAttempts} attempts: ${error.message}` - ); - } - console.log( - `โš ๏ธ Slot still active, waiting 2s before retry (attempt ${attempts}/${maxAttempts})...` - ); - await new Promise((resolve) => setTimeout(resolve, 2000)); - } - } - } - - // Drop and recreate publication (ensures clean slate) - const pubExists = await this.prisma!.$queryRaw>` - SELECT pubname FROM pg_publication WHERE pubname = ${this.config.consumer.publicationName}; - `; - - if (pubExists.length > 0) { - console.log(`๐Ÿงน Dropping existing publication: ${this.config.consumer.publicationName}`); - await this.prisma!.$executeRawUnsafe( - `DROP PUBLICATION ${this.config.consumer.publicationName};` - ); - } - - // Create fresh publication - await this.prisma!.$executeRawUnsafe( - `CREATE PUBLICATION ${this.config.consumer.publicationName} FOR TABLE "TaskRun";` - ); - console.log(`โœ… Created publication: ${this.config.consumer.publicationName}`); - - // Create fresh replication slot - await this.prisma!.$executeRawUnsafe( - `SELECT pg_create_logical_replication_slot('${this.config.consumer.slotName}', 'pgoutput');` - ); - console.log(`โœ… Created replication slot: ${this.config.consumer.slotName}`); - } - - private async setupTestFixtures(): Promise { - // Try to find existing profiling fixtures - let org = await this.prisma!.organization.findFirst({ - where: { - slug: { - startsWith: "perf-test-", - }, - }, - orderBy: { - createdAt: "desc", - }, - }); - - if (!org) { - org = await this.prisma!.organization.create({ - data: { - title: "Performance Test Org", - slug: `perf-test-${Date.now()}`, - }, - }); - console.log(`Created organization: ${org.id}`); - } else { - console.log(`Using existing organization: ${org.id}`); - } - - this.organizationId = org.id; - - // Find or create project - let project = await this.prisma!.project.findFirst({ - where: { - organizationId: org.id, - }, - orderBy: { - createdAt: "desc", - }, - }); - - if (!project) { - project = await this.prisma!.project.create({ - data: { - name: "Performance Test Project", - slug: `perf-test-${Date.now()}`, - organizationId: org.id, - externalRef: `perf-test-${Date.now()}`, - }, - }); - console.log(`Created project: ${project.id}`); - } else { - console.log(`Using existing project: ${project.id}`); - } - - this.projectId = project.id; - - // Find or create runtime environment - let env = await this.prisma!.runtimeEnvironment.findFirst({ - where: { - projectId: project.id, - type: "DEVELOPMENT", - }, - orderBy: { - createdAt: "desc", - }, - }); - - if (!env) { - env = await this.prisma!.runtimeEnvironment.create({ - data: { - slug: "dev", - type: "DEVELOPMENT", - projectId: project.id, - organizationId: org.id, - apiKey: `test-key-${Date.now()}`, - pkApiKey: `pk-test-${Date.now()}`, - shortcode: `dev-${Date.now()}`, - }, - }); - console.log(`Created environment: ${env.id}`); - } else { - console.log(`Using existing environment: ${env.id}`); - } - - this.runtimeEnvironmentId = env.id; - - console.log(`\nโœ… Test fixtures ready:`); - console.log(` Organization: ${this.organizationId}`); - console.log(` Project: ${this.projectId}`); - console.log(` Environment: ${this.runtimeEnvironmentId}`); - } - - private parseRedisUrl(url: string): any { - const match = url.match(/^redis:\/\/(?::([^@]+)@)?([^:]+):(\d+)/); - if (!match) { - return { - host: "localhost", - port: 6379, - }; - } - - return { - host: match[2], - port: parseInt(match[3], 10), - password: match[1] || undefined, - }; - } - - private async waitForReplicationLag(maxLagMs: number, timeoutMs: number): Promise { - const start = Date.now(); - - while (Date.now() - start < timeoutMs) { - await new Promise((resolve) => setTimeout(resolve, 1000)); - - if (Date.now() - start > 5000) { - console.log("โœ… Consumer caught up (approximated)"); - return; - } - } - - console.warn("โš ๏ธ Timeout waiting for replication to catch up"); - } - - private async waitWithProgress(durationMs: number): Promise { - const start = Date.now(); - const interval = 5000; - - while (Date.now() - start < durationMs) { - const elapsed = Date.now() - start; - const remaining = durationMs - elapsed; - const progress = (elapsed / durationMs) * 100; - - process.stdout.write( - `\rProgress: ${progress.toFixed(1)}% | Remaining: ${(remaining / 1000).toFixed(0)}s` - ); - - await new Promise((resolve) => setTimeout(resolve, Math.min(interval, remaining))); - } - - process.stdout.write("\n"); - } - - private async runClickHouseMigrations(): Promise { - // Use dynamic import to avoid module resolution issues with tsx - const { ClickHouse } = await import("@internal/clickhouse"); - - const clickhouse = new ClickHouse({ - url: this.config.infrastructure.clickhouseUrl!, - name: "profiling-migrator", - logLevel: "error", // Suppress migration spam - we handle errors ourselves - }); - - try { - // Path to migration files (relative to apps/webapp/test/performance) - const migrationsPath = path.join(__dirname, "../../../../internal-packages/clickhouse/schema"); - - // Read all SQL files in order - const files = await fs.readdir(migrationsPath); - const sqlFiles = files - .filter((f) => f.endsWith(".sql")) - .sort(); // Ensure numeric ordering - - // Suppress verbose output - only show errors - let successCount = 0; - let skippedCount = 0; - - for (const file of sqlFiles) { - const sql = await fs.readFile(path.join(migrationsPath, file), "utf-8"); - - // Parse goose migration file - only execute "up" section - const lines = sql.split("\n"); - let inUpSection = false; - const upSql: string[] = []; - - for (const line of lines) { - const trimmed = line.trim(); - const lowerTrimmed = trimmed.toLowerCase(); - - // Check for section markers (case-insensitive) - if (lowerTrimmed.includes("+goose up")) { - inUpSection = true; - continue; - } - if (lowerTrimmed.includes("+goose down")) { - inUpSection = false; - break; // Stop processing, we only want the "up" section - } - - // Add lines from the "up" section - if (inUpSection && trimmed) { - // Skip standalone comment lines (but keep inline comments and /* */ blocks) - if (trimmed.startsWith("--")) { - continue; - } - upSql.push(line); - } - } - - // Join and split by semicolons - const statements = upSql - .join("\n") - .split(";") - .map((s) => s.trim()) - .filter((s) => s.length > 0); - - for (const statement of statements) { - try { - // Use the underlying client's command method - await (clickhouse.writer as any).client.command({ query: statement }); - successCount++; - } catch (error: any) { - // Ignore "already exists" errors silently - if ( - error.message?.includes("already exists") || - error.message?.includes("ALREADY_EXISTS") || - error.code === "57" - ) { - skippedCount++; - } else { - console.error(`โœ— Migration error in ${file}: ${error.message}`); - throw error; - } - } - } - } - - if (successCount > 0 || skippedCount > 0) { - console.log(`Migrations: ${successCount} applied, ${skippedCount} skipped`); - } - } finally { - await clickhouse.close(); - } - } - - private maskPassword(url: string): string { - return url.replace(/\/\/.*@/, "//***:***@"); - } -} diff --git a/apps/webapp/test/performance/metrics-collector.ts b/apps/webapp/test/performance/metrics-collector.ts deleted file mode 100644 index 0189ad0f2c..0000000000 --- a/apps/webapp/test/performance/metrics-collector.ts +++ /dev/null @@ -1,217 +0,0 @@ -import type { PhaseMetrics, ProducerMetrics } from "./config"; -import fs from "fs/promises"; -import path from "path"; - -interface ConsumerMetrics { - heapUsed: number; - heapTotal: number; - rss: number; - eventLoopUtilization: number; -} - -interface BatchFlushedEvent { - flushId: string; - taskRunInserts: any[]; - payloadInserts: any[]; -} - -export class MetricsCollector { - private phases: Map = new Map(); - private currentPhase: PhaseData | null = null; - - startPhase(name: string): void { - const phase: PhaseData = { - name, - startTime: Date.now(), - endTime: null, - producerMetrics: [], - consumerMetrics: [], - batchesFlushed: [], - replicationLags: [], - }; - - this.phases.set(name, phase); - this.currentPhase = phase; - - console.log(`\n๐Ÿ“Š Phase started: ${name}`); - } - - endPhase(name: string): PhaseMetrics { - const phase = this.phases.get(name); - if (!phase) { - throw new Error(`Phase ${name} not found`); - } - - phase.endTime = Date.now(); - this.currentPhase = null; - - const metrics = this.calculatePhaseMetrics(phase); - console.log(`โœ… Phase completed: ${name}`); - this.printPhaseMetrics(metrics); - - return metrics; - } - - recordProducerMetrics(metrics: ProducerMetrics): void { - if (this.currentPhase) { - this.currentPhase.producerMetrics.push({ - timestamp: Date.now(), - ...metrics, - }); - } - } - - recordConsumerMetrics(metrics: ConsumerMetrics): void { - if (this.currentPhase) { - this.currentPhase.consumerMetrics.push({ - timestamp: Date.now(), - ...metrics, - }); - } - } - - recordBatchFlushed(event: BatchFlushedEvent): void { - if (this.currentPhase) { - this.currentPhase.batchesFlushed.push({ - timestamp: Date.now(), - ...event, - }); - } - } - - recordReplicationLag(lagMs: number): void { - if (this.currentPhase) { - this.currentPhase.replicationLags.push(lagMs); - } - } - - async exportToJSON(filePath: string): Promise { - const report = { - timestamp: new Date().toISOString(), - phases: Array.from(this.phases.values()).map((phase) => - this.calculatePhaseMetrics(phase) - ), - }; - - const dir = path.dirname(filePath); - await fs.mkdir(dir, { recursive: true }); - await fs.writeFile(filePath, JSON.stringify(report, null, 2)); - - console.log(`\n๐Ÿ“„ Metrics exported to: ${filePath}`); - } - - private calculatePhaseMetrics(phase: PhaseData): PhaseMetrics { - const durationMs = phase.endTime ? phase.endTime - phase.startTime : Date.now() - phase.startTime; - const durationSec = durationMs / 1000; - - // Producer metrics - aggregate from all workers - // Find the most recent metric from each worker and sum them - const latestMetricsByWorker = new Map(); - - for (const metric of phase.producerMetrics) { - const workerId = metric.workerId || "default"; - const existing = latestMetricsByWorker.get(workerId); - - // Keep the metric with the highest total (cumulative counters) - if (!existing || (metric.totalInserts + metric.totalUpdates) > (existing.totalInserts + existing.totalUpdates)) { - latestMetricsByWorker.set(workerId, metric); - } - } - - // Sum up the latest totals from each worker - let totalInserts = 0; - let totalUpdates = 0; - - for (const metric of latestMetricsByWorker.values()) { - totalInserts += metric.totalInserts; - totalUpdates += metric.totalUpdates; - } - - const recordsProduced = totalInserts + totalUpdates; - const producerThroughput = durationSec > 0 ? recordsProduced / durationSec : 0; - - // Consumer metrics - const totalBatches = phase.batchesFlushed.length; - const recordsConsumed = phase.batchesFlushed.reduce( - (sum, batch) => sum + batch.taskRunInserts.length, - 0 - ); - const consumerThroughput = durationSec > 0 ? recordsConsumed / durationSec : 0; - - // Replication lag - const sortedLags = [...phase.replicationLags].sort((a, b) => a - b); - const replicationLagP50 = this.percentile(sortedLags, 0.5); - const replicationLagP95 = this.percentile(sortedLags, 0.95); - const replicationLagP99 = this.percentile(sortedLags, 0.99); - - // Event loop utilization (average of samples) - const eventLoopUtilization = - phase.consumerMetrics.length > 0 - ? phase.consumerMetrics.reduce((sum, m) => sum + m.eventLoopUtilization, 0) / - phase.consumerMetrics.length - : 0; - - // Memory (last sample) - const lastConsumerMetric = phase.consumerMetrics[phase.consumerMetrics.length - 1]; - const heapUsedMB = lastConsumerMetric ? lastConsumerMetric.heapUsed / 1024 / 1024 : 0; - const heapTotalMB = lastConsumerMetric ? lastConsumerMetric.heapTotal / 1024 / 1024 : 0; - - // Flush duration (not directly available, use placeholder) - const flushDurationP50 = 0; // Would need to extract from OpenTelemetry metrics - - return { - phase: phase.name, - durationMs, - recordsProduced, - producerThroughput, - batchesFlushed: totalBatches, - recordsConsumed, - consumerThroughput, - replicationLagP50, - replicationLagP95, - replicationLagP99, - eventLoopUtilization, - flushDurationP50, - heapUsedMB, - heapTotalMB, - }; - } - - private percentile(sorted: number[], p: number): number { - if (sorted.length === 0) return 0; - const index = Math.ceil(sorted.length * p) - 1; - return sorted[Math.max(0, index)]; - } - - private printPhaseMetrics(metrics: PhaseMetrics): void { - console.log("\n" + "=".repeat(60)); - console.log(`Phase: ${metrics.phase}`); - console.log("=".repeat(60)); - console.log(`Duration: ${(metrics.durationMs / 1000).toFixed(1)}s`); - console.log(`Records Produced: ${metrics.recordsProduced}`); - console.log(`Producer Throughput: ${metrics.producerThroughput.toFixed(1)} rec/sec`); - console.log(`Records Consumed: ${metrics.recordsConsumed}`); - console.log(`Consumer Throughput: ${metrics.consumerThroughput.toFixed(1)} rec/sec`); - console.log(`Batches Flushed: ${metrics.batchesFlushed}`); - console.log(`Event Loop Util: ${(metrics.eventLoopUtilization * 100).toFixed(1)}%`); - console.log(`Heap Used: ${metrics.heapUsedMB.toFixed(1)} MB`); - console.log(`Replication Lag P50: ${metrics.replicationLagP50.toFixed(1)} ms`); - console.log(`Replication Lag P95: ${metrics.replicationLagP95.toFixed(1)} ms`); - console.log(`Replication Lag P99: ${metrics.replicationLagP99.toFixed(1)} ms`); - console.log("=".repeat(60) + "\n"); - } - - getAllPhases(): PhaseMetrics[] { - return Array.from(this.phases.values()).map((phase) => this.calculatePhaseMetrics(phase)); - } -} - -interface PhaseData { - name: string; - startTime: number; - endTime: number | null; - producerMetrics: Array<{ timestamp: number } & ProducerMetrics>; - consumerMetrics: Array<{ timestamp: number } & ConsumerMetrics>; - batchesFlushed: Array<{ timestamp: number } & BatchFlushedEvent>; - replicationLags: number[]; -} diff --git a/apps/webapp/test/performance/producer-runner.ts b/apps/webapp/test/performance/producer-runner.ts deleted file mode 100644 index 10de2f4cc3..0000000000 --- a/apps/webapp/test/performance/producer-runner.ts +++ /dev/null @@ -1,116 +0,0 @@ -#!/usr/bin/env tsx - -import { PrismaClient } from "@trigger.dev/database"; -import { TaskRunDataGenerator } from "./data-generator"; -import { TaskRunProducer } from "./producer"; -import type { ProducerConfig } from "./config"; - -async function main() { - if (!process.send) { - throw new Error("This script must be run as a child process with IPC enabled"); - } - - // Parse configuration from environment variable - const config = JSON.parse(process.env.PRODUCER_CONFIG!) as ProducerConfig; - - console.log("Producer process starting with config:", { - targetThroughput: config.targetThroughput, - batchSize: config.batchSize, - insertUpdateRatio: config.insertUpdateRatio, - }); - - // Connect to PostgreSQL - const prisma = new PrismaClient({ - datasources: { - db: { - url: config.databaseUrl, - }, - }, - }); - - // Create data generator - const dataGenerator = new TaskRunDataGenerator({ - organizationId: config.organizationId, - projectId: config.projectId, - runtimeEnvironmentId: config.runtimeEnvironmentId, - environmentType: config.environmentType, - payloadSizeKB: config.payloadSizeKB, - includeComplexPayloads: false, // Disabled to avoid BigInt serialization issues - }); - - // Create producer - const producer = new TaskRunProducer({ - prisma, - dataGenerator, - workerId: config.workerId, - targetThroughput: config.targetThroughput, - insertUpdateRatio: config.insertUpdateRatio, - batchSize: config.batchSize, - }); - - // Send metrics to parent every second - const metricsInterval = setInterval(() => { - const metrics = producer.getMetrics(); - process.send!({ - type: "metrics", - data: metrics, - }); - }, 1000); - - // Listen for commands from parent process - process.on("message", async (msg: any) => { - try { - if (msg.type === "start") { - console.log("Producer: Starting production at", msg.throughput || config.targetThroughput, "records/sec"); - await producer.start(); - process.send!({ type: "started" }); - } else if (msg.type === "stop") { - console.log("Producer: Stopping production"); - await producer.stop(); - process.send!({ type: "stopped" }); - // Don't exit - wait for restart or shutdown command - } else if (msg.type === "shutdown") { - console.log("Producer: Shutting down"); - await producer.stop(); - clearInterval(metricsInterval); - await prisma.$disconnect(); - process.send!({ type: "shutdown_complete" }); - process.exit(0); - } - } catch (error) { - console.error("Producer process error:", error); - process.send!({ - type: "error", - error: error instanceof Error ? error.message : String(error), - }); - } - }); - - // Handle uncaught errors (log but don't exit - producer loop handles errors gracefully) - process.on("uncaughtException", (error) => { - console.error("Uncaught exception in producer:", error); - process.send!({ - type: "error", - error: error.message, - }); - // Don't exit - let the producer loop continue - }); - - process.on("unhandledRejection", (reason) => { - console.error("Unhandled rejection in producer:", reason); - process.send!({ - type: "error", - error: String(reason), - }); - // Don't exit - let the producer loop continue - }); - - // Signal ready to parent - console.log("Producer process ready"); - process.send!({ type: "ready" }); -} - -main().catch((error) => { - console.error("Fatal error in producer process:", error); - process.exit(1); -}); diff --git a/apps/webapp/test/performance/producer.ts b/apps/webapp/test/performance/producer.ts deleted file mode 100644 index 3509ccbd8e..0000000000 --- a/apps/webapp/test/performance/producer.ts +++ /dev/null @@ -1,191 +0,0 @@ -import { PrismaClient } from "@trigger.dev/database"; -import { TaskRunDataGenerator } from "./data-generator"; -import type { ProducerMetrics } from "./config"; - -export interface TaskRunProducerOptions { - prisma: PrismaClient; - dataGenerator: TaskRunDataGenerator; - workerId?: string; - targetThroughput: number; - insertUpdateRatio: number; - batchSize: number; -} - -export class TaskRunProducer { - private running = false; - private totalInserts = 0; - private totalUpdates = 0; - private errors = 0; - private latencies: number[] = []; - private createdRunIds: string[] = []; - private timer: NodeJS.Timeout | null = null; - private startTime: number = 0; - - constructor(private readonly options: TaskRunProducerOptions) {} - - async start(): Promise { - if (this.running) { - throw new Error("Producer is already running"); - } - - this.running = true; - this.startTime = Date.now(); - this.resetMetrics(); - - await this.runProducerLoop(); - } - - async stop(): Promise { - this.running = false; - if (this.timer) { - clearTimeout(this.timer); - this.timer = null; - } - } - - getMetrics(): ProducerMetrics { - const elapsed = (Date.now() - this.startTime) / 1000; // seconds - const actualThroughput = elapsed > 0 ? (this.totalInserts + this.totalUpdates) / elapsed : 0; - - return { - workerId: this.options.workerId, - totalInserts: this.totalInserts, - totalUpdates: this.totalUpdates, - actualThroughput, - errors: this.errors, - latencies: [...this.latencies], - }; - } - - private async runProducerLoop(): Promise { - while (this.running) { - const loopStart = Date.now(); - - try { - // Determine insert vs update ratio for this batch - const insertCount = Math.floor(this.options.batchSize * this.options.insertUpdateRatio); - const updateCount = this.options.batchSize - insertCount; - - // Perform inserts - if (insertCount > 0) { - await this.performInserts(insertCount); - } - - // Perform updates (only if we have created runs to update) - if (updateCount > 0 && this.createdRunIds.length > 0) { - await this.performUpdates(updateCount); - } - - // Calculate delay to maintain target throughput - const elapsed = Date.now() - loopStart; - const targetDuration = (this.options.batchSize / this.options.targetThroughput) * 1000; - const delay = Math.max(0, targetDuration - elapsed); - - if (this.running && delay > 0) { - await new Promise((resolve) => { - this.timer = setTimeout(resolve, delay); - }); - } - } catch (error) { - console.error("Producer loop error:", error); - this.errors++; - - // Small delay on error to prevent tight error loops - if (this.running) { - await new Promise((resolve) => { - this.timer = setTimeout(resolve, 1000); - }); - } - } - } - } - - private async performInserts(count: number): Promise { - const start = performance.now(); - - const records = this.options.dataGenerator.generateBatch(count); - - // Extract IDs for future updates - const ids = records.map((r) => r.id as string); - - try { - await this.options.prisma.taskRun.createMany({ - data: records, - skipDuplicates: true, - }); - - this.totalInserts += count; - this.createdRunIds.push(...ids); - - // Keep pool size manageable (max 10000 runs) - if (this.createdRunIds.length > 10000) { - this.createdRunIds = this.createdRunIds.slice(-10000); - } - - const duration = performance.now() - start; - this.latencies.push(duration); - - // Keep latencies array from growing too large - if (this.latencies.length > 1000) { - this.latencies = this.latencies.slice(-1000); - } - } catch (error) { - console.error("Insert error:", error); - this.errors++; - throw error; - } - } - - private async performUpdates(count: number): Promise { - // Skip updates if no runs have been created yet - if (this.createdRunIds.length === 0) { - return; - } - - const start = performance.now(); - - // Select random runs to update - const runIdsToUpdate = new Set(); - while (runIdsToUpdate.size < count && runIdsToUpdate.size < this.createdRunIds.length) { - const randomIndex = Math.floor(Math.random() * this.createdRunIds.length); - runIdsToUpdate.add(this.createdRunIds[randomIndex]); - } - - try { - // Use a single updateMany for all updates with the same data - // This is a simplification - in reality each update might have different data - // but for performance testing, updating them all the same way is fine - const updateData = this.options.dataGenerator.generateUpdate(""); - - await this.options.prisma.taskRun.updateMany({ - where: { - id: { - in: Array.from(runIdsToUpdate), - }, - }, - data: updateData, - }); - - this.totalUpdates += runIdsToUpdate.size; - - const duration = performance.now() - start; - this.latencies.push(duration); - - if (this.latencies.length > 1000) { - this.latencies = this.latencies.slice(-1000); - } - } catch (error) { - console.error("Update error:", error); - this.errors++; - throw error; - } - } - - private resetMetrics(): void { - this.totalInserts = 0; - this.totalUpdates = 0; - this.errors = 0; - this.latencies = []; - this.createdRunIds = []; - } -} From f6559c4177adaf842e0e59d28e2be4989a72a020 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Sun, 11 Jan 2026 13:06:55 +0000 Subject: [PATCH 16/17] Remove remaining performance harness artifacts - Remove profile-runs-replication.ts script - Remove profiling-related .gitignore entries - Remove clinic/commander devDependencies Co-Authored-By: Claude Opus 4.5 --- .gitignore | 5 - apps/webapp/package.json | 4 - .../scripts/profile-runs-replication.ts | 331 ------------------ 3 files changed, 340 deletions(-) delete mode 100644 apps/webapp/scripts/profile-runs-replication.ts diff --git a/.gitignore b/.gitignore index b1ac3dbdcb..8267c9fbab 100644 --- a/.gitignore +++ b/.gitignore @@ -50,11 +50,6 @@ apps/**/public/build /playwright-report/ /playwright/.cache/ -# profiling outputs -profiling-results/ -*.clinic-* -*-v8.log - .cosine .trigger .tshy* diff --git a/apps/webapp/package.json b/apps/webapp/package.json index ffdd9658ed..d7ac3a5003 100644 --- a/apps/webapp/package.json +++ b/apps/webapp/package.json @@ -221,8 +221,6 @@ "zod-validation-error": "^1.5.0" }, "devDependencies": { - "@clinic/doctor": "^11.0.0", - "@clinic/flame": "^13.0.0", "@internal/clickhouse": "workspace:*", "@internal/replication": "workspace:*", "@internal/testcontainers": "workspace:*", @@ -265,8 +263,6 @@ "@typescript-eslint/parser": "^5.59.6", "autoevals": "^0.0.130", "autoprefixer": "^10.4.13", - "clinic": "^13.0.0", - "commander": "^11.0.0", "css-loader": "^6.10.0", "datepicker": "link:@types/@react-aria/datepicker", "engine.io": "^6.5.4", diff --git a/apps/webapp/scripts/profile-runs-replication.ts b/apps/webapp/scripts/profile-runs-replication.ts deleted file mode 100644 index baaef30a65..0000000000 --- a/apps/webapp/scripts/profile-runs-replication.ts +++ /dev/null @@ -1,331 +0,0 @@ -#!/usr/bin/env tsx - -import { program } from "commander"; -import path from "path"; -import fs from "fs/promises"; -import { spawn } from "child_process"; -import { RunsReplicationHarness } from "../test/performance/harness"; -import { getDefaultConfig, type HarnessConfig } from "../test/performance/config"; - -program - .name("profile-runs-replication") - .description("Profile RunsReplicationService performance and identify bottlenecks") - .option("-c, --config ", "Config file path (JSON)") - .option("-n, --name ", "Run name/label (e.g., 'baseline', 'optimized-v1')") - .option("--description ", "Run description (what is being tested)") - .option("-t, --throughput ", "Target throughput (records/sec)", "5000") - .option("-d, --duration ", "Test duration per phase (seconds)", "60") - .option("-w, --workers ", "Number of producer worker processes", "1") - .option("--mock-clickhouse", "Use mock ClickHouse (CPU-only profiling)") - .option( - "--profile ", - "Profiling tool: doctor, flame, both, none", - "none" - ) - .option("--output ", "Output directory", "./profiling-results") - .option("-v, --verbose", "Verbose logging") - .parse(); - -async function loadConfig(options: any): Promise { - let config: HarnessConfig = getDefaultConfig() as HarnessConfig; - - // Load from config file if provided - if (options.config) { - console.log(`Loading config from: ${options.config}`); - const configFile = await fs.readFile(options.config, "utf-8"); - const fileConfig = JSON.parse(configFile) as Partial; - config = { ...config, ...fileConfig }; - } - - // Override with CLI arguments - if (options.throughput) { - const throughput = parseInt(options.throughput, 10); - config.producer.targetThroughput = throughput; - - // Update all phases if no config file was provided - if (!options.config) { - config.phases = config.phases.map((phase) => ({ - ...phase, - targetThroughput: throughput, - })); - } - } - - if (options.duration) { - const duration = parseInt(options.duration, 10); - - // Update all phases if no config file was provided - if (!options.config) { - config.phases = config.phases.map((phase) => ({ - ...phase, - durationSec: duration, - })); - } - } - - if (options.workers) { - config.producer.workerCount = parseInt(options.workers, 10); - } - - if (options.name) { - config.runName = options.name; - } - - if (options.description) { - config.runDescription = options.description; - } - - if (options.mockClickhouse) { - config.consumer.useMockClickhouse = true; - } - - if (options.profile) { - config.profiling.enabled = options.profile !== "none"; - config.profiling.tool = options.profile; - } - - if (options.output) { - config.profiling.outputDir = options.output; - } - - if (options.verbose) { - config.output.verbose = true; - } - - // Organize output directory: profiling-results/[runName]-[timestamp]/ - const timestamp = new Date().toISOString().replace(/[:.]/g, "-").replace("T", "_").split("_")[0]; - const timeWithSeconds = new Date().toISOString().replace(/[:.]/g, "-").replace("T", "_").substring(0, 19); - const runFolder = `${config.runName}-${timeWithSeconds}`; - const outputDir = path.join(config.profiling.outputDir, runFolder); - - config.profiling.outputDir = outputDir; - config.output.metricsFile = path.join(outputDir, "metrics.json"); - - return config; -} - -function printConfig(config: HarnessConfig): void { - console.log("\n" + "=".repeat(60)); - console.log("RunsReplicationService Performance Test Harness"); - console.log("=".repeat(60)); - console.log(`\n๐Ÿท๏ธ Run: ${config.runName}`); - if (config.runDescription) { - console.log(`๐Ÿ“ Description: ${config.runDescription}`); - } - console.log("\n๐Ÿ“‹ Configuration:"); - console.log(` Profiling DB: ${config.infrastructure.profilingDatabaseName}`); - console.log(` Output Dir: ${config.profiling.outputDir}`); - console.log(` Mock ClickHouse: ${config.consumer.useMockClickhouse ? "Yes (CPU-only)" : "No (full stack)"}`); - console.log(` Profiling Tool: ${config.profiling.tool}`); - console.log(` Verbose: ${config.output.verbose}`); - - console.log("\n๐Ÿ“Š Test Phases:"); - for (const phase of config.phases) { - console.log(` - ${phase.name.padEnd(15)} ${phase.durationSec}s @ ${phase.targetThroughput} rec/sec`); - } - - console.log("\nโš™๏ธ Producer Config:"); - console.log(` Worker Processes: ${config.producer.workerCount}`); - console.log(` Insert/Update: ${(config.producer.insertUpdateRatio * 100).toFixed(0)}% inserts`); - console.log(` Batch Size: ${config.producer.batchSize}`); - console.log(` Payload Size: ${config.producer.payloadSizeKB} KB`); - - console.log("\nโš™๏ธ Consumer Config:"); - console.log(` Flush Batch Size: ${config.consumer.flushBatchSize}`); - console.log(` Flush Interval: ${config.consumer.flushIntervalMs} ms`); - console.log(` Max Concurrency: ${config.consumer.maxFlushConcurrency}`); - - console.log("\n" + "=".repeat(60) + "\n"); -} - -function printSummary(phases: any[]): void { - console.log("\n" + "=".repeat(60)); - console.log("๐Ÿ“ˆ Summary"); - console.log("=".repeat(60) + "\n"); - - for (const phase of phases) { - console.log(`${phase.phase}:`); - console.log(` Duration: ${(phase.durationMs / 1000).toFixed(1)}s`); - console.log(` Producer Throughput: ${phase.producerThroughput.toFixed(1)} rec/sec`); - console.log(` Consumer Throughput: ${phase.consumerThroughput.toFixed(1)} rec/sec`); - console.log(` Event Loop Util: ${(phase.eventLoopUtilization * 100).toFixed(1)}%`); - console.log(` Heap Used: ${phase.heapUsedMB.toFixed(1)} MB`); - console.log(` Replication Lag P95: ${phase.replicationLagP95.toFixed(1)} ms`); - console.log(); - } - - console.log("=".repeat(60) + "\n"); -} - -async function createSummaryReport( - config: HarnessConfig, - phases: any[], - outputPath: string -): Promise { - const lines: string[] = []; - - // Header - lines.push(`# Performance Test Run: ${config.runName}`); - lines.push(""); - lines.push(`**Date**: ${new Date().toISOString()}`); - if (config.runDescription) { - lines.push(`**Description**: ${config.runDescription}`); - } - lines.push(""); - - // Configuration - lines.push("## Configuration"); - lines.push(""); - lines.push(`- **Producer Workers**: ${config.producer.workerCount}`); - lines.push(`- **Batch Size**: ${config.producer.batchSize}`); - lines.push(`- **Insert/Update Ratio**: ${(config.producer.insertUpdateRatio * 100).toFixed(0)}% inserts`); - lines.push(`- **Payload Size**: ${config.producer.payloadSizeKB} KB`); - lines.push(`- **Consumer Flush Batch**: ${config.consumer.flushBatchSize}`); - lines.push(`- **Consumer Flush Interval**: ${config.consumer.flushIntervalMs} ms`); - lines.push(`- **Consumer Max Concurrency**: ${config.consumer.maxFlushConcurrency}`); - lines.push(`- **ClickHouse Mode**: ${config.consumer.useMockClickhouse ? "Mock (CPU-only)" : "Real"}`); - lines.push(`- **Profiling Tool**: ${config.profiling.tool}`); - lines.push(""); - - // Key Results - highlight most important metrics - lines.push("## Key Results"); - lines.push(""); - - // For flamegraph runs, focus on throughput only - if (config.profiling.enabled && config.profiling.tool !== "none") { - lines.push("**Profiling Output**: See flamegraph/analysis files in this directory"); - lines.push(""); - lines.push("### Throughput"); - lines.push(""); - lines.push("| Phase | Duration | Producer (rec/sec) | Consumer (rec/sec) |"); - lines.push("|-------|----------|--------------------|--------------------|"); - for (const phase of phases) { - lines.push( - `| ${phase.phase} | ${(phase.durationMs / 1000).toFixed(1)}s | ${phase.producerThroughput.toFixed(0)} | ${phase.consumerThroughput.toFixed(0)} |` - ); - } - } else { - // For non-profiling runs, show ELU prominently - lines.push("### Throughput & Event Loop Utilization"); - lines.push(""); - lines.push("| Phase | Duration | Producer (rec/sec) | Consumer (rec/sec) | ELU (%) |"); - lines.push("|-------|----------|--------------------|--------------------|---------|"); - for (const phase of phases) { - lines.push( - `| ${phase.phase} | ${(phase.durationMs / 1000).toFixed(1)}s | ${phase.producerThroughput.toFixed(0)} | ${phase.consumerThroughput.toFixed(0)} | ${(phase.eventLoopUtilization * 100).toFixed(1)}% |` - ); - } - } - lines.push(""); - - // Detailed Metrics - lines.push("## Detailed Metrics"); - lines.push(""); - - for (const phase of phases) { - lines.push(`### ${phase.phase}`); - lines.push(""); - lines.push(`- **Duration**: ${(phase.durationMs / 1000).toFixed(1)}s`); - lines.push(`- **Records Produced**: ${phase.recordsProduced.toLocaleString()}`); - lines.push(`- **Records Consumed**: ${phase.recordsConsumed.toLocaleString()}`); - lines.push(`- **Batches Flushed**: ${phase.batchesFlushed.toLocaleString()}`); - lines.push(`- **Producer Throughput**: ${phase.producerThroughput.toFixed(1)} rec/sec`); - lines.push(`- **Consumer Throughput**: ${phase.consumerThroughput.toFixed(1)} rec/sec`); - lines.push(`- **Event Loop Utilization**: ${(phase.eventLoopUtilization * 100).toFixed(1)}%`); - lines.push(`- **Heap Used**: ${phase.heapUsedMB.toFixed(1)} MB`); - lines.push(`- **Heap Total**: ${phase.heapTotalMB.toFixed(1)} MB`); - lines.push(`- **Replication Lag P50**: ${phase.replicationLagP50.toFixed(1)} ms`); - lines.push(`- **Replication Lag P95**: ${phase.replicationLagP95.toFixed(1)} ms`); - lines.push(`- **Replication Lag P99**: ${phase.replicationLagP99.toFixed(1)} ms`); - lines.push(""); - } - - // Write to file - await fs.writeFile(outputPath, lines.join("\n")); -} - -async function generateVisualization(config: HarnessConfig): Promise { - console.log("\n๐Ÿ”ฅ Generating flamegraph visualization..."); - - // Find the clinic flame data file - const files = await fs.readdir(config.profiling.outputDir); - const flameDataFile = files.find((f) => f.endsWith(".clinic-flame")); - - if (!flameDataFile) { - console.warn("โš ๏ธ No clinic flame data file found. Skipping visualization."); - return; - } - - const dataPath = path.join(config.profiling.outputDir, flameDataFile); - console.log(` Data file: ${flameDataFile}`); - - // Run clinic flame --visualize-only - const clinicPath = path.join(__dirname, "../node_modules/.bin/clinic"); - - await new Promise((resolve, reject) => { - const proc = spawn(clinicPath, ["flame", "--visualize-only", dataPath], { - stdio: "inherit", - cwd: path.join(__dirname, ".."), - }); - - proc.on("exit", (code) => { - if (code === 0) { - console.log("โœ… Flamegraph generated successfully!"); - console.log(` Open: ${dataPath.replace(".clinic-flame", ".clinic-flame.html")}\n`); - resolve(); - } else { - console.error(`โš ๏ธ Flamegraph generation exited with code ${code}`); - resolve(); // Don't fail the whole run - } - }); - - proc.on("error", (error) => { - console.error("โš ๏ธ Error generating flamegraph:", error.message); - resolve(); // Don't fail the whole run - }); - }); -} - -async function main() { - const options = program.opts(); - const config = await loadConfig(options); - - printConfig(config); - - const harness = new RunsReplicationHarness(config); - - try { - await harness.setup(); - const phases = await harness.run(); - await harness.teardown(); - - // Export metrics JSON - await harness.exportMetrics(config.output.metricsFile); - - // Create summary report - const summaryPath = path.join(config.profiling.outputDir, "SUMMARY.md"); - await createSummaryReport(config, phases, summaryPath); - - // Print summary - printSummary(phases); - - console.log("\nโœ… Profiling complete!"); - console.log(`๐Ÿ“Š Results saved to: ${config.profiling.outputDir}`); - console.log(`๐Ÿ“„ Summary report: ${summaryPath}`); - console.log(`๐Ÿ“Š Detailed metrics: ${config.output.metricsFile}\n`); - - if (config.profiling.enabled && config.profiling.tool !== "none") { - // Generate visualization from collected data - await generateVisualization(config); - } - - process.exit(0); - } catch (error) { - console.error("\nโŒ Profiling failed:"); - console.error(error); - await harness.teardown().catch(() => {}); - process.exit(1); - } -} - -main(); From 67cb06b465ce9d0dd3a14752a95cfc1536196bf1 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Sun, 11 Jan 2026 14:50:42 +0000 Subject: [PATCH 17/17] Update pnpm-lock.yaml Co-Authored-By: Claude Opus 4.5 --- pnpm-lock.yaml | 2980 ------------------------------------------------ 1 file changed, 2980 deletions(-) diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 7b01d2927d..b139d56c62 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -787,12 +787,6 @@ importers: specifier: ^1.5.0 version: 1.5.0(zod@3.25.76) devDependencies: - '@clinic/doctor': - specifier: ^11.0.0 - version: 11.0.0(encoding@0.1.13) - '@clinic/flame': - specifier: ^13.0.0 - version: 13.0.0 '@internal/clickhouse': specifier: workspace:* version: link:../../internal-packages/clickhouse @@ -919,12 +913,6 @@ importers: autoprefixer: specifier: ^10.4.13 version: 10.4.13(postcss@8.5.6) - clinic: - specifier: ^13.0.0 - version: 13.0.0(encoding@0.1.13) - commander: - specifier: ^11.0.0 - version: 11.1.0 css-loader: specifier: ^6.10.0 version: 6.10.0(webpack@5.102.1(@swc/core@1.3.26)(esbuild@0.15.18)) @@ -2761,11 +2749,6 @@ importers: packages: - 0x@5.8.0: - resolution: {integrity: sha512-d07ToyEoxGz/u8JbaqeivEr3b2X6sPil6IDBINrXKBkgveiTW30EfjwDtHmE0TvP5Y4p5vE7ErbK3p68kYE0aw==} - engines: {node: '>=8.5.0'} - hasBin: true - '@adobe/css-tools@4.4.0': resolution: {integrity: sha512-Ff9+ksdQQB3rMncgqDK78uLznstjyfIf2Arnh22pW8kBpLs6rpKDwgnZT46hin5Hl1WzazzK64DOrhSwYpS7bQ==} @@ -3031,9 +3014,6 @@ packages: resolution: {integrity: sha512-UQFQ6SgyJ6LX42W8rHCs8KVc0JS0tzVL9ct4XYedJukskYVWTo49tNiMEK9C2HTyarbNiT/RVIRSY82vH+6sTg==} engines: {node: '>=4'} - '@assemblyscript/loader@0.19.23': - resolution: {integrity: sha512-ulkCYfFbYj01ie1MDOyxv2F6SpRN1TOj7fQxbP07D6HmeR+gr2JLSmINKjga2emB+b1L2KGrFKBTc+e00p54nw==} - '@aws-crypto/crc32@3.0.0': resolution: {integrity: sha512-IzSgsrxUcsrejQbPVilIKy16kAT52EwB6zSaI+M3xxIhKh5+aldEyvI+z6erM7TCLB2BJsFrtHjp6/4/sr+3dA==} @@ -4018,29 +3998,6 @@ packages: resolution: {integrity: sha512-7ORY85rphRazqHzImNXMrh4vsaPrpetFoTWpZYueCO2bbO6PXYDXp/GQ4DgxnGIqbWB/Di1Ai+Xuwq2o7DJ36A==} engines: {node: '>=16'} - '@clinic/bubbleprof@10.0.0': - resolution: {integrity: sha512-7Y0uYO4cz7+Y1advV891uMJLXbZMIriLsV1IHSSVJxmf8tEFm8vogKi/GdYyi4CY0D5heuqOFze/WNrv+U3LRw==} - - '@clinic/clinic-common@7.1.0': - resolution: {integrity: sha512-+e/g1foFFtBqHKc0A9mZkFgH+DiijCT3ZojALGLOgdkzBY3Pun+Oj/FET5xvQWDtJ4RiXWAq4J+odza0NK0aWQ==} - engines: {node: '>= 12.13.0'} - - '@clinic/doctor@11.0.0': - resolution: {integrity: sha512-sfi3etIHDdrziWcG1fOB2XSNIbA+jwnoFNcCwYQxkYG3vh1QUajTur4lZ27YfV1ZsjzLNZAYxV0fOdUin/NJAg==} - - '@clinic/flame@13.0.0': - resolution: {integrity: sha512-3e//olko8YNl0aEUlzVJZybvmIXsmGuwMDxUlF7MKifCes8PICCusTHvuQ1AEIBvP73czbSLrE0xM4lUTWMYpg==} - - '@clinic/heap-profiler@5.0.0': - resolution: {integrity: sha512-1sAU3GuLk6mXGzMn6JGou6bMzP5vTpieZRgk0LVlauVDxq1+vxgiDrSO9Rn0IxHS7spMnHhOB/DigKFY6oci7Q==} - - '@clinic/node-trace-log-join@2.0.0': - resolution: {integrity: sha512-oOXf4Qavmawsg3YCRiGiAwnn8ENItMvfCiXS9sgEk8Iox5pToNRE1hwLwCfn/x2VL8FzJUiJtIcgGA6fJST91Q==} - hasBin: true - - '@clinic/trace-events-parser@2.0.0': - resolution: {integrity: sha512-hXpT4xJED7kW0+BNCSNSFNlYZO0xMYIBbx/lM8kbyW50SemOCk7JP0wEbmYpHNiW1wKT6ICuFaOK742R/w0vTQ==} - '@codemirror/autocomplete@6.4.0': resolution: {integrity: sha512-HLF2PnZAm1s4kGs30EiqKMgD7XsYaQ0XJnMR0rofEWQ5t5D60SfqpDIkIh1ze5tiEbyUWm8+VJ6W1/erVvBMIA==} peerDependencies: @@ -5738,10 +5695,6 @@ packages: engines: {node: '>= 14'} deprecated: too old - '@nearform/heap-profiler@2.0.0': - resolution: {integrity: sha512-846CWyq3Ky5rzcl8Z3S+VT3z6GQSlYD1G/dqbtANu29NUHoCO+W7tOZRK6eA6FjLHnNX0DvP1Mrt2oFBPnkxLw==} - engines: {node: '>= 12.13.0'} - '@neondatabase/serverless@0.9.5': resolution: {integrity: sha512-siFas6gItqv6wD/pZnvdu34wEqgG3nSE6zWZdq5j2DEsa+VvX8i/5HXJOo06qrw5axPXn+lGCxeR+NLaSPIXug==} @@ -10294,16 +10247,6 @@ packages: '@team-plain/typescript-sdk@3.5.0': resolution: {integrity: sha512-9kweiSlYAN31VI7yzILGxdlZqsGJ+FmCEfXyEZ/0/i3r6vOwq45FDqtjadnQJVtFm+rf/8vCFRN+wEYMIEv6Aw==} - '@tensorflow/tfjs-backend-cpu@3.21.0': - resolution: {integrity: sha512-88S21UAdzyK0CsLUrH17GPTD+26E85OP9CqmLZslaWjWUmBkeTQ5Zqyp6iK+gELnLxPx6q7JsNEeFuPv4254lQ==} - engines: {yarn: '>= 1.3.2'} - peerDependencies: - '@tensorflow/tfjs-core': 3.21.0 - - '@tensorflow/tfjs-core@3.21.0': - resolution: {integrity: sha512-YSfsswOqWfd+M4bXIhT3hwtAb+IV8+ODwIxwdFR/7jTAPZP1wMVnSlpKnXHAN64HFOiP+Tm3HmKusEZ0+09A0w==} - engines: {yarn: '>= 1.3.2'} - '@testcontainers/postgresql@10.28.0': resolution: {integrity: sha512-NN25rruG5D4Q7pCNIJuHwB+G85OSeJ3xHZ2fWx0O6sPoPEfCYwvpj8mq99cyn68nxFkFYZeyrZJtSFO+FnydiA==} @@ -10605,9 +10548,6 @@ packages: '@types/lodash@4.14.191': resolution: {integrity: sha512-BdZ5BCCvho3EIXw6wUCXHe7rS53AIDPLE+JzwgT+OsJk53oBfbSmZZ7CX4VaRoN78N+TJpFi9QPlfIVNmJYWxQ==} - '@types/long@4.0.2': - resolution: {integrity: sha512-MqTGEo5bj5t157U6fA/BiDynNkn0YknVdh48CMPkTSpFTVmvao5UQmm7uEF6xBEo7qIMAlY/JSleYaE6VOdpaA==} - '@types/marked@4.0.8': resolution: {integrity: sha512-HVNzMT5QlWCOdeuBsgXP8EZzKUf0+AXzN+sLmjvaB3ZlLqO+e4u0uXrdw9ub69wBKFs+c6/pA4r9sy6cCDvImw==} @@ -10674,9 +10614,6 @@ packages: '@types/object-hash@3.0.6': resolution: {integrity: sha512-fOBV8C1FIu2ELinoILQ+ApxcUKz4ngq+IWUYrxSGjXzzjUALijilampwkMgEtJ+h2njAW3pi853QpzNVCHB73w==} - '@types/offscreencanvas@2019.3.0': - resolution: {integrity: sha512-esIJx9bQg+QYF0ra8GnvfianIY8qWB0GBx54PK5Eps6m+xTj86KLavHv6qDhzKcu5UUOgNfJ2pWaIIV7TRUd9Q==} - '@types/pg-pool@2.0.6': resolution: {integrity: sha512-TaAUE5rq2VQYxab5Ts7WZhKNmuN78Q6PiFonTDdpbx8a1H0M1vhy3rhiMjl+e2iHmogyMw7jZF4FrE6eJUy5HQ==} @@ -10758,9 +10695,6 @@ packages: '@types/scheduler@0.16.2': resolution: {integrity: sha512-hppQEBDmlwhFAXKJX2KnWLYu5yMfi91yazPb2l+lbJiwW+wdo1gNeRA+3RgNSO39WYX2euey41KEwnqesU2Jew==} - '@types/seedrandom@2.4.34': - resolution: {integrity: sha512-ytDiArvrn/3Xk6/vtylys5tlY6eo7Ane0hvcx++TKo6RxQXuVfW0AF/oeWqAj9dN29SyhtawuXstgmPlwNcv/A==} - '@types/seedrandom@3.0.8': resolution: {integrity: sha512-TY1eezMU2zH2ozQoAFAQFOPpvP15g+ZgSfTZt31AUUH/Rxtnz3H+A/Sv1Snw2/amp//omibc+AEkTaA8KUeOLQ==} @@ -10833,9 +10767,6 @@ packages: '@types/uuid@9.0.0': resolution: {integrity: sha512-kr90f+ERiQtKWMz5rP32ltJ/BtULDI5RVO0uavn1HQUOwjx0R1h0rnDYNL0CepF1zL5bSY6FISAfd9tOdDhU5Q==} - '@types/webgl-ext@0.0.30': - resolution: {integrity: sha512-LKVgNmBxN0BbljJrVUwkxwRYqzsAEPcZOe6S2T6ZaBDIrFp0qu4FNlpc5sM1tGbXUYFgdVQIoeLk1Y1UoblyEg==} - '@types/webpack@5.28.5': resolution: {integrity: sha512-wR87cgvxj3p6D0Crt1r5avwqffqPXUkNlnQ1mjU93G7gCuFjufZR4I6j8cz5g1F1tTYpfOOFvly+cmIQwL9wvw==} @@ -11167,9 +11098,6 @@ packages: '@webassemblyjs/wast-printer@1.14.1': resolution: {integrity: sha512-kPSSXE6De1XOR820C90RIo2ogvZG+c3KiHzqUoO/F34Y2shGzesfqv7o57xrxovZJH/MetF5UjroJ/R/3isoiw==} - '@webgpu/types@0.1.16': - resolution: {integrity: sha512-9E61voMP4+Rze02jlTXud++Htpjyyk8vw5Hyw9FGRrmhHQg2GqbuOfwf5Klrb8vTxc2XWI3EfO7RUHMpxTj26A==} - '@whatwg-node/events@0.1.1': resolution: {integrity: sha512-AyQEn5hIPV7Ze+xFoXVU3QTHXVbWPrzaOkxtENMPMuNL6VVHrp4hHfDt9nrQpjO7BgvuM95dMtkycX5M/DZR3w==} engines: {node: '>=16.0.0'} @@ -11211,10 +11139,6 @@ packages: '@zxing/text-encoding@0.9.0': resolution: {integrity: sha512-U/4aVJ2mxI0aDNI8Uq0wEhMgY+u4CNtEb0om3+y3+niDAsoTCOB33UF0sxpzqzdqXLqmvc+vZyAt4O8pPdfkwA==} - JSONStream@1.3.5: - resolution: {integrity: sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==} - hasBin: true - abbrev@2.0.0: resolution: {integrity: sha512-6/mh1E2u2YgEsCHdY0Yx5oW+61gZU+1vXaoiHHrpKeuRNNgFvS+/jrwHiQhB5apAf5oB7UB7E19ol2R2LKH8hQ==} engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} @@ -11407,33 +11331,14 @@ packages: ajv@8.17.1: resolution: {integrity: sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==} - ansi-align@3.0.1: - resolution: {integrity: sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==} - ansi-colors@4.1.3: resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==} engines: {node: '>=6'} - ansi-escapes@3.2.0: - resolution: {integrity: sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==} - engines: {node: '>=4'} - ansi-escapes@7.0.0: resolution: {integrity: sha512-GdYO7a61mR0fOlAsvC9/rIHf7L96sBc6dEWzeOu+KAea5bZyQRPIpojrVoI4AXGJS/ycu/fBTdLrUkA4ODrvjw==} engines: {node: '>=18'} - ansi-regex@2.1.1: - resolution: {integrity: sha512-TIGnTpdo+E3+pCyAluZvtED5p5wCqLdezCyhPZzKPcxvFplEt4i+W7OONCKgeZFT3+y5NZZfOOS/Bdcanm1MYA==} - engines: {node: '>=0.10.0'} - - ansi-regex@3.0.1: - resolution: {integrity: sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==} - engines: {node: '>=4'} - - ansi-regex@4.1.1: - resolution: {integrity: sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==} - engines: {node: '>=6'} - ansi-regex@5.0.1: resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==} engines: {node: '>=8'} @@ -11442,10 +11347,6 @@ packages: resolution: {integrity: sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==} engines: {node: '>=12'} - ansi-styles@2.2.1: - resolution: {integrity: sha512-kmCevFghRiWM7HB5zTPULl4r9bVFSWjz62MhqizDGUrq2NWuNMQyuv4tHHoKJHs69M/MF64lEcHdYIocrdWQYA==} - engines: {node: '>=0.10.0'} - ansi-styles@3.2.1: resolution: {integrity: sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==} engines: {node: '>=4'} @@ -11472,9 +11373,6 @@ packages: any-promise@1.3.0: resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==} - any-shell-escape@0.1.1: - resolution: {integrity: sha512-36j4l5HVkboyRhIWgtMh1I9i8LTdFqVwDEHy1cp+QioJyKgAUG40X0W8s7jakWRta/Sjvm8mUG1fU6Tj8mWagQ==} - anymatch@3.1.3: resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==} engines: {node: '>= 8'} @@ -11521,12 +11419,6 @@ packages: array-flatten@1.1.1: resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==} - array-flatten@3.0.0: - resolution: {integrity: sha512-zPMVc3ZYlGLNk4mpK1NzP2wg0ml9t7fUgDsayR5Y5rSzxQilzR9FGu/EH2jQOcKSAeAfWeylyW8juy3OkWRvNA==} - - array-from@2.1.1: - resolution: {integrity: sha512-GQTc6Uupx1FCavi5mPzBvVT7nEOeWMmUA9P95wpfpW1XwMSKs+KaymD5C2Up7KAUKg/mYwbsUYzdZWcoajlNZg==} - array-includes@3.1.6: resolution: {integrity: sha512-sgTbLvL6cNnw24FnbaDyjmvddQ2ML8arZsgaJhoABMoplz/4QRhtrYS+alr1BUM1Bwp6dhx8vVCBSLG+StwOFw==} engines: {node: '>= 0.4'} @@ -11577,9 +11469,6 @@ packages: asap@2.0.6: resolution: {integrity: sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==} - asn1.js@4.10.1: - resolution: {integrity: sha512-p32cOF5q0Zqs9uBiONKYLm6BClCoBCM5O9JfeUSlnQLBTxYdTK+pW+nXflm8UkKd2UYlEbYz5qEi0JuZR9ckSw==} - asn1@0.2.6: resolution: {integrity: sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==} @@ -11590,9 +11479,6 @@ packages: resolution: {integrity: sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==} engines: {node: '>=0.8'} - assert@1.5.1: - resolution: {integrity: sha512-zzw1uCAgLbsKwBfFc8CX78DDg+xZeBksSO3vwVIDDN5i94eOrPsSSyiVhmsSABFDM/OcpE2aagCat9dnWQLG1A==} - assertion-error@2.0.1: resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==} engines: {node: '>=12'} @@ -11615,9 +11501,6 @@ packages: async-lock@1.4.1: resolution: {integrity: sha512-Az2ZTpuytrtqENulXwO3GGv1Bztugx6TT37NIo7imr/Qo0gsYiGtSdBa2B6fsXhTpVZDNfu1Qn3pk531e3q+nQ==} - async@2.6.4: - resolution: {integrity: sha512-mzo5dfJYwAn29PeiJ0zvwTo04zj8HDJj0Mn8TD7sno7q12prdbnasKJHhkm2c1LgrhlJ0teaea8860oxi51mGA==} - async@3.2.6: resolution: {integrity: sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==} @@ -11628,14 +11511,6 @@ packages: resolution: {integrity: sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==} engines: {node: '>=8.0.0'} - atomically@1.7.0: - resolution: {integrity: sha512-Xcz9l0z7y9yQ9rdDaxlmaI4uJHf/T8g9hOEzJcsEqX2SjCj4J20uK7+ldkDHMbpJDK76wF7xEIgxc/vSlsfw5w==} - engines: {node: '>=10.12.0'} - - autocannon@7.15.0: - resolution: {integrity: sha512-NaP2rQyA+tcubOJMFv2+oeW9jv2pq/t+LM6BL3cfJic0HEfscEcnWgAyU5YovE/oTHUzAgTliGdLPR+RQAWUbg==} - hasBin: true - autoevals@0.0.130: resolution: {integrity: sha512-JS0T/YCEH13AAOGiWWGJDkIPP8LsDmRBYr3EazTukHxvd0nidOW7fGj0qVPFx2bARrSNO9AfCR6xoTP/5m3Bmw==} @@ -11789,18 +11664,9 @@ packages: bintrees@1.0.2: resolution: {integrity: sha512-VOMgTMwjAaUG580SXn3LacVgjurrbMme7ZZNYGSSV7mmtY6QQRh0Eg3pwIcntQ77DErK1L0NxkbetjcoXzVwKw==} - bit-twiddle@1.0.2: - resolution: {integrity: sha512-B9UhK0DKFZhoTFcfvAzhqsjStvGJp9vYWf3+6SNTtdSQnvIgfkHbgHrg/e4+TH71N2GDu8tpmCVoyfrL1d7ntA==} - bl@4.1.0: resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==} - bn.js@4.12.2: - resolution: {integrity: sha512-n4DSx829VRTRByMRGdjQ9iqsN0Bh4OolPsFnaZBLcbi8iXcB+kJ9s7EnRt4wILZNV3kPLHkRVfOc/HvhC3ovDw==} - - bn.js@5.2.2: - resolution: {integrity: sha512-v2YAxEmKaBLahNwE1mjp4WON6huMNeuDvagFZW+ASCuA/ku0bXR9hSMw0XpiqMoA3+rmnyck/tPRSFQkoC9Cuw==} - body-parser@1.20.3: resolution: {integrity: sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==} engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} @@ -11818,10 +11684,6 @@ packages: bowser@2.12.1: resolution: {integrity: sha512-z4rE2Gxh7tvshQ4hluIT7XcFrgLIQaw9X3A+kTTRdovCz5PMukm/0QC/BKSYPj3omF5Qfypn9O/c5kgpmvYUCw==} - boxen@5.1.2: - resolution: {integrity: sha512-9gYgQKXx+1nP8mP7CzFyaUARhg7D3n1dF/FnErWmu9l6JvGpNUN278h0aSb+QjoiKSWG+iZ3uHrcqk0qrY9RQQ==} - engines: {node: '>=10'} - brace-expansion@1.1.11: resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==} @@ -11835,51 +11697,9 @@ packages: breakword@1.0.5: resolution: {integrity: sha512-ex5W9DoOQ/LUEU3PMdLs9ua/CYZl1678NUkKOdUSi8Aw5F1idieaiRURCBFJCwVcrD1J8Iy3vfWSloaMwO2qFg==} - brfs@2.0.2: - resolution: {integrity: sha512-IrFjVtwu4eTJZyu8w/V2gxU7iLTtcHih67sgEdzrhjLBMHp2uYefUBfdM4k2UvcuWMgV7PQDZHSLeNWnLFKWVQ==} - hasBin: true - - brorand@1.1.0: - resolution: {integrity: sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w==} - - browser-pack@6.1.0: - resolution: {integrity: sha512-erYug8XoqzU3IfcU8fUgyHqyOXqIE4tUTTQ+7mqUjQlvnXkOO6OlT9c/ZoJVHYoAaqGxr09CN53G7XIsO4KtWA==} - hasBin: true - - browser-process-hrtime@0.1.3: - resolution: {integrity: sha512-bRFnI4NnjO6cnyLmOV/7PVoDEMJChlcfN0z4s1YMBY989/SvlfMI1lgCnkFUs53e9gQF+w7qu7XdllSTiSl8Aw==} - - browser-resolve@2.0.0: - resolution: {integrity: sha512-7sWsQlYL2rGLy2IWm8WL8DCTJvYLc/qlOnsakDac87SOoCd16WLsaAMdCiAqsTNHIe+SXfaqyxyo6THoWqs8WQ==} - - browserify-aes@1.2.0: - resolution: {integrity: sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==} - - browserify-cipher@1.0.1: - resolution: {integrity: sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==} - - browserify-des@1.0.2: - resolution: {integrity: sha512-BioO1xf3hFwz4kc6iBhI3ieDFompMhrMlnDFC4/0/vd5MokpuAc3R+LYbwTA9A5Yc9pq9UYPqffKpW2ObuwX5A==} - - browserify-rsa@4.1.1: - resolution: {integrity: sha512-YBjSAiTqM04ZVei6sXighu679a3SqWORA3qZTEqZImnlkDIFtKc6pNutpjyZ8RJTjQtuYfeetkxM11GwoYXMIQ==} - engines: {node: '>= 0.10'} - - browserify-sign@4.2.5: - resolution: {integrity: sha512-C2AUdAJg6rlM2W5QMp2Q4KGQMVBwR1lIimTsUnutJ8bMpW5B52pGpR2gEnNBNwijumDo5FojQ0L9JrXA8m4YEw==} - engines: {node: '>= 0.10'} - browserify-zlib@0.1.4: resolution: {integrity: sha512-19OEpq7vWgsH6WkvkBJQDFvJS1uPcbFOQ4v9CU839dO+ZZXUZO6XpE6hNCqvlIIj+4fZvRiJ6DsAQ382GwiyTQ==} - browserify-zlib@0.2.0: - resolution: {integrity: sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==} - - browserify@17.0.1: - resolution: {integrity: sha512-pxhT00W3ylMhCHwG5yfqtZjNnFuX5h2IJdaBfSo4ChaaBsIp9VLrEMQ1bHV+Xr1uLPXuNDDM1GlJkjli0qkRsw==} - engines: {node: '>= 0.8'} - hasBin: true - browserslist@4.21.4: resolution: {integrity: sha512-CBHJJdDmgjl3daYjN5Cp5kbTf1mUhZoS+beLklHIvkOWscs83YAhLlF3Wsh/lciQYAcbBJgTOD44VtG31ZM4Hw==} engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} @@ -11908,19 +11728,9 @@ packages: buffer-equal-constant-time@1.0.1: resolution: {integrity: sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==} - buffer-equal@0.0.1: - resolution: {integrity: sha512-RgSV6InVQ9ODPdLWJ5UAqBqJBOg370Nz6ZQtRzpt6nUjc8v0St97uJ4PYC6NztqIScrAXafKM3mZPMygSe1ggA==} - engines: {node: '>=0.4.0'} - buffer-from@1.1.2: resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} - buffer-xor@1.0.3: - resolution: {integrity: sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ==} - - buffer@5.2.1: - resolution: {integrity: sha512-c+Ko0loDaFfuPWiL02ls9Xd3GO3cPVmUobQ6t3rXNUk304u6hGq+8N/kFi+QEIKhzK3uwolVhLzszmfLmMLnqg==} - buffer@5.7.1: resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==} @@ -11935,9 +11745,6 @@ packages: resolution: {integrity: sha512-8f9ZJCUXyT1M35Jx7MkBgmBMo3oHTTBIPLiY9xyL0pl3T5RwcPEY8cUHr5LBNfu/fk6c2T4DJZuVM/8ZZT2D2A==} engines: {node: '>=10.0.0'} - builtin-status-codes@3.0.0: - resolution: {integrity: sha512-HpGFw18DgFWlncDfjTa2rcQ4W88O1mC8e8yZ2AvQY5KDaktSTwo+KRf6nHK6FRI5FyRyb/5T6+TSxfP7QyGsmQ==} - builtins@1.0.3: resolution: {integrity: sha512-uYBjakWipfaO/bXI7E8rq6kpwHRZK5cNYrUv2OzZSI/FvmdMyXJ2tG9dKcjEC5YHmHpUAwsargWIZNWdxb/bnQ==} @@ -12001,9 +11808,6 @@ packages: resolution: {integrity: sha512-Oj3cAGPCqOZX7Rz64Uny2GYAZNliQSqfbePrgAQ1wKAihYmCUnraBtJtKcGR4xz7wF+LoJC+ssFZvv5BgF9Igg==} engines: {node: '>=8'} - cached-path-relative@1.1.0: - resolution: {integrity: sha512-WF0LihfemtesFcJgO7xfOoOcnWzY/QHR4qeDqV44jPU3HTI54+LnfXK3SA27AVVGCdZFgjjFFaqUA9Jx7dMJZA==} - call-bind-apply-helpers@1.0.2: resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==} engines: {node: '>= 0.4'} @@ -12024,9 +11828,6 @@ packages: resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} engines: {node: '>=6'} - camel-case@3.0.0: - resolution: {integrity: sha512-+MbKztAYHXPr1jNTSKQF52VpcFjwY5RkR7fxksV8Doo4KAYc5Fl4UJRgthBbTmEx8C54DqahhbLJkDwjI3PI/w==} - camelcase-css@2.0.1: resolution: {integrity: sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==} engines: {node: '>= 6'} @@ -12039,10 +11840,6 @@ packages: resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==} engines: {node: '>=6'} - camelcase@6.3.0: - resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==} - engines: {node: '>=10'} - caniuse-lite@1.0.30001577: resolution: {integrity: sha512-rs2ZygrG1PNXMfmncM0B5H1hndY5ZCC9b5TkFaVNfZ+AUlyqcMyVIQtc3fsezi0NUCk5XZfDf9WS6WxMxnfdrg==} @@ -12065,17 +11862,10 @@ packages: ccount@2.0.1: resolution: {integrity: sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==} - cephes@2.0.0: - resolution: {integrity: sha512-4GMUzkcXHZ0HMZ3gZdBrv8pQs1/zkJh2Q9rQOF8NJZHanM359y3XOSdeqmDBPfxQKYQpJt58R3dUpofrIXJ2mg==} - chai@5.2.0: resolution: {integrity: sha512-mCuXncKXk5iCLhfhwTc0izo0gtEmpz5CtG2y8GiOINBlMVS6v8TMRc5TaLWKS6692m9+dVVfzgeVxR5UxWHTYw==} engines: {node: '>=12'} - chalk@1.1.3: - resolution: {integrity: sha512-U3lRVLMSlsCfjqYPbLyVv11M9CPW4I728d6TCKMAOJueEeB9/8o+eSsMnxPJD+Q+K909sdESg7C+tIkoH6on1A==} - engines: {node: '>=0.10.0'} - chalk@2.4.2: resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==} engines: {node: '>=4'} @@ -12100,9 +11890,6 @@ packages: resolution: {integrity: sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==} engines: {node: '>=10'} - char-spinner@1.0.1: - resolution: {integrity: sha512-acv43vqJ0+N0rD+Uw3pDHSxP30FHrywu2NO6/wBaHChJIizpDeBUd6NjqhNhy9LGaEAhZAXn46QzmlAvIWd16g==} - character-entities-html4@2.1.0: resolution: {integrity: sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==} @@ -12169,17 +11956,10 @@ packages: peerDependencies: devtools-protocol: '*' - ci-info@2.0.0: - resolution: {integrity: sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==} - ci-info@3.8.0: resolution: {integrity: sha512-eXTggHWSooYhq49F2opQhuHWgzucfF2YgODK4e1566GQs5BIfP30B0oenwBJHfWxAs2fyPB1s7Mg949zLf61Yw==} engines: {node: '>=8'} - cipher-base@1.0.7: - resolution: {integrity: sha512-Mz9QMT5fJe7bKI7MH31UilT5cEK5EHHRCccw/YRFsRY47AuNgaV6HY3rscp0/I4Q+tTW/5zoqpSeRRI54TkDWA==} - engines: {node: '>= 0.10'} - citty@0.1.6: resolution: {integrity: sha512-tskPPKEs8D2KPafUypv2gxwJP8h/OaJmC82QQGGDQcHvXX43xF2VDACcJVmZ0EuSxkpO9Kc4MlrA3q0+FG58AQ==} @@ -12208,14 +11988,6 @@ packages: resolution: {integrity: sha512-LYv6XPxoyODi36Dp976riBtSY27VmFo+MKqEU9QCCWyTrdEPDog+RWA7xQWHi6Vbp61j5c4cdzzX1NidnwtUWg==} engines: {node: '>=12'} - cli-boxes@2.2.1: - resolution: {integrity: sha512-y4coMcylgSCdVinjiDBuR8PCC2bLjyGTwEmPb9NHR/QaNU6EUOXcTY/s6VjGMD6ENSEaeQYHCY0GNGS5jfMwPw==} - engines: {node: '>=6'} - - cli-cursor@2.1.0: - resolution: {integrity: sha512-8lgKz8LmCRYZZQDpRyT2m5rKJ08TnU4tR9FFFW2rxpxR1FzWi4PQ/NfyODchAatHaUgnSPVcx/R5w6NuTBzFiw==} - engines: {node: '>=4'} - cli-cursor@3.1.0: resolution: {integrity: sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==} engines: {node: '>=8'} @@ -12237,22 +12009,9 @@ packages: resolution: {integrity: sha512-+W/5efTR7y5HRD7gACw9yQjqMVvEMLBHmboM/kPWam+H+Hmyrgjh6YncVKK122YZkXrLudzTuAukUw9FnMf7IQ==} engines: {node: 10.* || >= 12.*} - cli-width@2.2.1: - resolution: {integrity: sha512-GRMWDxpOB6Dgk2E5Uo+3eEBvtOOlimMmpbFiKuLFnQzYDavtLFY3K5ona41jgN/WdRZtG7utuVSVTL4HbZHGkw==} - client-only@0.0.1: resolution: {integrity: sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==} - clinic@13.0.0: - resolution: {integrity: sha512-QAD3cLgA1OqEC7fJSDbAt4U0BKGAK1c5yopN5tu1OtmmsbRHHYxBeSMiElQfuMMdbkAuLEE7HOffZ0hKMzaYVw==} - hasBin: true - - clipboard-copy@4.0.1: - resolution: {integrity: sha512-wOlqdqziE/NNTUJsfSgXmBMIrYmfd5V0HCGsR8uAKHcg+h9NENWINcfRjtWGU77wDHC8B8ijV4hMTGYbrKovng==} - - cliui@5.0.0: - resolution: {integrity: sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==} - cliui@6.0.0: resolution: {integrity: sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==} @@ -12290,10 +12049,6 @@ packages: resolution: {integrity: sha512-RMr0FhtfXemyinomL4hrWcYJxmX6deFdCxpJzhDttxgO1+bcCnkk+9drydLVDmAMG7NE6aN/fl4F7ucU/90gAA==} engines: {node: '>=0.10.0'} - code-point-at@1.1.0: - resolution: {integrity: sha512-RpAVKQA5T63xEj6/giIbUEtZwJ4UFIc3ZtvEkiaUERylqe8xb5IvqcgOurZLahv93CLKfxcw5YI+DZcUBRyLXA==} - engines: {node: '>=0.10.0'} - codemirror@6.0.2: resolution: {integrity: sha512-VhydHotNW5w1UGK0Qj96BwSk/Zqbp9WbnyK2W/eVMv4QyF41INRGpjUhFJY7/uDNuudSc33a/PKr4iDqRduvHw==} @@ -12313,10 +12068,6 @@ packages: color-string@1.9.1: resolution: {integrity: sha512-shrVawQFojnZv6xM40anx4CkoDP+fZsw/ZerEMsW/pyzsRbElpsL/DBVW7q3ExxwusdNXI3lXpuhEZkzs8p5Eg==} - color-support@1.1.3: - resolution: {integrity: sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==} - hasBin: true - color@3.2.1: resolution: {integrity: sha512-aBl7dZI9ENN6fUGC7mWpMTPNHmWUSNan9tuWN6ahh5ZLNk9baLJOnSMlrQkHcrfFgz2/RigjUVAjdx36VcemKA==} @@ -12324,9 +12075,6 @@ packages: resolution: {integrity: sha512-1rXeuUUiGGrykh+CeBdu5Ie7OJwinCgQY0bc7GCRxy5xVHy+moaqkpL/jqQq0MtQOeYcrqEz4abc5f0KtU7W4A==} engines: {node: '>=12.5.0'} - combine-source-map@0.8.0: - resolution: {integrity: sha512-UlxQ9Vw0b/Bt/KYwCFqdEwsQ1eL8d1gibiFb7lxQJFdvTgc2hIZi6ugsg+kyhzhPV+QEpUiEIwInIAIrgoEkrg==} - combined-stream@1.0.8: resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} engines: {node: '>= 0.8'} @@ -12365,9 +12113,6 @@ packages: resolution: {integrity: sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==} engines: {node: ^12.20.0 || >=14} - commist@1.1.0: - resolution: {integrity: sha512-rraC8NXWOEjhADbZe9QBNzLAN5Q3fsTPQtBV+fEVj6xKIgDgNiEVE6ZNfHpZOqfQ21YUzfVNUXLOEZquYvQPPg==} - compare-versions@6.1.1: resolution: {integrity: sha512-4hm4VPpIecmlg59CHXnRDnqGplJFrbLG4aFEl5vl6cK1u76ws3LLvX7ikFnTDl5vo39sjWD6AaDPYodJp/NNHg==} @@ -12398,18 +12143,6 @@ packages: concat-map@0.0.1: resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} - concat-stream@1.6.2: - resolution: {integrity: sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==} - engines: {'0': node >= 0.8} - - concat-stream@2.0.0: - resolution: {integrity: sha512-MWufYdFw53ccGjCA+Ol7XJYpAlW6/prSMzuPOTRnJGcGzuhLn4Scrz7qf6o8bROZ514ltazcIFJZevcfbo0x7A==} - engines: {'0': node >= 6.0} - - conf@10.2.0: - resolution: {integrity: sha512-8fLl9F04EJqjSqH+QjITQfJF8BrOVaYr1jewVgSRAEWePfxT0sku4w2hrGQ60BC/TNLGQ2pgxNlTbWQmMPFvXg==} - engines: {node: '>=12'} - confbox@0.1.8: resolution: {integrity: sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==} @@ -12419,20 +12152,10 @@ packages: config-chain@1.1.13: resolution: {integrity: sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==} - configstore@5.0.1: - resolution: {integrity: sha512-aMKprgk5YhBNyH25hj8wGt2+D52Sw1DRRIzqBwLp2Ya9mFmY8KPvvtvmna8SxVR9JMZ4kzMD68N22vlaRpkeFA==} - engines: {node: '>=8'} - consola@3.4.2: resolution: {integrity: sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==} engines: {node: ^14.18.0 || >=16.10.0} - console-browserify@1.2.0: - resolution: {integrity: sha512-ZMkYO/LkF17QvCPqM0gxw8yUzigAOZOSWSHg91FH6orS7vcEj5dVZTidN2fQ14yBSdg97RqhSNwLUXInd52OTA==} - - constants-browserify@1.0.0: - resolution: {integrity: sha512-xFxOwqIzR/e1k1gLiWEophSCMqXcwVHIH7akf7b/vxcUeGunlj3hvZaaqxwHsTgn+IndtkQJgSztIDWeumWJDQ==} - content-disposition@0.5.4: resolution: {integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==} engines: {node: '>= 0.6'} @@ -12445,9 +12168,6 @@ packages: resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==} engines: {node: '>= 0.6'} - convert-source-map@1.1.3: - resolution: {integrity: sha512-Y8L5rp6jo+g9VEPgvqNfEopjTR4OTYct8lXlS8iVQdmnjDvbdbzYe9rjtFCB9egC86JoNCU61WRY+ScjkZpnIg==} - convert-source-map@1.9.0: resolution: {integrity: sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==} @@ -12548,15 +12268,6 @@ packages: resolution: {integrity: sha512-piICUB6ei4IlTv1+653yq5+KoqfBYmj9bw6LqXoOneTMDXk5nM1qt12mFW1caG3LlJXEKW1Bp0WggEmIfQB34g==} engines: {node: '>= 14'} - create-ecdh@4.0.4: - resolution: {integrity: sha512-mf+TCx8wWc9VpuxfP2ht0iSISLZnt0JgWlrOKZiNqyUZWnjIaCIVNQArMHnCZKfEYRg6IM7A+NeJoN8gf/Ws0A==} - - create-hash@1.2.0: - resolution: {integrity: sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==} - - create-hmac@1.1.7: - resolution: {integrity: sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==} - crelt@1.0.6: resolution: {integrity: sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g==} @@ -12573,12 +12284,6 @@ packages: deprecated: Non-backwards compatible Breaking changes hasBin: true - cross-argv@1.0.0: - resolution: {integrity: sha512-uAVe/bgNHlPdP1VE4Sk08u9pAJ7o1x/tVQtX77T5zlhYhuwOWtVkPBEtHdvF5cq48VzeCG5i1zN4dQc8pwLYrw==} - - cross-argv@2.0.0: - resolution: {integrity: sha512-YIaY9TR5Nxeb8SMdtrU8asWVM4jqJDNDYlKV21LxtYcfNJhp1kEsgSa6qXwXgzN0WQWGODps0+TlGp2xQSHwOg==} - cross-env@7.0.3: resolution: {integrity: sha512-+/HKd6EgcQCJGh2PSjZuUitQBQynKor4wrFbRg4DtAgS1aWO+gU52xpH7M9ScGgXSYmAVS9bIJ8EzuaGw0oNAw==} engines: {node: '>=10.14', npm: '>=6', yarn: '>=1'} @@ -12599,20 +12304,12 @@ packages: resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==} engines: {node: '>= 8'} - crypto-browserify@3.12.1: - resolution: {integrity: sha512-r4ESw/IlusD17lgQi1O20Fa3qNnsckR126TdUuBgAu7GBYSIPvdNyONd3Zrxh0xCwA4+6w/TDArBPsMvhur+KQ==} - engines: {node: '>= 0.10'} - crypto-js@4.1.1: resolution: {integrity: sha512-o2JlM7ydqd3Qk9CA0L4NL6mTzU2sdx96a+oOfPu8Mkl/PK51vSyoi8/rQ8NknZtk44vq15lmhAj9CIAGwgeWKw==} crypto-js@4.2.0: resolution: {integrity: sha512-KALDyEYgpY+Rlob/iriUtjV6d5Eq+Y191A5g4UqLAi8CyGP9N1+FdVbkc1SxKc2r4YAYqG8JzO2KGL+AizD70Q==} - crypto-random-string@2.0.0: - resolution: {integrity: sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==} - engines: {node: '>=8'} - css-in-js-utils@3.1.0: resolution: {integrity: sha512-fJAcud6B3rRu+KHYk+Bwf+WFL2MDCJJ1XG9x137tJQ0xYxor7XziQtuGFbWNdqrvF4Tk26O3H73nfVqXt/fW1A==} @@ -12673,9 +12370,6 @@ packages: resolution: {integrity: sha512-xiEMER6E7TlTPnDxrM4eRiC6TRgjNX9xzEZ5U/Se2YJKr7Mq4pJn/2XEHjl3STcSh96GmkHPcBXLES8M29wyyg==} deprecated: Cuid and other k-sortable and non-cryptographic ids (Ulid, ObjectId, KSUID, all UUIDs) are all insecure. Use @paralleldrive/cuid2 instead. - cwise-compiler@1.1.3: - resolution: {integrity: sha512-WXlK/m+Di8DMMcCjcWr4i+XzcQra9eCdXIJrgh4TUgh0pIS/yJduLxS9JgefsHJ/YVLdgPtXm9r62W92MvanEQ==} - cytoscape-cose-bilkent@4.1.0: resolution: {integrity: sha512-wgQlVIUJF13Quxiv5e1gstZ08rnZj2XaLHGoFMYXz7SkNfCDOOteKBE6SYRfA9WxxI/iBc3ajfDoc6hb/MRAHQ==} peerDependencies: @@ -12697,9 +12391,6 @@ packages: resolution: {integrity: sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==} engines: {node: '>=12'} - d3-axis@1.0.12: - resolution: {integrity: sha512-ejINPfPSNdGFKEOAtnBtdkpr24c4d4jsei6Lg98mxf424ivoDP2956/5HDpIAtmHo85lqT4pruy+zEgvRUBqaQ==} - d3-axis@3.0.0: resolution: {integrity: sha512-IH5tgjV4jE/GhHkRV0HiVYPDtvfjHQlQfJHs0usq7M30XcSBvOotpmH1IgkcXsO/5gEQZD43B//fc7SRT5S+xw==} engines: {node: '>=12'} @@ -12712,12 +12403,6 @@ packages: resolution: {integrity: sha512-VE5S6TNa+j8msksl7HwjxMHDM2yNK3XCkusIlpX5kwauBfXuyLAtNg9jCp/iHH61tgI4sb6R/EIMWCqEIdjT/g==} engines: {node: '>=12'} - d3-color@1.4.1: - resolution: {integrity: sha512-p2sTHSLCJI2QKunbGb7ocOh7DgTAn8IrLx21QRc/BSnodXM4sv6aLQlnfpvehFMLZEfBc6g9pH9SWQccFYfJ9Q==} - - d3-color@2.0.0: - resolution: {integrity: sha512-SPXi0TSKPD4g9tw0NMZFnR95XVgUZiBH+uUTqQuDu1OsE2zomHU7ho0FISciaPvosimixwHFl3WHLGabv6dDgQ==} - d3-color@3.1.0: resolution: {integrity: sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==} engines: {node: '>=12'} @@ -12730,16 +12415,10 @@ packages: resolution: {integrity: sha512-mdjtIZ1XLAM8bm/hx3WwjfHt6Sggek7qH043O8KEjDXN40xi3vx/6pYSVTwLjEgiXQTbvaouWKynLBiUZ6SK6A==} engines: {node: '>=12'} - d3-dispatch@1.0.6: - resolution: {integrity: sha512-fVjoElzjhCEy+Hbn8KygnmMS7Or0a9sI2UzGwoB7cCtvI1XpVN9GpoYlnb3xt2YV66oXYb1fLJ8GMvP4hdU1RA==} - d3-dispatch@3.0.1: resolution: {integrity: sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg==} engines: {node: '>=12'} - d3-drag@1.2.5: - resolution: {integrity: sha512-rD1ohlkKQwMZYkQlYVCrSFxsWPzI97+W+PaEIBNTMxRuxz9RF0Hi5nJWHGVJ3Om9d2fRTe1yOBINJyy/ahV95w==} - d3-drag@3.0.0: resolution: {integrity: sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg==} engines: {node: '>=12'} @@ -12749,9 +12428,6 @@ packages: engines: {node: '>=12'} hasBin: true - d3-ease@1.0.7: - resolution: {integrity: sha512-lx14ZPYkhNx0s/2HX5sLFUI3mbasHjSSpwO/KaaNACweVwxUruKyWVcb293wMv1RqTPZyZ8kSZ2NogUZNcLOFQ==} - d3-ease@3.0.1: resolution: {integrity: sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==} engines: {node: '>=12'} @@ -12760,19 +12436,10 @@ packages: resolution: {integrity: sha512-kpkQIM20n3oLVBKGg6oHrUchHM3xODkTzjMoj7aWQFq5QEM+R6E4WkzT5+tojDY7yjez8KgCBRoj4aEr99Fdqw==} engines: {node: '>=12'} - d3-fg@6.14.0: - resolution: {integrity: sha512-M4QpFZOEvAq4ZDzwabJp2inL+KXS85T2SQl00zWwjnolaCJR+gHxUbT7Ha4GxTeW1NXwzbykhv/38I1fxQqbyg==} - d3-force@3.0.0: resolution: {integrity: sha512-zxV/SsA+U4yte8051P4ECydjD/S+qeYtnaIyAs9tgHCqfguma/aAQDjo85A9Z6EKhBirHRJHXIgJUlffT4wdLg==} engines: {node: '>=12'} - d3-format@1.4.5: - resolution: {integrity: sha512-J0piedu6Z8iB6TbIGfZgDzfXxUFN3qQRMofy2oPdXzQibYGqPB/9iMcxr/TGalU+2RsyDO+U4f33id8tbnSRMQ==} - - d3-format@2.0.0: - resolution: {integrity: sha512-Ab3S6XuE/Q+flY96HXT0jOXcM4EAClYFnRGY5zsjRGNy6qCYrQsMffs7cV5Q9xejb35zxW5hf/guKw34kvIKsA==} - d3-format@3.1.0: resolution: {integrity: sha512-YyUI6AEuY/Wpt8KWLgZHsIU86atmikuoOmCfommt0LYHiQSPjvX2AcFc38PX0CBpr2RCyZhjex+NS/LPOv6YqA==} engines: {node: '>=12'} @@ -12781,19 +12448,10 @@ packages: resolution: {integrity: sha512-637ln3gXKXOwhalDzinUgY83KzNWZRKbYubaG+fGVuc/dxO64RRljtCTnf5ecMyE1RIdtqpkVcq0IbtU2S8j2Q==} engines: {node: '>=12'} - d3-hierarchy@1.1.9: - resolution: {integrity: sha512-j8tPxlqh1srJHAtxfvOUwKNYJkQuBFdM1+JAUfq6xqH5eAqf93L7oG1NVqDa4CpFZNvnNKtCYEUC8KY9yEn9lQ==} - d3-hierarchy@3.1.2: resolution: {integrity: sha512-FX/9frcub54beBdugHjDCdikxThEqjnR93Qt7PvQTOHxyiNCAlvMrHhclk3cD5VeAaq9fxmfRp+CnWw9rEMBuA==} engines: {node: '>=12'} - d3-interpolate@1.4.0: - resolution: {integrity: sha512-V9znK0zc3jOPV4VD2zZn0sDhZU3WAE2bmlxdIwwQPPzPjvyLkd8B3JUVdS1IDUFDkWZ72c9qnv1GK2ZagTZ8EA==} - - d3-interpolate@2.0.1: - resolution: {integrity: sha512-c5UhwwTs/yybcmTpAVqwSFl6vrQ8JZJoT5F7xNFK9pymv5C0Ymcc9/LIJHtYIggg/yS9YHw8i8O8tgb9pupjeQ==} - d3-interpolate@3.0.1: resolution: {integrity: sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==} engines: {node: '>=12'} @@ -12824,16 +12482,10 @@ packages: resolution: {integrity: sha512-A3s5PWiZ9YCXFye1o246KoscMWqf8BsD9eRiJ3He7C9OBaxKhAd5TFCdEx/7VbKtxxTsu//1mMJFrEt572cEyQ==} engines: {node: '>=12'} - d3-scale@3.3.0: - resolution: {integrity: sha512-1JGp44NQCt5d1g+Yy+GeOnZP7xHo0ii8zsQp6PGzd+C1/dl0KGsp9A7Mxwp+1D1o4unbTTxVdU/ZOIEBoeZPbQ==} - d3-scale@4.0.2: resolution: {integrity: sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==} engines: {node: '>=12'} - d3-selection@1.4.2: - resolution: {integrity: sha512-SJ0BqYihzOjDnnlfyeHT0e30k0K1+5sR3d5fNueCNeuhZTnGw4M4o8mqJchSwgKMXCNFo+e2VTChiSJ0vYtXkg==} - d3-selection@3.0.0: resolution: {integrity: sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==} engines: {node: '>=12'} @@ -12845,42 +12497,24 @@ packages: resolution: {integrity: sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA==} engines: {node: '>=12'} - d3-time-format@2.3.0: - resolution: {integrity: sha512-guv6b2H37s2Uq/GefleCDtbe0XZAuy7Wa49VGkPVPMfLL9qObgBST3lEHJBMUp8S7NdLQAGIvr2KXk8Hc98iKQ==} - d3-time-format@4.1.0: resolution: {integrity: sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==} engines: {node: '>=12'} - d3-time@1.1.0: - resolution: {integrity: sha512-Xh0isrZ5rPYYdqhAVk8VLnMEidhz5aP7htAADH6MfzgmmicPkTo8LhkLxci61/lCB7n7UmE3bN0leRt+qvkLxA==} - - d3-time@2.1.1: - resolution: {integrity: sha512-/eIQe/eR4kCQwq7yxi7z4c6qEXf2IYGcjoWB5OOQy4Tq9Uv39/947qlDcN2TLkiTzQWzvnsuYPB9TrWaNfipKQ==} - d3-time@3.1.0: resolution: {integrity: sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==} engines: {node: '>=12'} - d3-timer@1.0.10: - resolution: {integrity: sha512-B1JDm0XDaQC+uvo4DT79H0XmBskgS3l6Ve+1SBCfxgmtIb1AVrPIoqd+nPSv+loMX8szQ0sVUhGngL7D5QPiXw==} - d3-timer@3.0.1: resolution: {integrity: sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==} engines: {node: '>=12'} - d3-transition@1.3.2: - resolution: {integrity: sha512-sc0gRU4PFqZ47lPVHloMn9tlPcv8jxgOQg+0zjhfZXMQuvppjG6YuwdMBE0TuqCZjeJkLecku/l9R0JPcRhaDA==} - d3-transition@3.0.1: resolution: {integrity: sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w==} engines: {node: '>=12'} peerDependencies: d3-selection: 2 - 3 - d3-zoom@1.8.3: - resolution: {integrity: sha512-VoLXTK4wvy1a0JpH2Il+F2CiOhVu7VRXWF5M/LroMIh3/zBAC3WAt7QoIvPibOavVo20hN6/37vwAsdBejLyKQ==} - d3-zoom@3.0.0: resolution: {integrity: sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw==} engines: {node: '>=12'} @@ -12889,26 +12523,12 @@ packages: resolution: {integrity: sha512-e1U46jVP+w7Iut8Jt8ri1YsPOvFpg46k+K8TpCb0P+zjCkjkPnV7WzfDJzMHy1LnA+wj5pLT1wjO901gLXeEhA==} engines: {node: '>=12'} - d@1.0.2: - resolution: {integrity: sha512-MOqHvMWF9/9MX6nza0KgvFH4HpMU0EF5uUDXqX/BtxtU8NfB0QzRtJ8Oe/6SuS4kbhyzVJwjd97EA4PKrzJ8bw==} - engines: {node: '>=0.12'} - dagre-d3-es@7.0.11: resolution: {integrity: sha512-tvlJLyQf834SylNKax8Wkzco/1ias1OPw8DcUMDE7oUIoSEW25riQVuiu/0OWEFqT0cxHT3Pa9/D82Jr47IONw==} damerau-levenshtein@1.0.8: resolution: {integrity: sha512-sdQSFB7+llfUcQHUQO3+B8ERRj0Oa4w9POWMI/puGtuf7gFywGmkaLCElnudfTiKZV+NvHqL0ifzdrI8Ro7ESA==} - dargs@7.0.0: - resolution: {integrity: sha512-2iy1EkLdlBzQGvbweYRFxmFath8+K7+AKB0TlhHWkNuH+TmovaMH/Wp7V7R4u7f4SnX3OgLsU9t1NI9ioDnUpg==} - engines: {node: '>=8'} - - dash-ast@1.0.0: - resolution: {integrity: sha512-Vy4dx7gquTeMcQR/hDkYLGUnwVil6vk4FOOct+djUnHOUWt+zJPJAaRIXaAFkPXtJjvlY7o3rfRu0/3hpnwoUA==} - - dash-ast@2.0.1: - resolution: {integrity: sha512-5TXltWJGc+RdnabUGzhRae1TRq6m4gr+3K2wQX0is5/F2yS6MJXJvLyI3ErAnsAXuJoGqvfVD5icRgim07DrxQ==} - dashdash@1.14.1: resolution: {integrity: sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==} engines: {node: '>=0.10'} @@ -12942,10 +12562,6 @@ packages: dayjs@1.11.18: resolution: {integrity: sha512-zFBQ7WFRvVRhKcWoUh+ZA1g2HVgUbsZm9sbddh8EC5iv93sui8DVVz1Npvz+r6meo9VKfa8NyLWBsQK1VvIKPA==} - debounce-fn@4.0.0: - resolution: {integrity: sha512-8pYCQiL9Xdcg0UPSD3d+0KMlOjp+KGU5EPwYddgzQ7DATsg4fuUDjQtsYLmWjnk2obnNHgV3vE2Y4jejSOJVBQ==} - engines: {node: '>=10'} - debounce@1.2.1: resolution: {integrity: sha512-XRRe6Glud4rd/ZGQfiV1ruXSfbvfJedlV9Y6zOlP+2K04vBYiJEte6stfFkCP03aMnY5tsipamumUjL14fofug==} @@ -13123,17 +12739,10 @@ packages: deprecation@2.3.1: resolution: {integrity: sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ==} - deps-sort@2.0.1: - resolution: {integrity: sha512-1orqXQr5po+3KI6kQb9A4jnXT1PBwggGl2d7Sq2xsnOeI9GPcE/tGcF9UiSZtZBM7MukY4cAh7MemS6tZYipfw==} - hasBin: true - dequal@2.0.3: resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==} engines: {node: '>=6'} - des.js@1.1.0: - resolution: {integrity: sha512-r17GxjhUCjSRy8aiJpr8/UadFIzMzJGexI3Nmz4ADi9LYSFx4gTBp80+NaX/YsXWWLhpZ7v/v/ubEc/bCNfKwg==} - destr@2.0.3: resolution: {integrity: sha512-2N3BOUU4gYMpTP24s5rF5iP7BDr7uNTCs4ozw3kf/eKfvWSIu93GEBi5m427YoyJoeOzQ5smuu4nNAPGb8idSQ==} @@ -13181,9 +12790,6 @@ packages: resolution: {integrity: sha512-D+mk+qE8VC/PAUrlAU34N+VfXev0ghe5ywmpqrawphmVZc1bEfn56uo9qpyGp1p4xpzOHkSW4ztBd6L7Xx4ACw==} engines: {node: '>=0.3.1'} - diffie-hellman@5.0.3: - resolution: {integrity: sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==} - dir-glob@3.0.1: resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==} engines: {node: '>=8'} @@ -13191,9 +12797,6 @@ packages: discontinuous-range@1.0.0: resolution: {integrity: sha512-c68LpLbO+7kP/b1Hr1qs8/BJ09F5khZGTxqxZuhzxpmwJKOgRFHJWIb9/KmqnqHhLdO55aOxFH/EGBvUQbL/RQ==} - distributions@2.2.0: - resolution: {integrity: sha512-n7ybud+CRAOZlpg+ETuA0PTiSBfyVNt8Okns5gSK4NvHwj7RamQoufptOucvVcTn9CV4DZ38p1k6TgwMexUNkQ==} - dlv@1.1.3: resolution: {integrity: sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==} @@ -13229,10 +12832,6 @@ packages: dom-serializer@2.0.0: resolution: {integrity: sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==} - domain-browser@1.2.0: - resolution: {integrity: sha512-jnjyiM6eRyZl2H+W8Q/zLMA481hzi0eszAaBUzIVnmYVDBbnLxVNnfu1HgEBvCbL+71FrxMl3E6lpKH7Ge3OXA==} - engines: {node: '>=0.4', npm: '>=1.2'} - domelementtype@2.3.0: resolution: {integrity: sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==} @@ -13246,14 +12845,6 @@ packages: domutils@3.0.1: resolution: {integrity: sha512-z08c1l761iKhDFtfXO04C7kTdPBLi41zwOZl00WS8b5eiaebNpY00HKbztwBq+e3vyqWNwWF3mP9YLUeqIrF+Q==} - dot-prop@5.3.0: - resolution: {integrity: sha512-QM8q3zDe58hqUqjraQOmzZ1LIH9SWQJTlEKCH4kJ2oQvLZk7RbQXvtDM2XEq3fwkV9CCvvH4LA0AV+ogFsBM2Q==} - engines: {node: '>=8'} - - dot-prop@6.0.1: - resolution: {integrity: sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==} - engines: {node: '>=10'} - dotenv@16.0.3: resolution: {integrity: sha512-7GO6HghkA5fYG9TYnNxi14/7K9f5occMlp3zXAuSxn7CKCxt9xbNWG7yF8hTCSUchlfWSe3uLmlPfigevRItzQ==} engines: {node: '>=12'} @@ -13289,12 +12880,6 @@ packages: resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==} engines: {node: '>= 0.4'} - dup@1.0.0: - resolution: {integrity: sha512-Bz5jxMMC0wgp23Zm15ip1x8IhYRqJvF3nFC0UInJUDkN1z4uNPk9jTnfCUJXbOGiQ1JbXLQsiV41Fb+HXcj5BA==} - - duplexer2@0.1.4: - resolution: {integrity: sha512-asLFVfWWtJ90ZyOUHMqk7/S2w2guQKxUI2itj3d92ADHhxUSbCMGi1f1cBcJ7xM1To+pE/Khbwo1yuNbMEPKeA==} - duplexer3@0.1.5: resolution: {integrity: sha512-1A8za6ws41LQgv9HrE/66jyC5yuSjQ3L/KOpFtoBilsAK2iA2wuS5rTt1OCzIvtS2V7nVmedsUU+DGRcjBmOYA==} @@ -13352,12 +12937,6 @@ packages: electron-to-chromium@1.5.98: resolution: {integrity: sha512-bI/LbtRBxU2GzK7KK5xxFd2y9Lf9XguHooPYbcXWy6wUoT8NMnffsvRhPmSeUHLSDKAEtKuTaEtK4Ms15zkIEA==} - elliptic@6.6.1: - resolution: {integrity: sha512-RaddvvMatK2LJHqFJ+YA4WysVN5Ita9E35botqIYspQ4TkRAlCicdzKOjlyv/1Za5RyTNn7di//eEV0uTAfe3g==} - - emoji-regex@7.0.3: - resolution: {integrity: sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==} - emoji-regex@8.0.0: resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==} @@ -13385,9 +12964,6 @@ packages: end-of-stream@1.4.4: resolution: {integrity: sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==} - endpoint@0.4.5: - resolution: {integrity: sha512-oA2ALUF+d4Y0I8/WMV/0BuAZGHxfIdAygr9ZXP4rfzmp5zpYZmYKHKAbqRQnrE1YGdPhVg4D24CQkyx2qYEoHg==} - engine.io-client@6.5.3: resolution: {integrity: sha512-9Z0qLB0NIisTRt1DZ/8U2k12RJn8yls/nXMZLn+/N8hANT3TcYjKFKcwbw5zFQiN4NTde3TSY9zb79e1ij6j9Q==} @@ -13423,9 +12999,6 @@ packages: resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==} engines: {node: '>=6'} - env-string@1.0.1: - resolution: {integrity: sha512-/DhCJDf5DSFK32joQiWRpWrT0h7p3hVQfMKxiBb7Nt8C8IF8BYyPtclDnuGGLOoj16d/8udKeiE7JbkotDmorQ==} - environment@1.1.0: resolution: {integrity: sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==} engines: {node: '>=18'} @@ -13488,24 +13061,6 @@ packages: resolution: {integrity: sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==} engines: {node: '>= 0.4'} - es5-ext@0.10.64: - resolution: {integrity: sha512-p2snDhiLaXe6dahss1LddxqEm+SkuDvV8dnIQG0MWjyHpcMNfXKPE+/Cc0y+PhxJX3A4xGNeFCj5oc0BUh6deg==} - engines: {node: '>=0.10'} - - es6-iterator@2.0.3: - resolution: {integrity: sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g==} - - es6-map@0.1.5: - resolution: {integrity: sha512-mz3UqCh0uPCIqsw1SSAkB/p0rOzF/M0V++vyN7JqlPtSW/VsYgQBvVvqMLmfBuyMzTpLnNqi6JmcSizs4jy19A==} - - es6-set@0.1.6: - resolution: {integrity: sha512-TE3LgGLDIBX332jq3ypv6bcOpkLO0AslAQo7p2VqX/1N46YNsvIWgvjojjSEnWEGWMhr1qUbYeTSir5J6mFHOw==} - engines: {node: '>=0.12'} - - es6-symbol@3.1.4: - resolution: {integrity: sha512-U9bFFjX8tFiATgtkJ1zg25+KviIXpgRvRHS8sau3GfhVzThRQrOeksPeT0BWW2MNZs1OEWJ1DPXOQMn0KKRkvg==} - engines: {node: '>=0.12'} - esbuild-android-64@0.15.18: resolution: {integrity: sha512-wnpt3OXRhcjfIDSZu9bnzT4/TNTDsOUvip0foZOUBG7QbSt//w3QV4FInVJxNhKc/ErhUxc5z4QjHtMi7/TbgA==} engines: {node: '>=12'} @@ -13671,10 +13226,6 @@ packages: resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==} engines: {node: '>=6'} - escape-goat@2.1.1: - resolution: {integrity: sha512-8/uIhbG12Csjy2JEW7D9pHbreaVaS/OpN3ycnyvElTdwM5n6GY6W6e2IPemfvGZeUMqZ9A/3GqIZMgKnBhAw/Q==} - engines: {node: '>=8'} - escape-html@1.0.3: resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==} @@ -13690,11 +13241,6 @@ packages: resolution: {integrity: sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==} engines: {node: '>=12'} - escodegen@1.14.3: - resolution: {integrity: sha512-qFcX0XJkdg+PB3xjZZG/wKSuT1PnQWx57+TVSjIMmILd2yC/6ByYElPwJnslDsuWuSAp4AwJGumarAAmJch5Kw==} - engines: {node: '>=4.0'} - hasBin: true - escodegen@2.1.0: resolution: {integrity: sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==} engines: {node: '>=6.0'} @@ -13890,10 +13436,6 @@ packages: esm-env@1.2.2: resolution: {integrity: sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==} - esniff@2.0.1: - resolution: {integrity: sha512-kTUIGKQ/mDPFoJ0oVfcmyJn4iBDRptjNVIzwIFR7tqWXdVI9xfA2RMwY/gbSpJG3lkdWNEjLap/NqVHZiJsdfg==} - engines: {node: '>=0.10'} - espree@9.4.1: resolution: {integrity: sha512-XwctdmTO6SIvCzd9810yyNzIrOrqNYV9Koizx4C/mRhf9uq0o4yHoCEU/670pOxOL/MSraektvSAji79kX90Vg==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} @@ -13926,12 +13468,6 @@ packages: resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==} engines: {node: '>=4.0'} - estree-is-function@1.0.0: - resolution: {integrity: sha512-nSCWn1jkSq2QAtkaVLJZY2ezwcFO161HVc174zL1KPW3RJ+O6C3eJb8Nx7OXzvhoEv+nLgSR1g71oWUHUDTrJA==} - - estree-is-member-expression@1.0.0: - resolution: {integrity: sha512-Ec+X44CapIGExvSZN+pGkmr5p7HwUVQoPQSd458Lqwvaf4/61k/invHSh4BYK8OXnCkfEhWuIoG5hayKLQStIg==} - estree-util-attach-comments@2.1.0: resolution: {integrity: sha512-rJz6I4L0GaXYtHpoMScgDIwM0/Vwbu5shbMeER596rB2D1EWF6+Gj0e0UKzJPZrpoOc87+Q2kgVFHfjAymIqmw==} @@ -13979,9 +13515,6 @@ packages: resolution: {integrity: sha512-t12sJlfkxo0Hon6MYCwOd2qliAjGObrnGL6hYXP9h8AiNAVQCiyGrFrqtOH8TIhM0kgaGrq3s/DeZ679Sr8ipw==} hasBin: true - event-emitter@0.3.5: - resolution: {integrity: sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA==} - event-target-shim@5.0.1: resolution: {integrity: sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==} engines: {node: '>=6'} @@ -14024,16 +13557,9 @@ packages: resolution: {integrity: sha512-fvIkb9qZzdMxgZrEQDyll+9oJsyaVvY92I2Re+qK0qEJ+w5s0X3dtz+M0VAPOjP1gtU3iqWyjQ0G3nvd5CLZ2g==} engines: {node: '>=20.0.0'} - evp_bytestokey@1.0.3: - resolution: {integrity: sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==} - evt@2.4.13: resolution: {integrity: sha512-haTVOsmjzk+28zpzvVwan9Zw2rLQF2izgi7BKjAPRzZAfcv+8scL0TpM8MzvGNKFYHiy+Bq3r6FYIIUPl9kt3A==} - execa@4.1.0: - resolution: {integrity: sha512-j5W0//W7f8UxAn8hXVnwG8tLwdiUy4FJLcSupCg6maBYZDpyBvTApK7KyuI4bKj8KOh1r2YH+6ucuYtJv1bTZA==} - engines: {node: '>=10'} - execa@5.1.1: resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==} engines: {node: '>=10'} @@ -14042,9 +13568,6 @@ packages: resolution: {integrity: sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==} engines: {node: '>=16.17'} - execspawn@1.0.1: - resolution: {integrity: sha512-s2k06Jy9i8CUkYe0+DxRlvtkZoOkwwfhB+Xxo5HGUtrISVW2m98jO2tr67DGRFxZwkjQqloA3v/tNtjhBRBieg==} - exit-hook@2.2.1: resolution: {integrity: sha512-eNTPlAD67BmP31LDINZ3U7HSF8l57TxOY2PmBJ1shpCvpnxBF93mWCE8YHBnXs8qiUZJc9WDcWIeC3a2HIAMfw==} engines: {node: '>=6'} @@ -14074,9 +13597,6 @@ packages: exsolve@1.0.7: resolution: {integrity: sha512-VO5fQUzZtI6C+vx4w/4BWJpg3s/5l+6pRQEHzFRM8WFi4XffSP1Z+4qi7GbjWbvRQEbdIco5mIMq+zX4rPuLrw==} - ext@1.7.0: - resolution: {integrity: sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==} - extend@3.0.2: resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==} @@ -14218,10 +13738,6 @@ packages: fft.js@4.0.4: resolution: {integrity: sha512-f9c00hphOgeQTlDyavwTtu6RiK8AIFjD6+jvXkNkpeQ7rirK3uFWVpalkoS4LAwbdX7mfZ8aoBfFVQX1Re/8aw==} - figures@2.0.0: - resolution: {integrity: sha512-Oa2M9atig69ZkfwiApY8F2Yy+tzMbazyvqv21R0NsSC8floSOC09BbT1ITWAdoMGQvJ/aZnR1KMwdx9tvHnTNA==} - engines: {node: '>=4'} - file-entry-cache@6.0.1: resolution: {integrity: sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==} engines: {node: ^10.12.0 || >=12.0.0} @@ -14256,10 +13772,6 @@ packages: resolution: {integrity: sha512-eRoFWQw+Yv2tuYlK2pjFS2jGXSxSppAs3hSQjfxVKxM5amECzIgYYc1FEI8ZmhSh/Ig+FrKEz43NLRKJjYCZVg==} engines: {node: '>=20'} - find-up@3.0.0: - resolution: {integrity: sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==} - engines: {node: '>=6'} - find-up@4.1.0: resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==} engines: {node: '>=8'} @@ -14275,16 +13787,10 @@ packages: find-yarn-workspace-root2@1.2.16: resolution: {integrity: sha512-hr6hb1w8ePMpPVUK39S4RlwJzi+xPLuVuG8XlwXU3KD5Yn3qgBWVfy3AzNlDhWvE1EORCE65/Qm26rFQt3VLVA==} - flame-gradient@1.0.0: - resolution: {integrity: sha512-9ejk16/DqvQJ4dHsh68W/4N0zmVQ60zukyUuEHrTbf5pJvP4JqlIdke86Z9174PZokRCXAntY5+H1txSyC7mUA==} - flat-cache@3.0.4: resolution: {integrity: sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==} engines: {node: ^10.12.0 || >=12.0.0} - flatstr@1.0.12: - resolution: {integrity: sha512-4zPxDyhCyiN2wIAtSLI6gc82/EjqZc1onI4Mz/l0pWrAlsSfYH/2ZIcU+e3oA2wDwbzIWNKwa23F8rh6+DRWkw==} - flatted@3.2.7: resolution: {integrity: sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==} @@ -14300,10 +13806,6 @@ packages: for-each@0.3.3: resolution: {integrity: sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==} - for-each@0.3.5: - resolution: {integrity: sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==} - engines: {node: '>= 0.4'} - foreground-child@3.1.1: resolution: {integrity: sha512-TMKDUnIte6bfb5nWv7V/caI169OHgvwjb7V4WkeUvbQQdjr5rWKqHFiKWb/fcOwB+CzBT+qbWjvj+DVwRskpIg==} engines: {node: '>=14'} @@ -14381,12 +13883,6 @@ packages: resolution: {integrity: sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==} engines: {node: '>= 0.8'} - from2-string@1.1.0: - resolution: {integrity: sha512-m8vCh+KnXXXBtfF2VUbiYlQ+nczLcntB0BrtNgpmLkHylhObe9WF1b2LZjBBzrZzA6P4mkEla6ZYQoOUTG8cYA==} - - from2@2.3.0: - resolution: {integrity: sha512-OMcX/4IC/uqEPVgGeyfN22LJk6AZrMkRZHxcHBMBvHScDGgwTm2GT2Wkgtocyd3JfZffjj2kYUDXXII0Fk9W0g==} - fs-constants@1.0.0: resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==} @@ -14394,10 +13890,6 @@ packages: resolution: {integrity: sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==} engines: {node: '>=12'} - fs-extra@11.3.2: - resolution: {integrity: sha512-Xr9F6z6up6Ws+NjzMCZc6WXg2YFRlrLP9NQDO3VQrWrfiojdhS56TzueT88ze0uBdCTwEIhQ3ptnmKeWGFAe0A==} - engines: {node: '>=14.14'} - fs-extra@7.0.1: resolution: {integrity: sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==} engines: {node: '>=6 <7 || >=8'} @@ -14441,12 +13933,6 @@ packages: functions-have-names@1.2.3: resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==} - generate-function@2.3.1: - resolution: {integrity: sha512-eeB5GfMNeevm/GRYq20ShmsaGcmI81kIX2K9XQx5miC8KdHaC6Jm0qQ8ZNeGOi7wYB8OsdxKs+Y2oVuTFuVwKQ==} - - generate-object-property@1.2.0: - resolution: {integrity: sha512-TuOwZWgJ2VAMEGJvAyPWvpqxSANF0LDpmyHauMjFYzaACvn+QTT/AZomvPCzVBV7yDN3OmwHQ5OvHaeLKre3JQ==} - generic-names@4.0.0: resolution: {integrity: sha512-ySFolZQfw9FoDb3ed9d80Cm9f0+r7qj+HJkWjeD9RBfpxEVTlVhol+gvaQB/78WbwYfbnNh8nWHHBSlg072y6A==} @@ -14454,9 +13940,6 @@ packages: resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==} engines: {node: '>=6.9.0'} - get-assigned-identifiers@1.2.0: - resolution: {integrity: sha512-mBBwmeGTrxEMO4pMaaf/uUEFHnYtwr8FTe8Y/mer4rcV/bye0qGm6pw1bGZFGStxC5O76c5ZAVBGnqHmOaJpdQ==} - get-caller-file@2.0.5: resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==} engines: {node: 6.* || 8.* || >= 10.*} @@ -14578,10 +14061,6 @@ packages: resolution: {integrity: sha512-e1LleDykUz2Iu+MTYdkSsuWX8lvAjAcs0Xef0lNIu0S2wOAzuTxCJtcd9S3cijlwYF18EsU3rzb8jPVobxDh9Q==} engines: {node: '>=16 || 14 >=14.17'} - global-dirs@3.0.1: - resolution: {integrity: sha512-NBcGGFbBA9s1VzD41QXDG+3++t9Mn5t1FpLdhESY6oKY4gYTFpX4wO3sqGUa0Srjtbfj3szX0RnemmrVRUdULA==} - engines: {node: '>=10'} - globals@11.12.0: resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==} engines: {node: '>=4'} @@ -14667,13 +14146,6 @@ packages: resolution: {integrity: sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==} engines: {node: '>=6'} - has-ansi@2.0.0: - resolution: {integrity: sha512-C8vBJ8DwUCx19vhm7urhTuUsr4/IyP6l4VzNQDv+ryHQObW3TTTp9yB68WpYgRe2bbaGuZ/se74IqFeVnMnLZg==} - engines: {node: '>=0.10.0'} - - has-async-hooks@1.0.0: - resolution: {integrity: sha512-YF0VPGjkxr7AyyQQNykX8zK4PvtEDsUJAPqwu06UFz1lb6EvI53sPh5H1kWxg8NXI5LsfRCZ8uX9NkYDZBb/mw==} - has-bigints@1.0.2: resolution: {integrity: sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==} @@ -14708,28 +14180,10 @@ packages: resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==} engines: {node: '>= 0.4'} - has-unicode@2.0.1: - resolution: {integrity: sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==} - - has-yarn@2.1.0: - resolution: {integrity: sha512-UqBRqi4ju7T+TqGNdqAO0PaSVGsDGJUBQvk9eUWNGRY1CFGDzYhLWoM7JQEemnlvVcv/YEmc2wNW8BC24EnUsw==} - engines: {node: '>=8'} - has@1.0.3: resolution: {integrity: sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==} engines: {node: '>= 0.4.0'} - hash-base@3.0.5: - resolution: {integrity: sha512-vXm0l45VbcHEVlTCzs8M+s0VeYsB2lnlAaThoLKGXr3bE/VWDOelNUnycUPEhKEaXARL2TEFjBOyUiM6+55KBg==} - engines: {node: '>= 0.10'} - - hash-base@3.1.2: - resolution: {integrity: sha512-Bb33KbowVTIj5s7Ked1OsqHUeCpz//tPwR+E2zJgJKo9Z5XolZ9b6bdUgjmYlwnWhoOQKoTd1TYToZGn5mAYOg==} - engines: {node: '>= 0.8'} - - hash.js@1.1.7: - resolution: {integrity: sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==} - hasown@2.0.2: resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} engines: {node: '>= 0.4'} @@ -14779,28 +14233,13 @@ packages: hastscript@9.0.1: resolution: {integrity: sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==} - hdr-histogram-js@3.0.1: - resolution: {integrity: sha512-l3GSdZL1Jr1C0kyb461tUjEdrRPZr8Qry7jByltf5JGrA0xvqOSrxRBfcrJqqV/AMEtqqhHhC6w8HW0gn76tRQ==} - engines: {node: '>=14'} - - hdr-histogram-percentiles-obj@3.0.0: - resolution: {integrity: sha512-7kIufnBqdsBGcSZLPJwqHT3yhk1QTsSlFsVD3kx5ixH/AlgBs9yM1q6DPhXZ8f8gtdqgh7N7/5btRLpQsS2gHw==} - hexoid@1.0.0: resolution: {integrity: sha512-QFLV0taWQOZtvIRIAdBChesmogZrtuXvVWsFHZTk2SU+anspqZ2vMnoLg7IE1+Uk16N19APic1BuF8bC8c2m5g==} engines: {node: '>=8'} - hidden-markov-model-tf@4.0.0: - resolution: {integrity: sha512-q8VeBNCyQ5CNsUlbt4T5JXc+pUeKqq7LEGjs4HiH+thgZ2fuyJ9pf/V66ZFx9jZobXkwxVuQRWKZa3TwOFW+zw==} - peerDependencies: - '@tensorflow/tfjs-core': ^3.13.0 - highlight.js@10.7.3: resolution: {integrity: sha512-tzcUFauisWKNHaRkN4Wjl/ZA07gENAjFl3J/c480dprkGTg5EQstgaNFqBfUqCq54kZRIEcreTsAgF/m2quD7A==} - hmac-drbg@1.0.1: - resolution: {integrity: sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg==} - hoist-non-react-statics@3.3.2: resolution: {integrity: sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==} @@ -14815,9 +14254,6 @@ packages: resolution: {integrity: sha512-r0EI+HBMcXadMrugk0GCQ+6BQV39PiWAZVfq7oIckeGiN7sjRGyQxPdft3nQekFTCQbYxLBH+/axZMeH8UX6+w==} engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} - hsl-to-rgb-for-reals@1.1.1: - resolution: {integrity: sha512-LgOWAkrN0rFaQpfdWBQlv/VhkOxb5AsBjk6NQVx4yEzWS923T07X0M1Y0VNko2H52HeSpZrZNNMJ0aFqsdVzQg==} - html-escaper@2.0.2: resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==} @@ -14835,10 +14271,6 @@ packages: html-void-elements@3.0.0: resolution: {integrity: sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==} - htmlescape@1.1.1: - resolution: {integrity: sha512-eVcrzgbR4tim7c7soKQKtxa/kQM4TzjnlU83rcZ9bHU6t31ehfV7SktN6McWgwPWg+JYMA/O3qpGxBvFq1z2Jg==} - engines: {node: '>=0.10'} - htmlparser2@8.0.2: resolution: {integrity: sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==} @@ -14849,9 +14281,6 @@ packages: resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==} engines: {node: '>= 0.8'} - http-parser-js@0.5.10: - resolution: {integrity: sha512-Pysuw9XpUq5dVc/2SMHpuTY01RFl8fttgcyunjL7eEMhGM3cI4eOmiCycJDVCo/7O7ClfQD3SaI6ftDzqOXYMA==} - http-proxy-agent@7.0.2: resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==} engines: {node: '>= 14'} @@ -14860,9 +14289,6 @@ packages: resolution: {integrity: sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ==} engines: {node: '>=0.8', npm: '>=1.3.7'} - https-browserify@1.0.0: - resolution: {integrity: sha512-J+FkSdyD+0mA0N+81tMotaRMfSL9SGi+xpD3T6YApKsc3bGSXJlfXri3VyFOeYkfLRQisDk1W+jIFFKBeUBbBg==} - https-proxy-agent@5.0.1: resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==} engines: {node: '>= 6'} @@ -14874,10 +14300,6 @@ packages: human-id@1.0.2: resolution: {integrity: sha512-UNopramDEhHJD+VR+ehk8rOslwSfByxPIZyJRfV739NDhN5LF1fa1MqnzKm2lGTQRjNrjK19Q5fhkgIfjlVUKw==} - human-signals@1.1.1: - resolution: {integrity: sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw==} - engines: {node: '>=8.12.0'} - human-signals@2.1.0: resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==} engines: {node: '>=10.17.0'} @@ -14892,15 +14314,6 @@ packages: humanize-ms@1.2.1: resolution: {integrity: sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==} - hyperid@3.3.0: - resolution: {integrity: sha512-7qhCVT4MJIoEsNcbhglhdmBKb09QtcmJNiIQGq7js/Khf5FtQQ9bzcAuloeqBeee7XD7JqDeve9KNlQya5tSGQ==} - - hyperscript-attribute-to-property@1.0.2: - resolution: {integrity: sha512-oerMul16jZCmrbNsUw8QgrtDzF8lKgFri1bKQjReLw1IhiiNkI59CWuzZjJDGT79UQ1YiWqXhJMv/tRMVqgtkA==} - - hyperx@2.5.4: - resolution: {integrity: sha512-iOkSh7Yse7lsN/B9y7OsevLWjeXPqGuHQ5SbwaiJM5xAhWFqhoN6erpK1dQsS12OFU36lyai1pnx1mmzWLQqcA==} - hyphenate-style-name@1.0.4: resolution: {integrity: sha512-ygGZLjmXfPHj+ZWh6LwbC37l43MhfztxetbFCoYTM2VjkIUpeHgSNn7QIyVFj7YQ1Wl9Cbw5sholVJPzWvC2MQ==} @@ -14939,10 +14352,6 @@ packages: import-in-the-middle@1.14.2: resolution: {integrity: sha512-5tCuY9BV8ujfOpwtAGgsTx9CGUapcFMEEyByLv1B+v2+6DhAcw+Zr0nhQT7uwaZ7DiourxFEscghOR8e1aPLQw==} - import-lazy@2.1.0: - resolution: {integrity: sha512-m7ZEHgtw69qOGw+jwxXkHlrlIPdTGkyh66zXZ1ajZbxkDBNjSY/LGbmjc7h0s2ELsUDTAhFr55TrPSSqJGPG0A==} - engines: {node: '>=4'} - import-meta-resolve@4.1.0: resolution: {integrity: sha512-I6fiaX09Xivtk+THaMfAwnA3MVA5Big1WHF1Dfx9hFuvNIWpXnorlkzhcQf6ehrqQiiZECRt1poOAkPmer3ruw==} @@ -14962,26 +14371,16 @@ packages: resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==} deprecated: This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful. - inherits@2.0.3: - resolution: {integrity: sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw==} - inherits@2.0.4: resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} ini@1.3.8: resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==} - ini@2.0.0: - resolution: {integrity: sha512-7PnF4oN3CvZF23ADhA5wRaYEQpJ8qygSkbtTXWBeXWXmEVRXK+1ITciHWwHhsjv1TmW0MgacIv6hEi5pX5NQdA==} - engines: {node: '>=10'} - ini@5.0.0: resolution: {integrity: sha512-+N0ngpO3e7cRUWOJAS7qw0IZIVc6XPrW4MlFBdD066F2L4k1L6ker3hLqSq7iXxU5tgS4WGkIUElWn5vogAEnw==} engines: {node: ^18.17.0 || >=20.5.0} - inline-source-map@0.6.3: - resolution: {integrity: sha512-1aVsPEsJWMJq/pdMU61CDlm1URcW702MTB4w9/zUjMus6H/Py8o7g68Pr9D4I6QluWGt/KdmswuRhaA05xVR1w==} - inline-style-parser@0.1.1: resolution: {integrity: sha512-7NXolsK4CAS5+xvdj5OMMbI962hU/wvwoxk+LWR9Ek9bVtyuuYScDN6eS0rUm6TxApFpw7CX1o4uJzcd4AyD3Q==} @@ -14997,18 +14396,6 @@ packages: react: ^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc - inquirer@6.5.2: - resolution: {integrity: sha512-cntlB5ghuB0iuO65Ovoi8ogLHiWGs/5yNrtUcKjFhSSiVeAIVpD7koaSU9RM8mpXw5YDi9RdYXGQMaOURB7ycQ==} - engines: {node: '>=6.0.0'} - - insert-module-globals@7.2.1: - resolution: {integrity: sha512-ufS5Qq9RZN+Bu899eA9QCAYThY+gGW7oRkmb0vC93Vlyu/CFGcH0OYPEjVkDXA5FEbTt1+VWzdoOD3Ny9N+8tg==} - hasBin: true - - insight@0.11.1: - resolution: {integrity: sha512-TBcZ0qC9dgdmcxL93OoqkY/RZXJtIi0i07phX/QyYk2ysmJtZex59dgTj4Doq50N9CG9dLRe/RIudc/5CCoFNw==} - engines: {node: '>=12.20'} - install@0.13.0: resolution: {integrity: sha512-zDml/jzr2PKU9I8J/xyZBQn8rPCAY//UOYNmR01XwNwyfhEWObo2SWfSl1+0tm1u6PhxLwDnfsT/6jB7OUxqFA==} engines: {node: '>= 0.10'} @@ -15050,9 +14437,6 @@ packages: resolution: {integrity: sha512-1DKMMzlIHM02eBBVOFQ1+AolGjs6+xEcM4PDL7NqOS6szq7H9jSaEkIUH6/a5Hl241LzW6JLSiAbNvTQjUupUA==} engines: {node: '>=12.22.0'} - iota-array@1.0.0: - resolution: {integrity: sha512-pZ2xT+LOHckCatGQ3DcG/a+QuEqvoxqkiL7tvE8nn3uuu+f6i1TtpB5/FtWFbxUuVr5PZCx8KskuGatbJDXOWA==} - ip-address@9.0.5: resolution: {integrity: sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==} engines: {node: '>= 12'} @@ -15098,16 +14482,10 @@ packages: resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==} engines: {node: '>=8'} - is-boolean-attribute@0.0.1: - resolution: {integrity: sha512-0kXT52Scokg2Miscvsn5UVqg6y1691vcLJcagie1YHJB4zOEuAhMERLX992jtvaStGy2xQTqOtJhvmG/MK1T5w==} - is-boolean-object@1.1.2: resolution: {integrity: sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==} engines: {node: '>= 0.4'} - is-buffer@1.1.6: - resolution: {integrity: sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==} - is-buffer@2.0.5: resolution: {integrity: sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==} engines: {node: '>=4'} @@ -15116,10 +14494,6 @@ packages: resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==} engines: {node: '>= 0.4'} - is-ci@2.0.0: - resolution: {integrity: sha512-YfJT7rkpQB0updsdHLGWrvhBJfcfzNNawYDNIyQXJz0IViGf75O8EBPKSdvw2rF+LGCsX4FZ8tcr3b19LcZq4w==} - hasBin: true - is-ci@3.0.1: resolution: {integrity: sha512-ZYvCgrefwqoQ6yTyYUbQu64HsITZ3NfKX1lzaEYdkTDcfKzzCI/wthRRYKkdjHKFVgNiXKAKm65Zo1pk2as/QQ==} hasBin: true @@ -15159,14 +14533,6 @@ packages: resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} engines: {node: '>=0.10.0'} - is-fullwidth-code-point@1.0.0: - resolution: {integrity: sha512-1pqUqRjkhPJ9miNq9SwMfdvi6lBJcd6eFxvfaivQhaH3SgisfiuudvFntdKOmxuee/77l+FPjKrQjWvmPjWrRw==} - engines: {node: '>=0.10.0'} - - is-fullwidth-code-point@2.0.0: - resolution: {integrity: sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==} - engines: {node: '>=4'} - is-fullwidth-code-point@3.0.0: resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} engines: {node: '>=8'} @@ -15191,10 +14557,6 @@ packages: engines: {node: '>=14.16'} hasBin: true - is-installed-globally@0.4.0: - resolution: {integrity: sha512-iwGqO3J21aaSkC7jWnHP/difazwS7SFeIqxv6wEtLU8Y5KlzFTjyqcSIT0d8s4+dDhKytsk9PJZ2BkS5eZwQRQ==} - engines: {node: '>=10'} - is-interactive@1.0.0: resolution: {integrity: sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==} engines: {node: '>=8'} @@ -15211,10 +14573,6 @@ packages: resolution: {integrity: sha512-P3fxi10Aji2FZmHTrMPSNFbNC6nnp4U5juPAIjXPHkUNubi4+qK7vvdsaNpAUwXslhYm9oyjEYTxs1xd/+Ph0w==} engines: {node: '>=16'} - is-npm@5.0.0: - resolution: {integrity: sha512-WW/rQLOazUq+ST/bCAVBp/2oMERWLsR7OrKyt052dNDk4DHcDE0/7QSXITlmi+VBcV13DfIbysG3tZJm5RfdBA==} - engines: {node: '>=10'} - is-number-object@1.0.7: resolution: {integrity: sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==} engines: {node: '>= 0.4'} @@ -15223,10 +14581,6 @@ packages: resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} engines: {node: '>=0.12.0'} - is-obj@2.0.0: - resolution: {integrity: sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==} - engines: {node: '>=8'} - is-path-inside@3.0.3: resolution: {integrity: sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==} engines: {node: '>=8'} @@ -15250,9 +14604,6 @@ packages: is-promise@4.0.0: resolution: {integrity: sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==} - is-property@1.0.2: - resolution: {integrity: sha512-Ks/IoX00TtClbGQr4TWXemAnktAQvYB7HzcCxDGqEZU6oCmb2INHuOoKxbtR+HFkmYWBKv/dOZtGRiAjDhj92g==} - is-reference@3.0.3: resolution: {integrity: sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw==} @@ -15295,10 +14646,6 @@ packages: resolution: {integrity: sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==} engines: {node: '>= 0.4'} - is-typed-array@1.1.15: - resolution: {integrity: sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==} - engines: {node: '>= 0.4'} - is-typedarray@1.0.0: resolution: {integrity: sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==} @@ -15317,10 +14664,6 @@ packages: resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==} engines: {node: '>=0.10.0'} - is-wsl@1.1.0: - resolution: {integrity: sha512-gfygJYZ2gLTDlmbWMI0CE2MwnFzSN/2SZfkMlItC4K/JBlsWVDB0bO6XhqcY13YXE7iMcAJnzTCJjPiTeJJ0Mw==} - engines: {node: '>=4'} - is-wsl@2.2.0: resolution: {integrity: sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==} engines: {node: '>=8'} @@ -15329,9 +14672,6 @@ packages: resolution: {integrity: sha512-UcVfVfaK4Sc4m7X3dUSoHoozQGBEFeDC+zVo06t98xe8CzHSZZBekNXH+tu0NalHolcJ/QAGqS46Hef7QXBIMw==} engines: {node: '>=16'} - is-yarn-global@0.3.0: - resolution: {integrity: sha512-VjSeb/lHmkoyd8ryPVIKvOCn4D1koMqY+vqyjjUfc3xyKtP4dYOxM44sZrnqQSzSds3xyOrUTLTC9LVCVgLngw==} - isarray@1.0.0: resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==} @@ -15490,9 +14830,6 @@ packages: json-schema-traverse@1.0.0: resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==} - json-schema-typed@7.0.3: - resolution: {integrity: sha512-7DE8mpG+/fVw+dTpjbxnx47TaMnDfOI1jwft9g1VybltZCduyRQPJPvc+zzKY9WPHxhPWczyFuYa6I8Mw4iU5A==} - json-schema@0.4.0: resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==} @@ -15532,10 +14869,6 @@ packages: jsonify@0.0.1: resolution: {integrity: sha512-2/Ki0GcmuqSrgFyelQq9M05y7PS0mEwuIzrf3f1fPqkVDVRvZrPZtVSMHxdgo8Aq0sxAOb/cr2aqqA3LeWHVPg==} - jsonparse@1.3.1: - resolution: {integrity: sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==} - engines: {'0': node >= 0.2.0} - jsonpath-plus@10.3.0: resolution: {integrity: sha512-8TNmfeTCk2Le33A3vRRwtuworG/L5RrgMvdjhKZxvyShO+mBu2fP50OWUjRLNtvw344DdDarFh9buFAZs5ujeA==} engines: {node: '>=18.0.0'} @@ -15549,11 +14882,6 @@ packages: resolution: {integrity: sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==} engines: {node: '>=0.10.0'} - jsonstream2@3.0.0: - resolution: {integrity: sha512-8ngq2XB8NjYrpe3+Xtl9lFJl6RoV2dNT4I7iyaHwxUpTBwsj0AlAR7epGfeYVP0z4Z7KxMoSxRgJWrd2jmBT/Q==} - engines: {node: '>=5.10.0'} - hasBin: true - jsonwebtoken@9.0.2: resolution: {integrity: sha512-PRp66vJ865SSqOlgqS8hujT5U4AOgMfhrwYIuIhfKaoSCZcirrmASQr8CX7cUg+RMih+hgznrjp99o+W4pJLHQ==} engines: {node: '>=12', npm: '>=6'} @@ -15597,9 +14925,6 @@ packages: kolorist@1.8.0: resolution: {integrity: sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ==} - labeled-stream-splicer@2.0.2: - resolution: {integrity: sha512-Ca4LSXFFZUjPScRaqOcFxneA0VpKZr4MMYCljyQr4LIewTLb3Y0IUTIsnBBsVubIeEfxeSZpSjSsRM8APEQaAw==} - langium@3.3.1: resolution: {integrity: sha512-QJv/h939gDpvT+9SiLVlY7tZC3xB2qK57v0J04Sh9wpMb6MP1q8gB21L3WIo8T5P1MSMg3Ep14L7KkDCFG3y4w==} engines: {node: '>=16.0.0'} @@ -15618,10 +14943,6 @@ packages: language-tags@1.0.5: resolution: {integrity: sha512-qJhlO9cGXi6hBGKoxEG/sKZDAHD5Hnu9Hs4WbOY3pCWXDhw0N8x1NenNzm2EnNLkLkk7J2SdxAkDSbb6ftT+UQ==} - latest-version@5.1.0: - resolution: {integrity: sha512-weT+r0kTkRQdCdYCNtkMwWXQTMEswKrFBkm4ckQOMVhhqhIMI1UT2hMj+1iigIhgSZm5gTmrRXBNoGUgaTY1xA==} - engines: {node: '>=8'} - layerr@2.0.1: resolution: {integrity: sha512-z0730CwG/JO24evdORnyDkwG1Q7b7mF2Tp1qRQ0YvrMMARbt1DFG694SOv439Gm7hYKolyZyaB49YIrYIfZBdg==} @@ -15692,14 +15013,6 @@ packages: resolution: {integrity: sha512-HJp37y62j3j8qzAOODWuUJl4ysLwsDvCTBV6odr3jIRHR/a5e+tI14VQGIBcpK9ysqC3pGWyW5Rp9Jv1YDubyw==} hasBin: true - leven@2.1.0: - resolution: {integrity: sha512-nvVPLpIHUxCUoRLrFqTgSxXJ614d8AgQoWl7zPe/2VadE8+1dpU3LBhowRuBAcuwruWtOdD8oYC9jDNJjXDPyA==} - engines: {node: '>=0.10.0'} - - levn@0.3.0: - resolution: {integrity: sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA==} - engines: {node: '>= 0.8.0'} - levn@0.4.1: resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==} engines: {node: '>= 0.8.0'} @@ -15824,10 +15137,6 @@ packages: locate-character@3.0.0: resolution: {integrity: sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA==} - locate-path@3.0.0: - resolution: {integrity: sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==} - engines: {node: '>=6'} - locate-path@5.0.0: resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==} engines: {node: '>=8'} @@ -15849,12 +15158,6 @@ packages: lodash.castarray@4.4.0: resolution: {integrity: sha512-aVx8ztPv7/2ULbArGJ2Y42bG1mEQ5mGjpdvrbJcJFU3TbYybe+QlLS4pst9zV52ymy2in1KpFPiZnAOATxD4+Q==} - lodash.chunk@4.2.0: - resolution: {integrity: sha512-ZzydJKfUHJwHa+hF5X66zLFCBrWn5GeF28OHEr4WVWtNDXlQ/IjWKPBiikqKo2ne0+v6JgCgJ0GzJp8k8bHC7w==} - - lodash.clonedeep@4.5.0: - resolution: {integrity: sha512-H5ZhCF25riFd9uB5UCkVKo61m3S/xZk1x4wA6yp/L3RFP6Z/eHH1ymQcGLo7J3GMPfm0V/7m1tryHuGVxpqEBQ==} - lodash.debounce@4.0.8: resolution: {integrity: sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==} @@ -15864,9 +15167,6 @@ packages: lodash.escaperegexp@4.1.2: resolution: {integrity: sha512-TM9YBvyC84ZxE3rgfefxUWiQKLilstD6k7PTGt6wfbtXF8ixIJLOL3VYyV/z+ZiPLsVxAsKAFVwWlWeb2Y8Yyw==} - lodash.flatten@4.4.0: - resolution: {integrity: sha512-C5N2Z3DgnnKr0LOpv/hKCgKdb7ZZwafIrsesve6lmzvZIRZRGaZ/l6Q8+2W7NaT+ZwO3fFlSCzCzrDCFdJfZ4g==} - lodash.groupby@4.6.0: resolution: {integrity: sha512-5dcWxm23+VAoz+awKmBaiBvzox8+RqMgFhi7UvX9DHZr2HdxHXM/Wrf8cfKpsW37RNrvtPn6hSwNqurSILbmJw==} @@ -15900,9 +15200,6 @@ packages: lodash.isundefined@3.0.1: resolution: {integrity: sha512-MXB1is3s899/cD8jheYYE2V9qTHwKvt+npCwpD+1Sxm3Q3cECXCiYHjeHWXNwr6Q0SOBPrYUDxendrO6goVTEA==} - lodash.memoize@3.0.4: - resolution: {integrity: sha512-eDn9kqrAmVUC1wmZvlQ6Uhde44n+tXpqPrN8olQJbttgh0oKclk+SF54P47VEGE9CEiMeRwAP8BaM7UHvBkz2A==} - lodash.merge@4.6.2: resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==} @@ -15932,9 +15229,6 @@ packages: resolution: {integrity: sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==} engines: {node: '>=10'} - long@4.0.0: - resolution: {integrity: sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA==} - long@5.2.3: resolution: {integrity: sha512-lcHwpNoggQTObv5apGNCTdJrO69eHOZMi4BNC+rTLER8iHAqGrUVeLh/irVIM7zTw2bOXA8T6uNPeujwOLg/2Q==} @@ -15948,9 +15242,6 @@ packages: loupe@3.1.3: resolution: {integrity: sha512-kkIp7XSkP78ZxJEsSxW3712C6teJVoeHHwgo9zJ380de7IYyJ2ISlxojcH2pC5OFLewESmnRi/+XCDIEEVyoug==} - lower-case@1.1.4: - resolution: {integrity: sha512-2Fgx1Ycm599x+WGpIYwJOvsjmXFzTSc34IwDWALRA/8AopUKAVPwfJ+h5+f85BCp0PWmmJcWzEpxOpoXycMpdA==} - lowercase-keys@1.0.1: resolution: {integrity: sha512-G2Lj61tXDnVFFOi8VZds+SoQjtQC3dgokKdDG2mTm1tx4m50NUHBOZSBwQQHyy0V12A0JTG4icfZQH+xPyh8VA==} engines: {node: '>=0.10.0'} @@ -16013,16 +15304,6 @@ packages: resolution: {integrity: sha512-0ckx7ZHRPqb0oUm8zNr+90mtf9DQB60H1wMCjBtfi62Kl3a7JbHob6gA2bC+xRvZoOL+1hzUK8jeuEIQE8svEQ==} hasBin: true - macos-release@2.5.1: - resolution: {integrity: sha512-DXqXhEM7gW59OjZO8NIjBCz9AQ1BEMrfiOAl4AYByHCtVHRF4KoGNO8mqQeM8lRCtQe/UnJ4imO/d2HdkKsd+A==} - engines: {node: '>=6'} - - magic-string@0.23.2: - resolution: {integrity: sha512-oIUZaAxbcxYIp4AyLafV6OVKoB3YouZs0UTCJ8mOKBHNyJgGDaMJ4TgA+VylJh6fx7EQCC52XkbURxxG9IoJXA==} - - magic-string@0.25.1: - resolution: {integrity: sha512-sCuTz6pYom8Rlt4ISPFn6wuFodbKMIHUMv4Qko9P17dpxb7s52KJTmRuZZqHdGmLCK9AOcDare039nRIcfdkEg==} - magic-string@0.30.17: resolution: {integrity: sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==} @@ -16035,17 +15316,10 @@ packages: magicast@0.3.5: resolution: {integrity: sha512-L0WhttDl+2BOsybvEOLK7fW3UA0OQ0IQ2d6Zl2x/a6vVRs3bAY0ECOSHHeL5jD+SbOpOCUEi0y1DgHEn9Qn1AQ==} - make-dir@3.1.0: - resolution: {integrity: sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==} - engines: {node: '>=8'} - make-dir@4.0.0: resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==} engines: {node: '>=10'} - manage-path@2.0.0: - resolution: {integrity: sha512-NJhyB+PJYTpxhxZJ3lecIGgh4kwIY2RAh44XvAz9UlqthlQwtPBf62uBVR8XaD8CRuSjQ6TnZH2lNJkbLPZM2A==} - map-obj@1.0.1: resolution: {integrity: sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg==} engines: {node: '>=0.10.0'} @@ -16103,9 +15377,6 @@ packages: peerDependencies: react: 18.x - md5.js@1.3.5: - resolution: {integrity: sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==} - mdast-util-definitions@5.1.1: resolution: {integrity: sha512-rQ+Gv7mHttxHOBx2dkF4HWTg+EE+UR78ptQWDylzPKaQuVGdG4HIoY3SrS/pCp80nZ04greFvXbVFHT+uf0JVQ==} @@ -16220,9 +15491,6 @@ packages: resolution: {integrity: sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==} engines: {node: '>=18'} - merge-source-map@1.0.4: - resolution: {integrity: sha512-PGSmS0kfnTnMJCzJ16BLLCEe6oeYCamKFFdQKshi4BmM6FUwipjVOcBFGxqtQtirtAG4iZvHlqST9CpZKqlRjA==} - merge-stream@2.0.0: resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==} @@ -16415,10 +15683,6 @@ packages: resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==} engines: {node: '>=8.6'} - miller-rabin@4.0.1: - resolution: {integrity: sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==} - hasBin: true - mime-db@1.52.0: resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==} engines: {node: '>= 0.6'} @@ -16450,18 +15714,10 @@ packages: engines: {node: '>=10.0.0'} hasBin: true - mimic-fn@1.2.0: - resolution: {integrity: sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==} - engines: {node: '>=4'} - mimic-fn@2.1.0: resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==} engines: {node: '>=6'} - mimic-fn@3.1.0: - resolution: {integrity: sha512-Ysbi9uYW9hFyfrThdDEQuykN4Ey6BuwPD2kpI5ES/nFTDn/98yxYNLZJcgUAKPT/mcrLLKaGzJR9YVxJrIdASQ==} - engines: {node: '>=8'} - mimic-fn@4.0.0: resolution: {integrity: sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==} engines: {node: '>=12'} @@ -16482,22 +15738,12 @@ packages: resolution: {integrity: sha512-r9deDe9p5FJUPZAk3A59wGH7Ii9YrjjWw0jmw/liSbHl2CHiyXj6FcDXDu2K3TjVAXqiJdaw3xxwlZZr9E6nHg==} hasBin: true - minify-stream@2.1.0: - resolution: {integrity: sha512-P5xE4EQRkn7Td54VGcgfDMFx1jmKPPIXCdcMfrbXS6cNHK4dO1LXwtYFb48hHrSmZfT+jlGImvHgSZEkbpNtCw==} - engines: {node: '>= 6'} - minimal-polyfills@2.2.2: resolution: {integrity: sha512-eEOUq/LH/DbLWihrxUP050Wi7H/N/I2dQT98Ep6SqOpmIbk4sXOI4wqalve66QoZa+6oljbZWU6I6T4dehQGmw==} minimal-polyfills@2.2.3: resolution: {integrity: sha512-oxdmJ9cL+xV72h0xYxp4tP2d5/fTBpP45H8DIOn9pASuF8a3IYTf+25fMGDYGiWW+MFsuog6KD6nfmhZJQ+uUw==} - minimalistic-assert@1.0.1: - resolution: {integrity: sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==} - - minimalistic-crypto-utils@1.0.1: - resolution: {integrity: sha512-JIYlbt6g8i5jKfJ3xz7rF0LXmv2TkDxBLUkiBeZ7bAx4GnnNMr8xFpGnOxn6GhTEHx3SjRrZEoU+j04prX1ktg==} - minimatch@10.0.1: resolution: {integrity: sha512-ethXTt3SGGR+95gudmqJ1eNhRO7eGEGIgYA9vnPatK4/etz2MEVDno5GMCibdMTuBMyElzIlgxMna3K94XDIDQ==} engines: {node: 20 || >=22} @@ -16597,30 +15843,12 @@ packages: ml-array-rescale@1.3.7: resolution: {integrity: sha512-48NGChTouvEo9KBctDfHC3udWnQKNKEWN0ziELvY3KG25GR5cA8K8wNVzracsqSW1QEkAXjTNx+ycgAv06/1mQ==} - ml-distance-euclidean@2.0.0: - resolution: {integrity: sha512-yC9/2o8QF0A3m/0IXqCTXCzz2pNEzvmcE/9HFKOZGnTjatvBbsn4lWYJkxENkA4Ug2fnYl7PXQxnPi21sgMy/Q==} - - ml-kmeans@4.2.1: - resolution: {integrity: sha512-MyXoWfDuoH+eYjPCIvfMXBuQ0K473APoc57oeFSFcGCHPZuppVv8cQKnhxYb8ZDEMN47MgcPtcHmueTeq6JmVQ==} - - ml-matrix@5.3.0: - resolution: {integrity: sha512-DuvdXYwfGRpM+7MVdvi/zSjiazn+8QPrACT3Xi0pQpYx5SXZ1WuFYwUDXTSmV9+hrCxRhrC4hrzesNcfjpvOsw==} - ml-matrix@6.12.1: resolution: {integrity: sha512-TJ+8eOFdp+INvzR4zAuwBQJznDUfktMtOB6g/hUcGh3rcyjxbz4Te57Pgri8Q9bhSQ7Zys4IYOGhFdnlgeB6Lw==} - ml-nearest-vector@2.0.1: - resolution: {integrity: sha512-gMPwNm3eed59ewJYiCK/+wElWBfNoD6JizH965ePiQgCo0pvQL63w4YdZhLs5eUV0iWcq6brVMUBL6iMySHnqg==} - - ml-random@0.5.0: - resolution: {integrity: sha512-zLJBmNb34LOz+vN6BD8l3aYm/VWYWbmAunrLMPs4dHf4gTl8BWlhil72j56HubPg86zrXioIs4qoHq7Topy6tw==} - ml-spectra-processing@14.13.0: resolution: {integrity: sha512-AZPE+XrBoRhSRwzUm0IbiQlAPbetDtndDnoq9VO/SzRkN82wrxJpU+urH4aaFVnxTJhxtGOI81FiAxjFe7xQtQ==} - ml-xsadd@2.0.0: - resolution: {integrity: sha512-VoAYUqmPRmzKbbqRejjqceGFp3VF81Qe8XXFGU0UXLxB7Mf4GGvyGq5Qn3k4AiQgDEV6WzobqlPOd+j0+m6IrA==} - ml-xsadd@3.0.1: resolution: {integrity: sha512-Fz2q6dwgzGM8wYKGArTUTZDGa4lQFA2Vi6orjGeTVRy22ZnQFKlJuwS9n8NRviqz1KHAHAzdKJwbnYhdo38uYg==} @@ -16630,11 +15858,6 @@ packages: mlly@1.7.4: resolution: {integrity: sha512-qmdSIPC4bDJXgZTCR7XosJiNKySV7O215tsPtDN9iEO/7q/76b/ijtgRu/+epFXSJhijtTCCGp3DWS549P3xKw==} - module-deps@6.2.3: - resolution: {integrity: sha512-fg7OZaQBcL4/L+AK5f4iVqf9OMbCclXfy/znXRxTVhJSeW5AIlS9AwheYwDaXM3lVW7OBeaeUEY3gbaC6cLlSA==} - engines: {node: '>= 0.8.0'} - hasBin: true - module-details-from-path@1.0.3: resolution: {integrity: sha512-ySViT69/76t8VhE1xXHK6Ch4NcDd26gx0MzKXLO+F7NOtnqH68d9zF94nT8ZWSxXh8ELOERsnJO/sWt1xZYw5A==} @@ -16645,9 +15868,6 @@ packages: resolution: {integrity: sha512-AbegBVI4sh6El+1gNwvD5YIck7nSA36weD7xvIxG4in80j/UoK8AEGaWnnz8v1GxonMCltmlNs5ZKbGvl9b1XQ==} engines: {node: '>= 0.8.0'} - morphdom@2.7.7: - resolution: {integrity: sha512-04GmsiBcalrSCNmzfo+UjU8tt3PhZJKzcOy+r1FlGA7/zri8wre3I1WkYN9PT3sIeIKfW9bpyElA+VzOg2E24g==} - mri@1.2.0: resolution: {integrity: sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==} engines: {node: '>=4'} @@ -16672,19 +15892,10 @@ packages: multipasta@0.2.5: resolution: {integrity: sha512-c8eMDb1WwZcE02WVjHoOmUVk7fnKU/RmUcosHACglrWAuPQsEJv+E8430sXj6jNc1jHw0zrS16aCjQh4BcEb4A==} - multistream@2.1.1: - resolution: {integrity: sha512-xasv76hl6nr1dEy3lPvy7Ej7K/Lx3O/FCvwge8PeVJpciPPoNCbaANcNiBug3IpdvTveZUcAV0DJzdnUDMesNQ==} - mustache@4.2.0: resolution: {integrity: sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==} hasBin: true - mute-stream@0.0.7: - resolution: {integrity: sha512-r65nCZhrbXXb6dXOACihYApHw2Q6pV0M3V0PSxd74N0+D8nzAdEAITq2oAjA1jVnKI+tGvEBUpqiMh0+rW6zDQ==} - - mutexify@1.4.0: - resolution: {integrity: sha512-pbYSsOrSB/AKN5h/WzzLRMFgZhClWccf2XIB4RSMC8JbquiB0e0/SH5AIfdQMdyHmYtv4seU7yV/TvAwPLJ1Yg==} - mz@2.7.0: resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==} @@ -16697,16 +15908,6 @@ packages: react: '*' react-dom: '*' - nanoassert@1.1.0: - resolution: {integrity: sha512-C40jQ3NzfkP53NsO8kEOFd79p4b9kDXQMwgiY1z8ZwrDZgUyom0AHwGegF4Dm99L+YoYhuaB0ceerUcXmqr1rQ==} - - nanobench@2.1.1: - resolution: {integrity: sha512-z+Vv7zElcjN+OpzAxAquUayFLGK3JI/ubCl0Oh64YQqsTGG09CGqieJVQw4ui8huDnnAgrvTv93qi5UaOoNj8A==} - hasBin: true - - nanohtml@1.10.0: - resolution: {integrity: sha512-r/3AQl+jxAxUIJRiKExUjBtFcE1cm4yTOsTIdVqqlxPNtBxJh522ANrcQYzdNHhPzbPgb7j6qujq6eGehBX0kg==} - nanoid@3.3.11: resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==} engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1} @@ -16741,33 +15942,6 @@ packages: natural-compare@1.4.0: resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==} - ndarray-blas-level1@1.1.3: - resolution: {integrity: sha512-g0Qzf+W0J2S/w1GeYlGuFjGRGGE+f+u8x4O8lhBtsrCaf++n/+YLTPKk1tovYmciL3zUePmwi/szoP5oj8zQvg==} - - ndarray-cholesky-factorization@1.0.2: - resolution: {integrity: sha512-8mXl8mMCDgv9plZem0ifolu39hHYu+IchdBX39VWS8X3f4935JDq5uGpxOJr2gXiy7QgY6MglAmoCjyHRWyqlQ==} - - ndarray-crout-decomposition@1.1.0: - resolution: {integrity: sha512-jcww9T/4thrVvBDCk5PivUScolTW1Lu6QWzvrxHMHAhZzTUzznvT/U/xfn40EfseiITLkHlST/0df5pn2yQHUQ==} - - ndarray-determinant@1.0.0: - resolution: {integrity: sha512-fJUlUhFZHwKP0lFsF2Si14dnkXBoiqKVzlv2nsUAcycsjjpuUkJGF0SXLHbRgl1wI6sgordV4P86bJ4ulcR6Yw==} - - ndarray-diagonal@1.0.0: - resolution: {integrity: sha512-r+LgakWgIt9xiRES42fwP6nc3pn4DjGSrs+OCPqiVTxtzCJ2L31KFypcHplSXG008j0IWZt6bx1+ZRbx+aQkfA==} - - ndarray-inv@0.2.0: - resolution: {integrity: sha512-rl+5PMUrP3WCYktFOK3myIiOwA6Q1oQddvQl2TN0tROcTXciCakha0QRMdE5t8ywlkbp1rmIKtWKFrEO7BAEUQ==} - - ndarray-ops@1.2.2: - resolution: {integrity: sha512-BppWAFRjMYF7N/r6Ie51q6D4fs0iiGmeXIACKY66fLpnwIui3Wc3CXiD/30mgLbDjPpSLrsqcp3Z62+IcHZsDw==} - - ndarray-scratch@1.2.0: - resolution: {integrity: sha512-a4pASwB1jQyJcKLYrwrladVfDZDUGc78qLJZbHyb1Q4rhte0URhzc6ALQpBcauwgov0sXLwZz3vYH5jKAhSMIg==} - - ndarray@1.0.19: - resolution: {integrity: sha512-B4JHA4vdyZU30ELBw3g7/p9bZupyew5a7tX1Y/gGeF2hafrPaQZhgrGQfsvgfYbgdFZjYwuEcnaobeM/WMW+HQ==} - nearley@2.20.1: resolution: {integrity: sha512-+Mc8UaAebFzgV+KpI5n7DasuuQCHA89dmwm7JXw3TV43ukfNQ9DnBH3Mdb2g/I4Fdxc26pwimBWvjIw0UAILSQ==} hasBin: true @@ -16794,9 +15968,6 @@ packages: resolution: {integrity: sha512-kOCT/1MCPAxY5iUV3wytNFUMUolzuwd/VF/1KCx7kf6CutrOsTie+84zTGTpgQycjvfLdBBdvBvFLqFD2c0wkQ==} engines: {node: '>=18'} - next-tick@1.1.0: - resolution: {integrity: sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==} - next@14.1.0: resolution: {integrity: sha512-wlzrsbfeSU48YQBjZhDzOwhWhGsy+uQycR8bHAOt1LY1bn3zZEcDyHQOEoN3aWzQ8LHCAJ1nqrWCc9XF2+O45Q==} engines: {node: '>=18.17.0'} @@ -16898,9 +16069,6 @@ packages: nice-try@1.0.5: resolution: {integrity: sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==} - no-case@2.3.2: - resolution: {integrity: sha512-rmTZ9kz+f3rCvK2TD1Ue/oZlns7OGoIWP4fc3llxxRXlOkHKoWPPWJOfFYpITabSow43QJbRIoHQXtt10VldyQ==} - node-abi@3.75.0: resolution: {integrity: sha512-OhYaY5sDsIka7H7AtijtI9jwGYLyl29eQn/W623DiN/MIv5sUqc4g7BIDThX+gb7di9f6xK02nkp8sdfFWZLTg==} engines: {node: '>=10'} @@ -16966,10 +16134,6 @@ packages: engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} hasBin: true - normalize-html-whitespace@0.2.0: - resolution: {integrity: sha512-5CZAEQ4bQi8Msqw0GAT6rrkrjNN4ZKqAG3+jJMwms4O6XoMvh6ekwOueG4mRS1LbPUR1r9EdnhxxfpzMTOdzKw==} - engines: {node: '>= 0.10'} - normalize-package-data@2.5.0: resolution: {integrity: sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==} @@ -17027,10 +16191,6 @@ packages: num2fraction@1.2.2: resolution: {integrity: sha512-Y1wZESM7VUThYY+4W+X4ySH2maqcA+p7UR+w8VWNWVAd6lwuXXWz/w/Cz43J/dI2I+PS6wD5N+bJUF+gjWvIqg==} - number-is-nan@1.0.1: - resolution: {integrity: sha512-4jbtZXNAsfZbAHiiqjLPBiCl16dES1zI4Hpzzxw61Tk+loF+sBDBKx1ICKKKwIqQ7M0mFn1TmkN7euSncWgHiQ==} - engines: {node: '>=0.10.0'} - nypm@0.3.9: resolution: {integrity: sha512-BI2SdqqTHg2d4wJh8P9A1W+bslg33vOE9IZDY6eR2QC+Pu1iNBVZUqczrd43rJb+fMzHU7ltAYKsEFY/kHMFcw==} engines: {node: ^14.16.0 || >=16.10.0} @@ -17136,17 +16296,9 @@ packages: resolution: {integrity: sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA==} engines: {node: '>= 0.8'} - on-net-listen@1.1.2: - resolution: {integrity: sha512-y1HRYy8s/RlcBvDUwKXSmkODMdx4KSuIvloCnQYJ2LdBBC1asY4HtfhXwe3UWknLakATZDnbzht2Ijw3M1EqFg==} - engines: {node: '>=9.4.0 || ^8.9.4'} - once@1.4.0: resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==} - onetime@2.0.1: - resolution: {integrity: sha512-oyyPpiMaKARvvcgip+JV+7zci5L8D1W9RZIz2l1o08AM3pfspitVWnPt3mzHcBPp12oYMTy0pqrFs/C+m3EwsQ==} - engines: {node: '>=4'} - onetime@5.1.2: resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==} engines: {node: '>=6'} @@ -17165,10 +16317,6 @@ packages: resolution: {integrity: sha512-dtbI5oW7987hwC9qjJTyABldTaa19SuyJse1QboWv3b0qCcrrLNVDqBx1XgELAjh9QTVQaP/C5b1nhQebd1H2A==} engines: {node: '>=18'} - open@7.4.2: - resolution: {integrity: sha512-MVHddDVweXZF3awtlAS+6pgKLlm/JgxZ90+/NBurBoQctVOOB/zDdVjcyPzQ+0laDGbsWgrRkflI65sQeOgT9Q==} - engines: {node: '>=8'} - open@8.4.0: resolution: {integrity: sha512-XgFPPM+B28FtCCgSb9I+s9szOC1vZRSwgWsRUA5ylIxRTgKozqjOCrVOqGsYABPYK5qnfqClxZTFBa8PKt2v6Q==} engines: {node: '>=12'} @@ -17214,14 +16362,6 @@ packages: openid-client@6.3.3: resolution: {integrity: sha512-lTK8AV8SjqCM4qznLX0asVESAwzV39XTVdfMAM185ekuaZCnkWdPzcxMTXNlsm9tsUAMa1Q30MBmKAykdT1LWw==} - opn@5.5.0: - resolution: {integrity: sha512-PqHpggC9bLV0VeWcdKhkpxY+3JTzetLSqTCWL/z/tFIbI6G8JCjondXklT1JinczLz2Xib62sSp0T/gKT4KksA==} - engines: {node: '>=4'} - - optionator@0.8.3: - resolution: {integrity: sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==} - engines: {node: '>= 0.8.0'} - optionator@0.9.1: resolution: {integrity: sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==} engines: {node: '>= 0.8.0'} @@ -17230,13 +16370,6 @@ packages: resolution: {integrity: sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==} engines: {node: '>=10'} - os-browserify@0.3.0: - resolution: {integrity: sha512-gjcpUc3clBf9+210TRaDWbf+rZZZEshZ+DlXMRCeAjp0xhTrnQsKHypIy1J3d5hKdUzj69t708EHtU8P6bUn0A==} - - os-name@4.0.1: - resolution: {integrity: sha512-xl9MAoU97MH1Xt5K9ERft2YfCAoaO6msy1OBA0ozxEC0x0TmIoE6K3QvgJMMZA9yKGLmHXNY/YZoDbiGDj4zYw==} - engines: {node: '>=10'} - os-paths@7.4.0: resolution: {integrity: sha512-Ux1J4NUqC6tZayBqLN1kUlDAEvLiQlli/53sSddU4IN+h+3xxnv2HmRSMpVSvr1hvJzotfMs3ERvETGK+f4OwA==} engines: {node: '>= 4.0'} @@ -17287,10 +16420,6 @@ packages: resolution: {integrity: sha512-kuUqqHNUqoIWp/c467RI4X6mmyuojY5jGutNU0wVTmEOOfcuwLqyMVoAi9MKi2Ak+5i9+nhmrK4ufZE8069kHA==} engines: {node: '>=18'} - p-locate@3.0.0: - resolution: {integrity: sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==} - engines: {node: '>=6'} - p-locate@4.1.0: resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==} engines: {node: '>=8'} @@ -17372,20 +16501,10 @@ packages: pako@0.2.9: resolution: {integrity: sha512-NUcwaKxUxWrZLpDG+z/xZaCgQITkA/Dv4V/T6bw7VON6l1Xz/VnrBqrYjZQ12TamKHzITTfOEIYUj48y2KXImA==} - pako@1.0.11: - resolution: {integrity: sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==} - parent-module@1.0.1: resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==} engines: {node: '>=6'} - parents@1.0.1: - resolution: {integrity: sha512-mXKF3xkoUt5td2DoxpLmtOmZvko9VfFpwRwkKDHSNvgmpLAeBo18YDhcPbBzJq+QLCHMbGOfzia2cX4U+0v9Mg==} - - parse-asn1@5.1.9: - resolution: {integrity: sha512-fIYNuZ/HastSb80baGOuPRo1O9cf4baWw5WsAp7dBuUzeTD/BoaG8sVTdlPFksBE2lF21dN+A1AnrpIjSWqHHg==} - engines: {node: '>= 0.10'} - parse-duration@2.1.4: resolution: {integrity: sha512-b98m6MsCh+akxfyoz9w9dt0AlH2dfYLOBss5SdDsr9pkhKNvkWBXU/r8A4ahmIGByBOLV2+4YwfCuFxbDDaGyg==} @@ -17431,16 +16550,9 @@ packages: partysocket@1.0.2: resolution: {integrity: sha512-rAFOUKImaq+VBk2B+2RTBsWEvlnarEP53nchoUHzpVs8V6fG2/estihOTslTQUWHVuHEKDL5k8htG8K3TngyFA==} - path-browserify@1.0.1: - resolution: {integrity: sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==} - path-data-parser@0.1.0: resolution: {integrity: sha512-NOnmBpt5Y2RWbuv0LMzsayp3lVylAHLPUTut412ZA3l+C4uw4ZVkQbjShYCQ8TCpUMdPapr4YjUqLYD6v68j+w==} - path-exists@3.0.0: - resolution: {integrity: sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==} - engines: {node: '>=4'} - path-exists@4.0.0: resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} engines: {node: '>=8'} @@ -17468,10 +16580,6 @@ packages: path-parse@1.0.7: resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==} - path-platform@0.11.15: - resolution: {integrity: sha512-Y30dB6rab1A/nfEKsZxmr01nUotHX0c/ZiIAsCTatEe1CmS5Pm5He7fZ195bPT7RdquoaL8lLxFCMQi/bS7IJg==} - engines: {node: '>= 0.8.0'} - path-scurry@1.11.1: resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==} engines: {node: '>=16 || 14 >=14.18'} @@ -17505,10 +16613,6 @@ packages: resolution: {integrity: sha512-vE7JKRyES09KiunauX7nd2Q9/L7lhok4smP9RZTDeD4MVs72Dp2qNFVz39Nz5a0FVEW0BJR6C0DYrq6unoziZA==} engines: {node: '>= 14.16'} - pbkdf2@3.1.5: - resolution: {integrity: sha512-Q3CG/cYvCO1ye4QKkuH7EXxs3VC/rI1/trd+qX2+PolbaKG0H+bgcZzrTt96mMyRtejk+JMCiLUn3y29W8qmFQ==} - engines: {node: '>= 0.10'} - peberminta@0.9.0: resolution: {integrity: sha512-XIxfHpEuSJbITd1H3EeQwpcZbTLHc+VVr8ANI9t5sit565tsI4/xK3KWTUFE2e6QiangUkh3B0jihzmGnNrRsQ==} @@ -17686,10 +16790,6 @@ packages: pkg-types@2.3.0: resolution: {integrity: sha512-SIqCzDRg0s9npO5XQ3tNZioRY1uK06lA41ynBC1YmFTmnY6FjUjVt6s4LoADmwoig1qqD0oK8h1p/8mlMx8Oig==} - pkg-up@3.1.0: - resolution: {integrity: sha512-nDywThFk1i4BQK4twPQ6TA4RT8bDY96yeuCVBWL3ePARCiEKDRSrNGbFIgUJpLp+XeIR65v8ra7WuJOFUBtkMA==} - engines: {node: '>=8'} - platform@1.3.6: resolution: {integrity: sha512-fnWVljUchTro6RiCFvCXBbNhJc2NijN7oIQxbwsyL0buWJPG85v81ehlHI9fXrJsMNgTofEoWIQeClKpgxFLrg==} @@ -17724,12 +16824,6 @@ packages: postcss-functions@3.0.0: resolution: {integrity: sha512-N5yWXWKA+uhpLQ9ZhBRl2bIAdM6oVJYpDojuI1nF2SzXBimJcdjFwiAouBVbO5VuOF3qA6BSFWFc3wXbbj72XQ==} - postcss-import@13.0.0: - resolution: {integrity: sha512-LPUbm3ytpYopwQQjqgUH4S3EM/Gb9QsaSPP/5vnoi+oKVy3/mIk2sc0Paqw7RL57GpScm9MdIMUypw2znWiBpg==} - engines: {node: '>=10.0.0'} - peerDependencies: - postcss: ^8.0.0 - postcss-import@15.1.0: resolution: {integrity: sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==} engines: {node: '>=14.0.0'} @@ -17938,10 +17032,6 @@ packages: resolution: {integrity: sha512-+wZgbxNES/KlJs9q40F/1sfOd/j7f1O9JaHcW5Dsn3aUUOZg3L2bjpVUcKV2jvtElYfoTuQiNeMfQJ4kwUAhCQ==} engines: {node: '>=10'} - prelude-ls@1.1.2: - resolution: {integrity: sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w==} - engines: {node: '>= 0.8.0'} - prelude-ls@1.2.1: resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==} engines: {node: '>= 0.8.0'} @@ -18012,10 +17102,6 @@ packages: engines: {node: '>=14'} hasBin: true - pretty-bytes@5.6.0: - resolution: {integrity: sha512-FFw039TmrBqFK8ma/7OL3sDz/VytdtJr044/QUJtH0wK9lb9jLq9tJyIxUwtQJHwar2BqtiA4iCWSwo9JLkzFg==} - engines: {node: '>=6'} - pretty-format@27.5.1: resolution: {integrity: sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==} engines: {node: ^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0} @@ -18152,16 +17238,6 @@ packages: resolution: {integrity: sha512-RXyHaACeqXeqAKGLDl68rQKbmObRsTIn4TYVUUug1KfS47YWCo5MacGITEryugIgZqORCvJWEk4l449POg5Txg==} engines: {node: '>=12.0.0'} - protocol-buffers-encodings@1.2.0: - resolution: {integrity: sha512-daeNPuKh1NlLD1uDfbLpD+xyUTc07nEtfHwmBZmt/vH0B7VOM+JOCOpDcx9ZRpqHjAiIkGqyTDi+wfGSl17R9w==} - - protocol-buffers-schema@3.6.0: - resolution: {integrity: sha512-TdDRD+/QNdrCGCE7v8340QyuXd4kIWIgapsE2+n/SaGiSSbomYl4TjHlvIoCWRpE7wFt02EpB35VVA2ImcBVqw==} - - protocol-buffers@4.2.0: - resolution: {integrity: sha512-hNp56d5uuREVde7UqP+dmBkwzxrhJwYU5nL/mdivyFfkRZdgAgojkyBeU3jKo7ZHrjdSx6Q1CwUmYJI6INt20g==} - hasBin: true - proxy-addr@2.0.7: resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==} engines: {node: '>= 0.10'} @@ -18179,9 +17255,6 @@ packages: psl@1.9.0: resolution: {integrity: sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==} - public-encrypt@4.0.3: - resolution: {integrity: sha512-zVpa8oKZSz5bTMTFClc1fQOnyyEzpl5ozpi1B5YcvBrdohMjH2rfsBtyXcuNuwjsDIXmBYlF2N5FlJYhR29t8Q==} - pump@2.0.1: resolution: {integrity: sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==} @@ -18191,9 +17264,6 @@ packages: pumpify@1.5.1: resolution: {integrity: sha512-oClZI37HvuUJJxSKKrC17bZ9Cu0ZYhEAGPsPUy9KlMUmv9dKX2o77RUmq7f3XjIxbwyGwYzbzQ1L2Ks8sIradQ==} - pumpify@2.0.1: - resolution: {integrity: sha512-m7KOje7jZxrmutanlkS1daj1dS6z6BgslzOXmcSEpIlCxM3VJH7lG5QLeck/6hgF6F4crFf01UtQmNsJfweTAw==} - punycode@1.4.1: resolution: {integrity: sha512-jmYNElW7yvO7TV33CjSmvSiE2yco3bV2czu/OzDKdMNVZQWfxCblURLhf+47syQRBntjfLdd/H0egrzIG+oaFQ==} @@ -18201,10 +17271,6 @@ packages: resolution: {integrity: sha512-LN6QV1IJ9ZhxWTNdktaPClrNfp8xdSAYS0Zk2ddX7XsXZAxckMHPCBcHRo0cTcEIgYPRiGEkmji3Idkh2yFtYw==} engines: {node: '>=6'} - pupa@2.1.1: - resolution: {integrity: sha512-l1jNAspIBSFqbT+y+5FosojNpVpF94nlI+wDUpqP9enwOTfHx9f0gh5nB96vl+6yTpsJsypeNrwfzPrKuHB41A==} - engines: {node: '>=8'} - puppeteer-core@24.15.0: resolution: {integrity: sha512-2iy0iBeWbNyhgiCGd/wvGrDSo73emNFjSxYOcyAqYiagkYt5q4cPfVXaVDKBsukgc2fIIfLAalBZlaxldxdDYg==} engines: {node: '>=18'} @@ -18240,19 +17306,9 @@ packages: quansync@0.2.11: resolution: {integrity: sha512-AifT7QEbW9Nri4tAwR5M/uzpBuqfZf+zwaEM/QkzEjj7NBuFD2rBuy0K3dE+8wltbezDV7JMA0WfnCPYRSYbXA==} - querystring-es3@0.2.1: - resolution: {integrity: sha512-773xhDQnZBMFobEiztv8LIl70ch5MSF/jUQVlhwFyBILqq96anmoctVIYz+ZRp0qbCKATTn6ev02M3r7Ga5vqA==} - engines: {node: '>=0.4.x'} - - querystringify@2.2.0: - resolution: {integrity: sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ==} - queue-microtask@1.2.3: resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} - queue-tick@1.0.1: - resolution: {integrity: sha512-kJt5qhMxoszgU/62PLP1CJytzd2NKetjSRnyuj31fDd3Rlcz3fzlFdFLD1SItunPwyqEOkca6GbV612BWfaBag==} - quick-format-unescaped@4.0.4: resolution: {integrity: sha512-tYC1Q1hgyRuHgloV/YXs2w15unPVh8qfu/qCTfhTYamaw7fyhumKa2yGpdSo87vY32rIclj+4fWYQXUMs9EHvg==} @@ -18260,10 +17316,6 @@ packages: resolution: {integrity: sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==} engines: {node: '>=8'} - quote-stream@1.0.2: - resolution: {integrity: sha512-kKr2uQ2AokadPjvTyKJQad9xELbZwYzWlNfI3Uz2j/ib5u6H9lDP7fUUR//rMycd0gv4Z5P1qXMfXR8YpIxrjQ==} - hasBin: true - railroad-diagrams@1.0.0: resolution: {integrity: sha512-cz93DjNeLY0idrCNOH6PviZGRN9GJhsdm9hpn1YCS879fj4W+x5IFJhhkRZcwVgMmFF7R82UA/7Oh+R8lLZg6A==} @@ -18277,9 +17329,6 @@ packages: randombytes@2.1.0: resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==} - randomfill@1.0.4: - resolution: {integrity: sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==} - range-parser@1.2.1: resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==} engines: {node: '>= 0.6'} @@ -18482,9 +17531,6 @@ packages: read-cache@1.0.0: resolution: {integrity: sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==} - read-only-stream@2.0.0: - resolution: {integrity: sha512-3ALe0bjBVZtkdWKIcThYpQCLbBMd/+Tbh2CDSrAIDO3UsZ4Xs+tnyjv2MjCOMMgBG+AsUOeuP1cgtY1INISc8w==} - read-pkg-up@7.0.1: resolution: {integrity: sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==} engines: {node: '>=8'} @@ -18616,9 +17662,6 @@ packages: rehype-raw@7.0.0: resolution: {integrity: sha512-/aE8hCfKlQeA8LmyeyQvQF3eBiLRGNlfBJEvWH7ivp9sBqs7TNqBL5X3v157rM4IFETqDnIOO+z5M/biZbo9Ww==} - reinterval@1.1.0: - resolution: {integrity: sha512-QIRet3SYrGp0HUHO88jVskiG6seqUGC5iAG7AwI/BV4ypGcuqk9Du6YQBUOUqm9c8pw1eyLoIaONifRua1lsEQ==} - remark-frontmatter@4.0.1: resolution: {integrity: sha512-38fJrB0KnmD3E33a5jZC/5+gGAC2WKNiPw1/fdXJvijBlhA7RCsvJklrYJakS0HedninvaCYW8lQGf9C918GfA==} @@ -18754,9 +17797,6 @@ packages: resolution: {integrity: sha512-L9jEkOi3ASd9PYit2cwRfyppc9NoABujTP8/5gFcbERmo5jUoAKovIC3fsF17pkTnGsrByysqX+Kxd2OTNI1ww==} engines: {node: '>=0.10.5'} - requires-port@1.0.0: - resolution: {integrity: sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==} - resend@3.2.0: resolution: {integrity: sha512-lDHhexiFYPoLXy7zRlJ8D5eKxoXy6Tr9/elN3+Vv7PkUoYuSSD1fpiIfa/JYXEWyiyN2UczkCTLpkT8dDPJ4Pg==} engines: {node: '>=18'} @@ -18794,10 +17834,6 @@ packages: responselike@1.0.2: resolution: {integrity: sha512-/Fpe5guzJk1gPqdJLJR5u7eG/gNY4nImjbRDaVWVMRhne55TCmj2i9Q+54PBRfatRC8v/rIiv9BN0pMd9OV5EQ==} - restore-cursor@2.0.0: - resolution: {integrity: sha512-6IzJLuGi4+R14vwagDHX+JrXmPVtPpn4mffDJ1UdR7/Edm87fl6yi8mMBIVvFtJaNTUvjughmW4hwLhRG7gC1Q==} - engines: {node: '>=4'} - restore-cursor@3.1.0: resolution: {integrity: sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==} engines: {node: '>=8'} @@ -18810,9 +17846,6 @@ packages: resolution: {integrity: sha512-I1XxrZSQ+oErkRR4jYbAyEEu2I0avBvvMM5JN+6EBprOGRCs63ENqZ3vjavq8fBw2+62G5LF5XelKwuJpcvcxw==} engines: {node: '>=10'} - retimer@3.0.0: - resolution: {integrity: sha512-WKE0j11Pa0ZJI5YIk0nflGI7SQsfl2ljihVy7ogh7DeQSeYAUi0ubZ/yEueGtDfUPk6GH5LRw1hBdLq4IwUBWA==} - retry@0.12.0: resolution: {integrity: sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==} engines: {node: '>= 4'} @@ -18851,10 +17884,6 @@ packages: engines: {node: 20 || >=22} hasBin: true - ripemd160@2.0.3: - resolution: {integrity: sha512-5Di9UC0+8h1L6ZD2d7awM7E/T4uA1fJRlx6zk/NvdCCVEoAnFqvHmCuNeIKoCeIixBX/q8uM+6ycDvF8woqosA==} - engines: {node: '>= 0.8'} - robot3@0.4.1: resolution: {integrity: sha512-hzjy826lrxzx8eRgv80idkf8ua1JAepRc9Efdtj03N3KNJuznQCPlyCJ7gnUmDFwZCLQjxy567mQVKmdv2BsXQ==} @@ -18885,10 +17914,6 @@ packages: resolution: {integrity: sha512-9by4Ij99JUr/MCFBUkDKLWK3G9HVXmabKz9U5MlIAIuvuzkiOicRYs8XJLxX+xahD+mLiiCYDqF9dKAgtzKP1A==} engines: {node: '>=18'} - run-async@2.4.1: - resolution: {integrity: sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ==} - engines: {node: '>=0.12.0'} - run-exclusive@2.2.18: resolution: {integrity: sha512-TXr1Gkl1iEAOCCpBTRm/2m0+1KGjORcWpZZ+VGGTe7dYX8E4y8/fMvrHk0zf+kclec2R//tpvdBxgG0bDgaJfw==} @@ -18901,10 +17926,6 @@ packages: rw@1.3.3: resolution: {integrity: sha512-PdhdWy89SiZogBLaw42zdeqtRJ//zFd2PgQavcICDUgJT5oW10QCRKbJ6bg4r0/UY2M6BWd5tkxuGFRvCkgfHQ==} - rxjs@6.6.7: - resolution: {integrity: sha512-hTdwr+7yYNIT5n4AMYp85KA6yw2Va0FLa3Rguvbpa4W3I5xynaBZo41cM3XM+4Q6fRMj3sBYIR1VAmZMXYJvRQ==} - engines: {npm: '>=2.0.0'} - rxjs@7.8.2: resolution: {integrity: sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==} @@ -18959,9 +17980,6 @@ packages: resolution: {integrity: sha512-eflK8wEtyOE6+hsaRVPxvUKYCpRgzLqDTb8krvAsRIwOGlHoSgYLgBXoubGgLd2fT41/OUYdb48v4k4WWHQurA==} engines: {node: '>= 10.13.0'} - scope-analyzer@2.1.2: - resolution: {integrity: sha512-5cfCmsTYV/wPaRIItNxatw02ua/MThdIUNnUOCYp+3LSEJvnG804ANw2VLaavNILIfWXF1D1G2KNANkBBvInwQ==} - screenfull@5.2.0: resolution: {integrity: sha512-9BakfsO2aUQN2K9Fdbj87RJIEZ82Q9IGim7FqM5OsebfoFC6ZHXgDq/KvniuLTPdeM8wY2o6Dj3WQ7KeQCj3cA==} engines: {node: '>=0.10.0'} @@ -18981,10 +17999,6 @@ packages: sembear@0.5.2: resolution: {integrity: sha512-Ij1vCAdFgWABd7zTg50Xw1/p0JgESNxuLlneEAsmBrKishA06ulTTL/SHGmNy2Zud7+rKrHTKNI6moJsn1ppAQ==} - semver-diff@3.1.1: - resolution: {integrity: sha512-GX0Ix/CJcHyB8c4ykpHGIAvLyOwOobtM/8d+TQkAd81/bEjgPHrfba41Vpesr7jX/t8Uh+R3EX9eAS5be+jQYg==} - engines: {node: '>=8'} - semver@5.7.1: resolution: {integrity: sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==} hasBin: true @@ -19055,14 +18069,6 @@ packages: setprototypeof@1.2.0: resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==} - sha.js@2.4.12: - resolution: {integrity: sha512-8LzC5+bvI45BjpfXU8V5fdU2mfeKiQe1D1gIMn7XUlF3OTUrpdJpPPH4EMAnF0DsHHdSZqCdSss5qCmJKuiO3w==} - engines: {node: '>= 0.10'} - hasBin: true - - shallow-copy@0.0.1: - resolution: {integrity: sha512-b6i4ZpVuUxB9h5gfCxPiusKYkqTMOjEbBs4wMaFbkfia4yFv92UKZ6Df8WXcKbn08JNL/abvg3FnMAOfakDvUw==} - sharp@0.33.5: resolution: {integrity: sha512-haPVm1EkS9pgvHrQ/F3Xy+hgcuMV0Wm9vfIBSiwZ05k+xgb0PkBQpGsAA/oWdDobNaZTH5ppvHtzCFbnSEwHVw==} engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} @@ -19071,10 +18077,6 @@ packages: resolution: {integrity: sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==} engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0} - shasum-object@1.0.1: - resolution: {integrity: sha512-SsC+1tW7XKQ/94D4k1JhLmjDFpVGET/Nf54jVDtbavbALf8Zhp0Td9zTlxScjMW6nbEIrpADtPWfLk9iCXzHDQ==} - hasBin: true - shebang-command@1.2.0: resolution: {integrity: sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==} engines: {node: '>=0.10.0'} @@ -19105,10 +18107,6 @@ packages: shimmer@1.2.1: resolution: {integrity: sha512-sQTKC1Re/rM6XyFM6fIAGHRPVGvyXfgzIDvzoq608vM+jeyVD0Tu1E6Np0Kc2zAIFWIj963V2800iF/9LPieQw==} - showdown@1.9.1: - resolution: {integrity: sha512-9cGuS382HcvExtf5AHk7Cb4pAeQQ+h0eTr33V1mu+crYWV4KvWAw6el92bDrqGEk5d46Ai/fhbEUwqJ/mTCNEA==} - hasBin: true - side-channel-list@1.0.0: resolution: {integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==} engines: {node: '>= 0.4'} @@ -19135,9 +18133,6 @@ packages: resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==} engines: {node: '>=14'} - signed-varint@2.0.1: - resolution: {integrity: sha512-abgDPg1106vuZZOvw7cFwdCABddfJRz5akcCcchzTbhyhYnsG31y4AlZEgp315T7W3nQq5P4xeOm186ZiPVFzw==} - simple-concat@1.0.1: resolution: {integrity: sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==} @@ -19153,12 +18148,6 @@ packages: simplur@3.0.1: resolution: {integrity: sha512-bBAoTn75tuKh83opmZ1VoyVoQIsvLCKzSxuasAxbnKofrT8eGyOEIaXSuNfhi/hI160+fwsR7ObcbBpOyzDvXg==} - single-line-log@1.1.2: - resolution: {integrity: sha512-awzaaIPtYFdexLr6TBpcZSGPB6D1RInNO/qNetgaJloPDF/D0GkVtLvGEp8InfmLV7CyLyQ5fIRP+tVN/JmWQA==} - - sinusoidal-decimal@1.0.0: - resolution: {integrity: sha512-KPUi1ZqLocV64n0AuV+g4VDjAM+tEEY66nUd+rYaVBHIfeheGGUvIxe9bf7Mpc1PonDTVW2uRr9nigQa9odvuA==} - sirv@2.0.4: resolution: {integrity: sha512-94Bdh3cC2PKrbgSOUqTiGPWVZeSiXfKOVZNJniWoqrWrRkB1CJzBU3NEbiTsPcYy1lDsANA/THzS+9WBiy5nfQ==} engines: {node: '>= 10'} @@ -19225,9 +18214,6 @@ packages: resolution: {integrity: sha512-l5x7VUUWbjVFbafGLxPWkYsHIhEvmF85tbIeFZWc8ZPtoMyybuEhL7Jye/ooC4/d48FgOjSJXgsF/AJPYCW8Zw==} engines: {node: '>= 10.0.0', npm: '>= 3.0.0'} - sonic-boom@1.4.1: - resolution: {integrity: sha512-LRHh/A8tpW7ru89lrlkU4AszXt1dbwSjVWguGrmlxE7tawVmDBlI1PILMkXAxJTwqhgsEeTHzj36D5CmHgQmNg==} - sonic-boom@4.2.0: resolution: {integrity: sha512-INb7TM37/mAcsGmc9hyyI6+QR3rR1zVRu36B0NeGXKnOOLiZOfER5SA+N7X7k3yUYRzLWafduTDvJAfDswwEww==} @@ -19275,10 +18261,6 @@ packages: engines: {node: '>= 8'} deprecated: The work that was done in this beta branch won't be included in future versions - sourcemap-codec@1.4.8: - resolution: {integrity: sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==} - deprecated: Please use @jridgewell/sourcemap-codec instead - space-separated-tokens@2.0.2: resolution: {integrity: sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==} @@ -19366,12 +18348,6 @@ packages: standard-as-callback@2.1.0: resolution: {integrity: sha512-qoRRSyROncaz1z0mvYqIE4lCd9p2R90i6GxW3uZv5ucSu8tU7B5HXUP1gG8pVZsYNVaXjk8ClXHPttLyxAL48A==} - static-eval@2.1.1: - resolution: {integrity: sha512-MgWpQ/ZjGieSVB3eOJVs4OA2LT/q1vx98KPCTTQPzq/aLr0YUXTsgryTXr4SLfR0ZfUUCiedM9n/ABeDIyy4mA==} - - static-module@3.0.4: - resolution: {integrity: sha512-gb0v0rrgpBkifXCa3yZXxqVmXDVE+ETXj6YlC/jt5VzOnGXR2C15+++eXuMDUYsePnbhf+lwW0pE1UXyOLtGCw==} - statuses@2.0.1: resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==} engines: {node: '>= 0.8'} @@ -19385,35 +18361,16 @@ packages: std-env@3.9.0: resolution: {integrity: sha512-UGvjygr6F6tpH7o2qyqR6QYpwraIjKSdtzyBdyytFOHmPZY917kwdwLG0RbOjWOnKmnm3PeHjaoLLMie7kPLQw==} - stream-browserify@3.0.0: - resolution: {integrity: sha512-H73RAHsVBapbim0tU2JwwOiXUj+fikfiaoYAKHF3VJfA0pe2BCzkhAHBlLG6REzE+2WNZcxOXjK7lkso+9euLA==} - stream-buffers@3.0.2: resolution: {integrity: sha512-DQi1h8VEBA/lURbSwFtEHnSTb9s2/pwLEaFuNhXwy1Dx3Sa0lOuYT2yNUr4/j2fs8oCAMANtrZ5OrPZtyVs3MQ==} engines: {node: '>= 0.10.0'} - stream-collector@1.0.1: - resolution: {integrity: sha512-b9/C+HonJNmPmdBFGa0aJc9cai07YksAFvmchnSobiIitppiBn6wfAN7rLGEz6fE30Rj9EC/UVkovzoLJTpC5Q==} - - stream-combiner2@1.1.1: - resolution: {integrity: sha512-3PnJbYgS56AeWgtKF5jtJRT6uFJe56Z0Hc5Ngg/6sI6rIt8iiMBTa9cvdyFfpMQjaVHr8dusbNeFGIIonxOvKw==} - - stream-http@3.2.0: - resolution: {integrity: sha512-Oq1bLqisTyK3TSCXpPbT4sdeYNdmyZJv1LxpEm2vu1ZhK89kSE5YXwZc3cWk0MagGaKriBh9mCFbVGtO+vY29A==} - stream-shift@1.0.3: resolution: {integrity: sha512-76ORR0DO1o1hlKwTbi/DM3EXWGf3ZJYO8cXX5RJwnul2DEg2oyoZyjLNoQM8WsvZiFKCRfC1O0J7iCvie3RZmQ==} stream-slice@0.1.2: resolution: {integrity: sha512-QzQxpoacatkreL6jsxnVb7X5R/pGw9OUv2qWTYWnmLpg4NdN31snPy/f3TdQE1ZUXaThRvj1Zw4/OGg0ZkaLMA==} - stream-splicer@2.0.1: - resolution: {integrity: sha512-Xizh4/NPuYSyAXyT7g8IvdJ9HJpxIGL9PjyhtywCZvvP0OPIdqyrr4dMikeuvY8xahpdKEBlBTySe583totajg==} - - stream-template@0.0.10: - resolution: {integrity: sha512-whIqf/ljJ88dr0z6iNFtJq09rs4R6JxJOnIqGthC3rHFEMYq6ssm4sPYILXEPrFYncMjF39An6MBys1o5BC19w==} - engines: {node: '>=4.0.0'} - stream-transform@2.1.3: resolution: {integrity: sha512-9GHUiM5hMiCi6Y03jD2ARC1ettBXkQBoQAe7nJsPknnI0ow10aXjTnew8QtYQmLjzn974BnmWEAJgCY6ZP1DeQ==} @@ -19422,9 +18379,6 @@ packages: peerDependencies: react: ^18.0.0 || ^19.0.0 - streaming-json-stringify@3.1.0: - resolution: {integrity: sha512-axtfs3BDxAsrZ9swD163FBrXZ8dhJJp6kUI6C97TvUZG9RHKfbg9nFbXqEheFNOb3IYMEt2ag9F62sWLFUZ4ug==} - streamsearch@1.1.0: resolution: {integrity: sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==} engines: {node: '>=10.0.0'} @@ -19435,18 +18389,6 @@ packages: string-hash@1.1.3: resolution: {integrity: sha512-kJUvRUFK49aub+a7T1nNE66EJbZBMnBgoC1UbCZ5n6bsZKBRga4KgBRTMn/pFkeCZSYtNeSyMxPDM0AXWELk2A==} - string-width@1.0.2: - resolution: {integrity: sha512-0XsVpQLnVCXHJfyEs8tC0zpTVIr5PKKsQtkT29IwupnPTjtPmQ3xT/4yCREF9hYkV/3M3kzcUTSAZT6a6h81tw==} - engines: {node: '>=0.10.0'} - - string-width@2.1.1: - resolution: {integrity: sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==} - engines: {node: '>=4'} - - string-width@3.1.0: - resolution: {integrity: sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==} - engines: {node: '>=6'} - string-width@4.2.3: resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} engines: {node: '>=8'} @@ -19488,18 +18430,6 @@ packages: stringify-entities@4.0.3: resolution: {integrity: sha512-BP9nNHMhhfcMbiuQKCqMjhDP5yBCAxsPu4pHFFzJ6Alo9dZgY4VLDPutXqIjpRiMoKdp7Av85Gr73Q5uH9k7+g==} - strip-ansi@3.0.1: - resolution: {integrity: sha512-VhumSSbBqDTP8p2ZLKj40UjBCV4+v8bUSEpUb4KjRgWk9pbqGF4REFj6KEagidb2f/M6AzC0EmFyDNGaw9OCzg==} - engines: {node: '>=0.10.0'} - - strip-ansi@4.0.0: - resolution: {integrity: sha512-4XaJ2zQdCzROZDivEVIDPkcQn8LMFSa8kj8Gxb/Lnwzv9A8VctNZ+lfivC/sV3ivW8ElJTERXZoPBRrZKkNKow==} - engines: {node: '>=4'} - - strip-ansi@5.2.0: - resolution: {integrity: sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==} - engines: {node: '>=6'} - strip-ansi@6.0.1: resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==} engines: {node: '>=8'} @@ -19592,17 +18522,11 @@ packages: stylis@4.3.6: resolution: {integrity: sha512-yQ3rwFWRfwNUY7H5vpU0wfdkNSnvnJinhF9830Swlaxl03zsOjCfmX0ugac+3LtK0lYSgwL/KXc8oYL3mG4YFQ==} - subarg@1.0.0: - resolution: {integrity: sha512-RIrIdRY0X1xojthNcVtgT9sjpOGagEUKpZdgBUi054OEPFo282yg+zE+t1Rj3+RqKq2xStL7uUHhY+AjbC4BXg==} - sucrase@3.35.0: resolution: {integrity: sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==} engines: {node: '>=16 || 14 >=14.17'} hasBin: true - summary@2.1.0: - resolution: {integrity: sha512-nMIjMrd5Z2nuB2RZCKJfFMjgS3fygbeyGk9PxPPaJR1RIcyN9yn4A63Isovzm3ZtQuEkLBVgMdPup8UeLH7aQw==} - superagent@9.0.2: resolution: {integrity: sha512-xuW7dzkUpcJq7QnhOsnNUgtYp3xRwpt2F7abdRYIpCsAt0hhUqia0EdxyXZQQpNmGtsCzYHryaKSV3q3GJnq7w==} engines: {node: '>=14.18.0'} @@ -19625,10 +18549,6 @@ packages: resolution: {integrity: sha512-HRVVSbCCMbj7/kdWF9Q+bbckjBHLtHMEoJWlkmYzzdwhYMkjkOwubLM6t7NbWKjgKamGDrWL1++KrjUO1t9oAQ==} engines: {node: '>=18'} - supports-color@2.0.0: - resolution: {integrity: sha512-KKNVtd6pCYgPIKU4cp2733HWYCpplQhddZLBUryaAHou723x+FRzQ5Df824Fj+IyyuiQTRoub4SnIFfIcrp70g==} - engines: {node: '>=0.8.0'} - supports-color@5.5.0: resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==} engines: {node: '>=4'} @@ -19679,9 +18599,6 @@ packages: resolution: {integrity: sha512-L1dapNV6vu2s/4Sputv8xGsCdAVlb5nRDMFU/E27D44l5U6cw1g0dGd45uLc+OXjNMmF4ntiMdCimzcjFKQI8Q==} engines: {node: ^14.18.0 || >=16.0.0} - syntax-error@1.4.0: - resolution: {integrity: sha512-YPPlu67mdnHGTup2A8ff7BC2Pjq0e0Yp/IyTFN03zWO0RcK07uLcbi7C2KpGR2FvWbaB0+bfE27a+sBKebSo7w==} - systeminformation@5.23.8: resolution: {integrity: sha512-Osd24mNKe6jr/YoXLLK3k8TMdzaxDffhpCxgkfgBHcapykIkd50HXThM3TCEuHO2pPuCsSx2ms/SunqhU5MmsQ==} engines: {node: '>=8.0.0'} @@ -19692,9 +18609,6 @@ packages: resolution: {integrity: sha512-9kY+CygyYM6j02t5YFHbNz2FN5QmYGv9zAjVp4lCDjlCw7amdckXlEt/bjMhUIfj4ThGRE4gCUH5+yGnNuPo5A==} engines: {node: '>=10.0.0'} - tachyons@4.12.0: - resolution: {integrity: sha512-2nA2IrYFy3raCM9fxJ2KODRGHVSZNTW3BR0YnlGsLUf1DA3pk3YfWZ/DdfbnZK6zLZS+jUenlUGJsKcA5fUiZg==} - tailwind-merge@1.12.0: resolution: {integrity: sha512-Y17eDp7FtN1+JJ4OY0Bqv9OA41O+MS8c1Iyr3T6JFLnOgLg3EvcyMKZAnQ8AGyvB5Nxm3t9Xb5Mhe139m8QT/g==} @@ -19832,11 +18746,6 @@ packages: uglify-js: optional: true - terser@4.8.1: - resolution: {integrity: sha512-4GnLC0x667eJG0ewJTa6z/yXrbLGv80D9Ru6HIpCQmO+Q4PfEtBFi0ObSckqwL6VyQv/7ENJieXHo2ANmdQwgw==} - engines: {node: '>=6.0.0'} - hasBin: true - terser@5.44.1: resolution: {integrity: sha512-t/R3R/n0MSwnnazuPpPNVO60LX0SKL45pyl9YlvxIdkH0Of7D5qM2EVe+yASRIlY5pZ73nclYJfNANGWPwFDZw==} engines: {node: '>=10'} @@ -19876,23 +18785,6 @@ packages: through2@2.0.5: resolution: {integrity: sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==} - through2@3.0.2: - resolution: {integrity: sha512-enaDQ4MUyP2W6ZyT6EsMzqBPZaM/avg8iuo+l2d3QCs0J+6RaqkHV/2/lOwDTueBHeJ/2LG9lrLW3d5rWPucuQ==} - - through2@4.0.2: - resolution: {integrity: sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw==} - - through@2.3.8: - resolution: {integrity: sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==} - - timers-browserify@1.4.2: - resolution: {integrity: sha512-PIxwAupJZiYU4JmVZYwXp9FKsHMXb5h0ZEFyuXTAn8WLHOlcij+FEcbrvDsom1o5dr1YggEtFbECvGCW2sT53Q==} - engines: {node: '>=0.6.0'} - - timestring@6.0.0: - resolution: {integrity: sha512-wMctrWD2HZZLuIlchlkE2dfXJh7J2KDI9Dwl+2abPYg0mswQHfOAyQW3jJg1pY5VfttSINZuKcXoB3FGypVklA==} - engines: {node: '>=8'} - tiny-case@1.0.3: resolution: {integrity: sha512-Eet/eeMhkO6TX8mnUteS9zgPbUMQa4I6Kkp5ORiBD5476/m+PIRiumP5tmh5ioJpH7k51Kehawy2UDfsnxxY8Q==} @@ -19973,10 +18865,6 @@ packages: resolution: {integrity: sha512-nZD7m9iCPC5g0pYmcaxogYKggSfLsdxl8of3Q/oIbqCqLLIO9IAF0GWjX1z9NZRHPiXv8Wex4yDCaZsgEw0Y8w==} engines: {node: '>=14.14'} - to-buffer@1.2.2: - resolution: {integrity: sha512-db0E3UJjcFhpDhAF4tLo03oli3pwl3dbnzXOUIlRKrp+ldk/VUxzpWYZENsw2SZiuBjHAk7DfB0VU7NKdpb6sw==} - engines: {node: '>= 0.4'} - to-fast-properties@2.0.0: resolution: {integrity: sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==} engines: {node: '>=4'} @@ -20018,19 +18906,12 @@ packages: resolution: {integrity: sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==} engines: {node: '>=0.8'} - tough-cookie@4.1.4: - resolution: {integrity: sha512-Loo5UUvLD9ScZ6jh8beX1T6sO1w2/MpCRpEP7V280GKMVUQ0Jzar2U3UJPsrdbziLEMMhu3Ujnq//rhiFuIeag==} - engines: {node: '>=6'} - tr46@0.0.3: resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==} tr46@1.0.1: resolution: {integrity: sha512-dTpowEjclQ7Kgx5SdBkqRzVhERQXov8/l9Ft9dVM9fmg0W0KQSVaXX9T4i6twCPNtYiZM53lpSSUAwJbFPOHxA==} - transform-ast@2.4.4: - resolution: {integrity: sha512-AxjeZAcIOUO2lev2GDe3/xZ1Q0cVGjIMk5IsriTy8zbWlsEnjeB025AhkhBJHoy997mXpLd4R+kRbvnnQVuQHQ==} - tree-kill@1.2.2: resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==} hasBin: true @@ -20182,12 +19063,6 @@ packages: engines: {node: '>=18.0.0'} hasBin: true - ttest@3.0.0: - resolution: {integrity: sha512-bLo+LdYokiDZHVFIWJmC5afoh7wZ+o1h++0XXKh01+yprzz8CnaiGNcbcbqP0e3+iyDqclLI+rM0j/9AwmRljw==} - - tty-browserify@0.0.1: - resolution: {integrity: sha512-C3TaO7K81YvjCgQH9Q1S3R3P3BtN3RIM8n+OvX4il1K1zgE8ZhI0op7kClgkxtutIE8hQrcrHBXvIheqKUUCxw==} - tty-table@4.1.6: resolution: {integrity: sha512-kRj5CBzOrakV4VRRY5kUWbNYvo/FpOsz65DzI5op9P+cHov3+IqPbo1JE1ZnQGkHdZgNFDsrEjrfqqy/Ply9fw==} engines: {node: '>=8.0.0'} @@ -20206,9 +19081,6 @@ packages: cpu: [arm64] os: [darwin] - turbo-json-parse@2.3.0: - resolution: {integrity: sha512-f1CWo4TNqwicXXUAOU5K9RZX6MhEdtOPT+FmgPhiet0a698+46KiXzMHpl8V4fieUa6qXr968uuNbHDSfXjkcQ==} - turbo-linux-64@1.10.3: resolution: {integrity: sha512-kvAisGKE7xHJdyMxZLvg53zvHxjqPK1UVj4757PQqtx9dnjYHSc8epmivE6niPgDHon5YqImzArCjVZJYpIGHQ==} cpu: [x64] @@ -20239,17 +19111,10 @@ packages: tweetnacl@0.14.5: resolution: {integrity: sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==} - type-check@0.3.2: - resolution: {integrity: sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==} - engines: {node: '>= 0.8.0'} - type-check@0.4.0: resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==} engines: {node: '>= 0.8.0'} - type-component@0.0.1: - resolution: {integrity: sha512-mDZRBQS2yZkwRQKfjJvQ8UIYJeBNNWCq+HBNstl9N5s9jZ4dkVYXEGkVPsSCEh5Ld4JM1kmrZTzjnrqSAIQ7dw==} - type-fest@0.13.1: resolution: {integrity: sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==} engines: {node: '>=10'} @@ -20286,17 +19151,10 @@ packages: resolution: {integrity: sha512-gd0sGezQYCbWSbkZr75mln4YBidWUN60+devscpLF5mtRDUpiaTvKpBNrdaCvel1NdR2k6vclXybU5fBd2i+nw==} engines: {node: '>= 0.6'} - type@2.7.3: - resolution: {integrity: sha512-8j+1QmAbPvLZow5Qpi6NCaN8FB60p/6x8/vfNqOk/hC+HuvFZhL4+WfekuhQLiqFZXOgQdrs3B+XxEmCc6b3FQ==} - typed-array-buffer@1.0.2: resolution: {integrity: sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ==} engines: {node: '>= 0.4'} - typed-array-buffer@1.0.3: - resolution: {integrity: sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==} - engines: {node: '>= 0.4'} - typed-array-byte-length@1.0.1: resolution: {integrity: sha512-3iMJ9q0ao7WE9tWcaYKIptkNBuOIcZCCT0d4MRvuuH88fEoEH62IuQe0OtraD3ebQEoTRk8XCBoknUNc1Y67pw==} engines: {node: '>= 0.4'} @@ -20318,15 +19176,6 @@ packages: typed-query-selector@2.12.0: resolution: {integrity: sha512-SbklCd1F0EiZOyPiW192rrHZzZ5sBijB6xM+cpmrwDqObvdtunOHHIk9fCGsoK5JVIYXoyEp4iEdE3upFH3PAg==} - typedarray-pool@1.2.0: - resolution: {integrity: sha512-YTSQbzX43yvtpfRtIDAYygoYtgT+Rpjuxy9iOpczrjpXLgGoyG7aS5USJXV2d3nn8uHTeb9rXDvzS27zUg5KYQ==} - - typedarray-to-buffer@3.1.5: - resolution: {integrity: sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==} - - typedarray@0.0.6: - resolution: {integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==} - typescript@5.1.6: resolution: {integrity: sha512-zaWCozRZ6DLEWAWFrVDz1H6FVXzUSfTy5FUMWsQlU8Ym5JP9eO4xkTIROFCQvhQf61z6O/G6ugw3SgAnvvm+HA==} engines: {node: '>=14.17'} @@ -20369,20 +19218,12 @@ packages: resolution: {integrity: sha512-DU9F5t1tihdafuNyW3fIrXUFHHiHxmwuQSGVGIbSpqkc93IH4P0dU8nPhk0gOW7ARxaFu4+P/9cxVwn6PdnIaQ==} engines: {node: '>=16'} - umd@3.0.3: - resolution: {integrity: sha512-4IcGSufhFshvLNcMCV80UnQVlZ5pMOC8mvNPForqwA4+lzYQuetTESLDQkeLmihq8bRcnpbQa48Wb8Lh16/xow==} - hasBin: true - unbox-primitive@1.0.2: resolution: {integrity: sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==} uncrypto@0.1.3: resolution: {integrity: sha512-Ql87qFHB3s/De2ClA9e0gsnS6zXG27SkTiSJwjCc9MebbfapQfuPzumMIUMi38ezPZVNFcHI9sUIepeQfw8J8Q==} - undeclared-identifiers@1.1.3: - resolution: {integrity: sha512-pJOW4nxjlmfwKApE4zvxLScM/njmwj/DiUBv7EabwE4O8kRUy+HIwxQtZLBPll/jx1LJyBcqNfB3/cpv9EZwOw==} - hasBin: true - undici-types@5.26.5: resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==} @@ -20411,9 +19252,6 @@ packages: unified@11.0.5: resolution: {integrity: sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==} - uniq@1.0.1: - resolution: {integrity: sha512-Gw+zz50YNKPDKXs+9d+aKAjVwpjNwqzvNpLigIruT4HA9lMZNdMqs9x07kKHB/L9WRzqp4+DlTU5s4wG2esdoA==} - unique-filename@3.0.0: resolution: {integrity: sha512-afXhuC55wkAmZ0P18QsVE6kp8JaxrEokN2HGIoIVv2ijHQd419H0+6EigAFcIzXeMIkcIkNBpB3L/DXB3cTS/g==} engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} @@ -20422,10 +19260,6 @@ packages: resolution: {integrity: sha512-WrcA6AyEfqDX5bWige/4NQfPZMtASNVxdmWR76WESYQVAACSgWcR6e9i0mofqqBxYFtL4oAxPIptY73/0YE1DQ==} engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0} - unique-string@2.0.0: - resolution: {integrity: sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==} - engines: {node: '>=8'} - unist-util-find-after@5.0.0: resolution: {integrity: sha512-amQa0Ep2m6hE2g72AugUItjbuM8X8cGQnFoHk0pGfrFeT9GZhzN5SW8nRsiGKK7Aif4CrACPENkA6P/Lw6fHGQ==} @@ -20484,10 +19318,6 @@ packages: resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==} engines: {node: '>= 4.0.0'} - universalify@0.2.0: - resolution: {integrity: sha512-CJ1QgKmNg3CwvAv/kOFmtnEN05f0D/cn9QntgNOQlQF9dgvVTHj3t+8JPdjqawCHk7V/KA+fbUqzZ9XWhcqPUg==} - engines: {node: '>= 4.0.0'} - universalify@2.0.0: resolution: {integrity: sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==} engines: {node: '>= 10.0.0'} @@ -20514,10 +19344,6 @@ packages: peerDependencies: browserslist: '>= 4.21.0' - update-notifier@5.1.0: - resolution: {integrity: sha512-ItnICHbeMh9GqUy31hFPrD1kcuZ3rpxDZbf4KUDavXwS0bW5m7SLbDQpGX3UYr072cbrF5hFUs3r5tUsPwjfHw==} - engines: {node: '>=10'} - uploadthing@7.1.0: resolution: {integrity: sha512-l1bRHs+q/YLx3XwBav98t4Bl1wLWaskhPEwopxtYgiRrxX5nW3uUuSP0RJ9eKwx0+6ZhHWxHDvShf7ZLledqmQ==} engines: {node: '>=18.13.0'} @@ -20539,9 +19365,6 @@ packages: tailwindcss: optional: true - upper-case@1.1.3: - resolution: {integrity: sha512-WRbjgmYzgXkCV7zNVpy5YgrHgbBv126rMALQQMrmzOVC4GM2waQ9x7xtm8VU+1yF2kWyPzI9zbZ48n4vSxwfSA==} - uri-js@4.4.1: resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} @@ -20549,13 +19372,6 @@ packages: resolution: {integrity: sha512-NjFKA0DidqPa5ciFcSrXnAltTtzz84ogy+NebPvfEgAck0+TNg4UJ4IN+fB7zRZfbgUf0syOo9MDxFkDSMuFaQ==} engines: {node: '>=4'} - url-parse@1.5.10: - resolution: {integrity: sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==} - - url@0.11.4: - resolution: {integrity: sha512-oCwdVC7mTuWiPyjLUz/COz5TLk6wgp0RCsN+wHZ2Ekneac9w8uuV0njcbbie2ME+Vs+d6duwmYuR3HgQXs1fOg==} - engines: {node: '>= 0.4'} - urlpattern-polyfill@9.0.0: resolution: {integrity: sha512-WHN8KDQblxd32odxeIgo83rdVDE2bvdkb86it7bMhYZwWKJz0+O0RK/eZiHYnM+zgt/U7hAHOlCQGfjjvSkw2g==} @@ -20596,12 +19412,6 @@ packages: util-deprecate@1.0.2: resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==} - util-extend@1.0.3: - resolution: {integrity: sha512-mLs5zAK+ctllYBj+iAQvlDCwoxU/WDOUaJkcFudeiAX6OajC6BKXJUa9a+tbtkC11dz2Ufb7h0lyvIOVn4LADA==} - - util@0.10.4: - resolution: {integrity: sha512-0Pm9hTQ3se5ll1XihRic3FDIku70C+iHUdT/W926rSgHV5QgXsYbKZN8MSC3tJtSkhuROzvsQjAaFENRXr+19A==} - util@0.12.5: resolution: {integrity: sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==} @@ -20609,9 +19419,6 @@ packages: resolution: {integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==} engines: {node: '>= 0.4.0'} - uuid-parse@1.1.0: - resolution: {integrity: sha512-OdmXxA8rDsQ7YpNVbKSJkNzTw2I+S5WsbMDnCtIWSQaosNAcWtFuI/YK1TjzUI6nbkgiqEyh8gWngfcv8Asd9A==} - uuid@10.0.0: resolution: {integrity: sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ==} hasBin: true @@ -20666,12 +19473,6 @@ packages: validate.io-function@1.0.2: resolution: {integrity: sha512-LlFybRJEriSuBnUhQyG5bwglhh50EpTL2ul23MPIuR1odjO7XaMLFV8vHGwp7AZciFxtYOeiSCT5st+XSPONiQ==} - varint@5.0.0: - resolution: {integrity: sha512-gC13b/bWrqQoKY2EmROCZ+AR0jitc6DnDGaQ6Ls9QpKmuSgJB1eQ7H3KETtQm7qSdMWMKCmsshyCmUwMLh3OAA==} - - varint@5.0.2: - resolution: {integrity: sha512-lKxKYG6H03yCZUpAGOPOsMcGxd1RHCu1iKvEHYDPmTyq2HueGhD73ssNBqqQWfvYs04G9iUFRvmAVLW20Jw6ow==} - vary@1.1.2: resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==} engines: {node: '>= 0.8'} @@ -20801,9 +19602,6 @@ packages: jsdom: optional: true - vm-browserify@1.1.2: - resolution: {integrity: sha512-2ham8XPWTONajOR0ohOKOHXkm3+gaBmGut3SRuu75xLd/RRaY6vqgh8NBYYk7+RW3u5AtzPQZG8F10LHkl0lAQ==} - vscode-jsonrpc@8.2.0: resolution: {integrity: sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA==} engines: {node: '>=14.0.0'} @@ -20867,9 +19665,6 @@ packages: resolution: {integrity: sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug==} engines: {node: '>= 14'} - webfontloader@1.6.28: - resolution: {integrity: sha512-Egb0oFEga6f+nSgasH3E0M405Pzn6y3/9tOVanv/DLfa1YBIgcv90L18YyWnvXkRbIM17v5Kv6IT2N6g1x5tvQ==} - webidl-conversions@3.0.1: resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==} @@ -20929,10 +19724,6 @@ packages: resolution: {integrity: sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA==} engines: {node: '>= 0.4'} - which-typed-array@1.1.19: - resolution: {integrity: sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==} - engines: {node: '>= 0.4'} - which@1.3.1: resolution: {integrity: sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==} hasBin: true @@ -20952,22 +19743,10 @@ packages: engines: {node: '>=8'} hasBin: true - widest-line@3.1.0: - resolution: {integrity: sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg==} - engines: {node: '>=8'} - - windows-release@4.0.0: - resolution: {integrity: sha512-OxmV4wzDKB1x7AZaZgXMVsdJ1qER1ed83ZrTYd5Bwq2HfJVg3DJS8nqlAG4sMoJ7mu8cuRmLEYyU13BKwctRAg==} - engines: {node: '>=10'} - word-wrap@1.2.3: resolution: {integrity: sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==} engines: {node: '>=0.10.0'} - wrap-ansi@5.1.0: - resolution: {integrity: sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==} - engines: {node: '>=6'} - wrap-ansi@6.2.0: resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==} engines: {node: '>=8'} @@ -20983,9 +19762,6 @@ packages: wrappy@1.0.2: resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} - write-file-atomic@3.0.3: - resolution: {integrity: sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==} - ws@7.5.9: resolution: {integrity: sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==} engines: {node: '>=8.3.0'} @@ -21062,10 +19838,6 @@ packages: resolution: {integrity: sha512-mgxlWVZw0TNWHoGmXq+NC3uhCIc55dDpAlDkMQUaIAcQzysb0kxctwv//fvuW61/nAAeUBJMQ8mnZjMmuYwOcQ==} engines: {node: '>= 4.0'} - xdg-basedir@4.0.0: - resolution: {integrity: sha512-PSNhEJDejZYV7h50BohL09Er9VaIefr2LMAf3OEmpCkjOi34eYyQYAXUTjEQtZJTKcF0E2UKTh+osDLsgNim9Q==} - engines: {node: '>=8'} - xdg-portable@10.6.0: resolution: {integrity: sha512-xrcqhWDvtZ7WLmt8G4f3hHy37iK7D2idtosRgkeiSPZEPmBShp0VfmRBLWAPC6zLF48APJ21yfea+RfQMF4/Aw==} engines: {node: '>= 4.0'} @@ -21106,9 +19878,6 @@ packages: engines: {node: '>= 14'} hasBin: true - yargs-parser@15.0.3: - resolution: {integrity: sha512-/MVEVjTXy/cGAjdtQf8dW3V9b97bPN7rNn8ETj6BmAQL7ibC7O1Q9SPJbGjgh3SlwoBNXMzj/ZGIj8mBgl12YA==} - yargs-parser@18.1.3: resolution: {integrity: sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==} engines: {node: '>=6'} @@ -21121,9 +19890,6 @@ packages: resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==} engines: {node: '>=12'} - yargs@14.2.3: - resolution: {integrity: sha512-ZbotRWhF+lkjijC/VhmOT9wSgyBQ7+zr13+YLkhfsSiTriYsMzkTUFP18pFhWwBeMa5gUc1MzbhrO6/VB7c9Xg==} - yargs@15.4.1: resolution: {integrity: sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==} engines: {node: '>=8'} @@ -21215,39 +19981,6 @@ packages: snapshots: - 0x@5.8.0: - dependencies: - ajv: 8.17.1 - browserify: 17.0.1 - concat-stream: 2.0.0 - d3-fg: 6.14.0 - debounce: 1.2.1 - debug: 4.4.1(supports-color@10.0.0) - end-of-stream: 1.4.4 - env-string: 1.0.1 - escape-string-regexp: 4.0.0 - execspawn: 1.0.1 - fs-extra: 10.1.0 - has-unicode: 2.0.1 - hsl-to-rgb-for-reals: 1.1.1 - jsonstream2: 3.0.0 - make-dir: 3.1.0 - minimist: 1.2.7 - morphdom: 2.7.7 - nanohtml: 1.10.0 - on-net-listen: 1.1.2 - opn: 5.5.0 - pump: 3.0.2 - pumpify: 2.0.1 - semver: 7.7.3 - single-line-log: 1.1.2 - split2: 4.2.0 - tachyons: 4.12.0 - through2: 4.0.2 - which: 2.0.2 - transitivePeerDependencies: - - supports-color - '@adobe/css-tools@4.4.0': {} '@ai-sdk/anthropic@2.0.4(zod@3.25.76)': @@ -21524,8 +20257,6 @@ snapshots: '@arr/every@1.0.1': {} - '@assemblyscript/loader@0.19.23': {} - '@aws-crypto/crc32@3.0.0': dependencies: '@aws-crypto/util': 3.0.0 @@ -23974,123 +22705,6 @@ snapshots: dependencies: '@clickhouse/client-common': 1.12.1 - '@clinic/bubbleprof@10.0.0': - dependencies: - '@clinic/clinic-common': 7.1.0 - '@clinic/node-trace-log-join': 2.0.0 - '@clinic/trace-events-parser': 2.0.0 - array-flatten: 3.0.0 - async: 3.2.6 - d3-axis: 1.0.12 - d3-color: 1.4.1 - d3-drag: 1.2.5 - d3-ease: 1.0.7 - d3-format: 1.4.5 - d3-interpolate: 1.4.0 - d3-scale: 3.3.0 - d3-selection: 1.4.2 - d3-shape: 1.3.7 - d3-time: 1.1.0 - d3-time-format: 2.3.0 - d3-transition: 1.3.2 - endpoint: 0.4.5 - lodash: 4.17.21 - minify-stream: 2.1.0 - mkdirp: 1.0.4 - on-net-listen: 1.1.2 - protocol-buffers: 4.2.0 - pump: 3.0.2 - - '@clinic/clinic-common@7.1.0': - dependencies: - brfs: 2.0.2 - browserify: 17.0.1 - chalk: 4.1.2 - lodash.debounce: 4.0.8 - loose-envify: 1.4.0 - postcss: 8.5.6 - postcss-import: 13.0.0(postcss@8.5.6) - stream-template: 0.0.10 - webfontloader: 1.6.28 - - '@clinic/doctor@11.0.0(encoding@0.1.13)': - dependencies: - '@clinic/clinic-common': 7.1.0 - '@clinic/node-trace-log-join': 2.0.0 - '@clinic/trace-events-parser': 2.0.0 - '@tensorflow/tfjs-backend-cpu': 3.21.0(@tensorflow/tfjs-core@3.21.0(encoding@0.1.13)) - '@tensorflow/tfjs-core': 3.21.0(encoding@0.1.13) - async: 3.2.6 - clipboard-copy: 4.0.1 - d3-array: 2.12.1 - d3-axis: 1.0.12 - d3-scale: 3.3.0 - d3-selection: 1.4.2 - d3-shape: 1.3.7 - d3-time-format: 2.3.0 - debug: 4.4.1(supports-color@10.0.0) - distributions: 2.2.0 - endpoint: 0.4.5 - hidden-markov-model-tf: 4.0.0(@tensorflow/tfjs-core@3.21.0(encoding@0.1.13)) - minify-stream: 2.1.0 - mkdirp: 1.0.4 - on-net-listen: 1.1.2 - protocol-buffers: 4.2.0 - pump: 3.0.2 - pumpify: 2.0.1 - semver: 7.7.3 - showdown: 1.9.1 - stream-template: 0.0.10 - streaming-json-stringify: 3.1.0 - summary: 2.1.0 - ttest: 3.0.0 - transitivePeerDependencies: - - encoding - - supports-color - - '@clinic/flame@13.0.0': - dependencies: - 0x: 5.8.0 - '@clinic/clinic-common': 7.1.0 - copy-to-clipboard: 3.3.3 - d3-array: 2.12.1 - d3-fg: 6.14.0 - d3-selection: 1.4.2 - flame-gradient: 1.0.0 - lodash.debounce: 4.0.8 - pump: 3.0.2 - querystringify: 2.2.0 - rimraf: 3.0.2 - transitivePeerDependencies: - - supports-color - - '@clinic/heap-profiler@5.0.0': - dependencies: - '@clinic/clinic-common': 7.1.0 - '@nearform/heap-profiler': 2.0.0 - abort-controller: 3.0.0 - copy-to-clipboard: 3.3.3 - d3-array: 2.12.1 - d3-fg: 6.14.0 - d3-selection: 1.4.2 - fs-extra: 11.3.2 - lodash.debounce: 4.0.8 - on-net-listen: 1.1.2 - pump: 3.0.2 - querystringify: 2.2.0 - sinusoidal-decimal: 1.0.0 - - '@clinic/node-trace-log-join@2.0.0': - dependencies: - '@clinic/trace-events-parser': 2.0.0 - multistream: 2.1.1 - pump: 3.0.2 - through2: 2.0.5 - - '@clinic/trace-events-parser@2.0.0': - dependencies: - turbo-json-parse: 2.3.0 - '@codemirror/autocomplete@6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.3.0)': dependencies: '@codemirror/language': 6.3.2 @@ -25466,11 +24080,6 @@ snapshots: '@msgpack/msgpack@3.0.0-beta2': {} - '@nearform/heap-profiler@2.0.0': - dependencies: - abort-controller: 3.0.0 - sonic-boom: 1.4.1 - '@neondatabase/serverless@0.9.5': dependencies: '@types/pg': 8.11.6 @@ -31698,25 +30307,6 @@ snapshots: graphql: 16.6.0 zod: 3.25.76 - '@tensorflow/tfjs-backend-cpu@3.21.0(@tensorflow/tfjs-core@3.21.0(encoding@0.1.13))': - dependencies: - '@tensorflow/tfjs-core': 3.21.0(encoding@0.1.13) - '@types/seedrandom': 2.4.34 - seedrandom: 3.0.5 - - '@tensorflow/tfjs-core@3.21.0(encoding@0.1.13)': - dependencies: - '@types/long': 4.0.2 - '@types/offscreencanvas': 2019.3.0 - '@types/seedrandom': 2.4.34 - '@types/webgl-ext': 0.0.30 - '@webgpu/types': 0.1.16 - long: 4.0.0 - node-fetch: 2.6.12(encoding@0.1.13) - seedrandom: 3.0.5 - transitivePeerDependencies: - - encoding - '@testcontainers/postgresql@10.28.0': dependencies: testcontainers: 10.28.0 @@ -32078,8 +30668,6 @@ snapshots: '@types/lodash@4.14.191': {} - '@types/long@4.0.2': {} - '@types/marked@4.0.8': {} '@types/mdast@3.0.10': @@ -32156,8 +30744,6 @@ snapshots: '@types/object-hash@3.0.6': {} - '@types/offscreencanvas@2019.3.0': {} - '@types/pg-pool@2.0.6': dependencies: '@types/pg': 8.11.14 @@ -32264,8 +30850,6 @@ snapshots: '@types/scheduler@0.16.2': {} - '@types/seedrandom@2.4.34': {} - '@types/seedrandom@3.0.8': {} '@types/semver@6.2.3': {} @@ -32342,8 +30926,6 @@ snapshots: '@types/uuid@9.0.0': {} - '@types/webgl-ext@0.0.30': {} - '@types/webpack@5.28.5(@swc/core@1.3.101(@swc/helpers@0.5.15))(esbuild@0.19.11)': dependencies: '@types/node': 20.14.14 @@ -32872,8 +31454,6 @@ snapshots: '@webassemblyjs/ast': 1.14.1 '@xtuc/long': 4.2.2 - '@webgpu/types@0.1.16': {} - '@whatwg-node/events@0.1.1': {} '@whatwg-node/fetch@0.9.14': @@ -32919,11 +31499,6 @@ snapshots: '@zxing/text-encoding@0.9.0': optional: true - JSONStream@1.3.5: - dependencies: - jsonparse: 1.3.1 - through: 2.3.8 - abbrev@2.0.0: {} abort-controller@3.0.0: @@ -33117,30 +31692,16 @@ snapshots: json-schema-traverse: 1.0.0 require-from-string: 2.0.2 - ansi-align@3.0.1: - dependencies: - string-width: 4.2.3 - ansi-colors@4.1.3: {} - ansi-escapes@3.2.0: {} - ansi-escapes@7.0.0: dependencies: environment: 1.1.0 - ansi-regex@2.1.1: {} - - ansi-regex@3.0.1: {} - - ansi-regex@4.1.1: {} - ansi-regex@5.0.1: {} ansi-regex@6.0.1: {} - ansi-styles@2.2.1: {} - ansi-styles@3.2.1: dependencies: color-convert: 1.9.3 @@ -33159,8 +31720,6 @@ snapshots: any-promise@1.3.0: {} - any-shell-escape@0.1.1: {} - anymatch@3.1.3: dependencies: normalize-path: 3.0.0 @@ -33222,10 +31781,6 @@ snapshots: array-flatten@1.1.1: {} - array-flatten@3.0.0: {} - - array-from@2.1.1: {} - array-includes@3.1.6: dependencies: call-bind: 1.0.8 @@ -33307,12 +31862,6 @@ snapshots: asap@2.0.6: {} - asn1.js@4.10.1: - dependencies: - bn.js: 4.12.2 - inherits: 2.0.4 - minimalistic-assert: 1.0.1 - asn1@0.2.6: dependencies: safer-buffer: 2.1.2 @@ -33321,11 +31870,6 @@ snapshots: assert-plus@1.0.0: {} - assert@1.5.1: - dependencies: - object.assign: 4.1.5 - util: 0.10.4 - assertion-error@2.0.1: {} ast-types-flow@0.0.7: {} @@ -33340,44 +31884,12 @@ snapshots: async-lock@1.4.1: {} - async@2.6.4: - dependencies: - lodash: 4.17.21 - async@3.2.6: {} asynckit@0.4.0: {} atomic-sleep@1.0.0: {} - atomically@1.7.0: {} - - autocannon@7.15.0: - dependencies: - chalk: 4.1.2 - char-spinner: 1.0.1 - cli-table3: 0.6.5 - color-support: 1.1.3 - cross-argv: 2.0.0 - form-data: 4.0.4 - has-async-hooks: 1.0.0 - hdr-histogram-js: 3.0.1 - hdr-histogram-percentiles-obj: 3.0.0 - http-parser-js: 0.5.10 - hyperid: 3.3.0 - lodash.chunk: 4.2.0 - lodash.clonedeep: 4.5.0 - lodash.flatten: 4.4.0 - manage-path: 2.0.0 - on-net-listen: 1.1.2 - pretty-bytes: 5.6.0 - progress: 2.0.3 - reinterval: 1.1.0 - retimer: 3.0.0 - semver: 7.7.3 - subarg: 1.0.0 - timestring: 6.0.0 - autoevals@0.0.130(encoding@0.1.13)(ws@8.12.0(bufferutil@4.0.9)): dependencies: ajv: 8.17.1 @@ -33542,18 +32054,12 @@ snapshots: bintrees@1.0.2: {} - bit-twiddle@1.0.2: {} - bl@4.1.0: dependencies: buffer: 5.7.1 inherits: 2.0.4 readable-stream: 3.6.2 - bn.js@4.12.2: {} - - bn.js@5.2.2: {} - body-parser@1.20.3: dependencies: bytes: 3.1.2 @@ -33591,17 +32097,6 @@ snapshots: bowser@2.12.1: {} - boxen@5.1.2: - dependencies: - ansi-align: 3.0.1 - camelcase: 6.3.0 - chalk: 4.1.2 - cli-boxes: 2.2.1 - string-width: 4.2.3 - type-fest: 0.20.2 - widest-line: 3.1.0 - wrap-ansi: 7.0.0 - brace-expansion@1.1.11: dependencies: balanced-match: 1.0.2 @@ -33619,129 +32114,10 @@ snapshots: dependencies: wcwidth: 1.0.1 - brfs@2.0.2: - dependencies: - quote-stream: 1.0.2 - resolve: 1.22.8 - static-module: 3.0.4 - through2: 2.0.5 - - brorand@1.1.0: {} - - browser-pack@6.1.0: - dependencies: - JSONStream: 1.3.5 - combine-source-map: 0.8.0 - defined: 1.0.1 - safe-buffer: 5.2.1 - through2: 2.0.5 - umd: 3.0.3 - - browser-process-hrtime@0.1.3: {} - - browser-resolve@2.0.0: - dependencies: - resolve: 1.22.8 - - browserify-aes@1.2.0: - dependencies: - buffer-xor: 1.0.3 - cipher-base: 1.0.7 - create-hash: 1.2.0 - evp_bytestokey: 1.0.3 - inherits: 2.0.4 - safe-buffer: 5.2.1 - - browserify-cipher@1.0.1: - dependencies: - browserify-aes: 1.2.0 - browserify-des: 1.0.2 - evp_bytestokey: 1.0.3 - - browserify-des@1.0.2: - dependencies: - cipher-base: 1.0.7 - des.js: 1.1.0 - inherits: 2.0.4 - safe-buffer: 5.2.1 - - browserify-rsa@4.1.1: - dependencies: - bn.js: 5.2.2 - randombytes: 2.1.0 - safe-buffer: 5.2.1 - - browserify-sign@4.2.5: - dependencies: - bn.js: 5.2.2 - browserify-rsa: 4.1.1 - create-hash: 1.2.0 - create-hmac: 1.1.7 - elliptic: 6.6.1 - inherits: 2.0.4 - parse-asn1: 5.1.9 - readable-stream: 2.3.8 - safe-buffer: 5.2.1 - browserify-zlib@0.1.4: dependencies: pako: 0.2.9 - browserify-zlib@0.2.0: - dependencies: - pako: 1.0.11 - - browserify@17.0.1: - dependencies: - JSONStream: 1.3.5 - assert: 1.5.1 - browser-pack: 6.1.0 - browser-resolve: 2.0.0 - browserify-zlib: 0.2.0 - buffer: 5.2.1 - cached-path-relative: 1.1.0 - concat-stream: 1.6.2 - console-browserify: 1.2.0 - constants-browserify: 1.0.0 - crypto-browserify: 3.12.1 - defined: 1.0.1 - deps-sort: 2.0.1 - domain-browser: 1.2.0 - duplexer2: 0.1.4 - events: 3.3.0 - glob: 7.2.3 - hasown: 2.0.2 - htmlescape: 1.1.1 - https-browserify: 1.0.0 - inherits: 2.0.4 - insert-module-globals: 7.2.1 - labeled-stream-splicer: 2.0.2 - mkdirp-classic: 0.5.3 - module-deps: 6.2.3 - os-browserify: 0.3.0 - parents: 1.0.1 - path-browserify: 1.0.1 - process: 0.11.10 - punycode: 1.4.1 - querystring-es3: 0.2.1 - read-only-stream: 2.0.0 - readable-stream: 2.3.8 - resolve: 1.22.8 - shasum-object: 1.0.1 - shell-quote: 1.8.1 - stream-browserify: 3.0.0 - stream-http: 3.2.0 - string_decoder: 1.3.0 - subarg: 1.0.0 - syntax-error: 1.4.0 - through2: 2.0.5 - timers-browserify: 1.4.2 - tty-browserify: 0.0.1 - url: 0.11.4 - util: 0.12.5 - vm-browserify: 1.1.2 - xtend: 4.0.2 - browserslist@4.21.4: dependencies: caniuse-lite: 1.0.30001577 @@ -33772,17 +32148,8 @@ snapshots: buffer-equal-constant-time@1.0.1: {} - buffer-equal@0.0.1: {} - buffer-from@1.1.2: {} - buffer-xor@1.0.3: {} - - buffer@5.2.1: - dependencies: - base64-js: 1.5.1 - ieee754: 1.2.1 - buffer@5.7.1: dependencies: base64-js: 1.5.1 @@ -33800,8 +32167,6 @@ snapshots: buildcheck@0.0.6: optional: true - builtin-status-codes@3.0.0: {} - builtins@1.0.3: {} builtins@5.0.1: @@ -33893,8 +32258,6 @@ snapshots: normalize-url: 4.5.1 responselike: 1.0.2 - cached-path-relative@1.1.0: {} - call-bind-apply-helpers@1.0.2: dependencies: es-errors: 1.3.0 @@ -33922,11 +32285,6 @@ snapshots: callsites@3.1.0: {} - camel-case@3.0.0: - dependencies: - no-case: 2.3.2 - upper-case: 1.1.3 - camelcase-css@2.0.1: {} camelcase-keys@6.2.2: @@ -33937,8 +32295,6 @@ snapshots: camelcase@5.3.1: {} - camelcase@6.3.0: {} - caniuse-lite@1.0.30001577: {} caniuse-lite@1.0.30001699: {} @@ -33953,8 +32309,6 @@ snapshots: ccount@2.0.1: {} - cephes@2.0.0: {} - chai@5.2.0: dependencies: assertion-error: 2.0.1 @@ -33963,14 +32317,6 @@ snapshots: loupe: 3.1.3 pathval: 2.0.0 - chalk@1.1.3: - dependencies: - ansi-styles: 2.2.1 - escape-string-regexp: 1.0.5 - has-ansi: 2.0.0 - strip-ansi: 3.0.1 - supports-color: 2.0.0 - chalk@2.4.2: dependencies: ansi-styles: 3.2.1 @@ -33993,8 +32339,6 @@ snapshots: char-regex@1.0.2: {} - char-spinner@1.0.1: {} - character-entities-html4@2.1.0: {} character-entities-legacy@3.0.0: {} @@ -34067,16 +32411,8 @@ snapshots: mitt: 3.0.1 zod: 3.25.76 - ci-info@2.0.0: {} - ci-info@3.8.0: {} - cipher-base@1.0.7: - dependencies: - inherits: 2.0.4 - safe-buffer: 5.2.1 - to-buffer: 1.2.2 - citty@0.1.6: dependencies: consola: 3.4.2 @@ -34101,12 +32437,6 @@ snapshots: dependencies: escape-string-regexp: 5.0.0 - cli-boxes@2.2.1: {} - - cli-cursor@2.1.0: - dependencies: - restore-cursor: 2.0.0 - cli-cursor@3.1.0: dependencies: restore-cursor: 3.1.0 @@ -34134,44 +32464,8 @@ snapshots: optionalDependencies: '@colors/colors': 1.5.0 - cli-width@2.2.1: {} - client-only@0.0.1: {} - clinic@13.0.0(encoding@0.1.13): - dependencies: - '@clinic/bubbleprof': 10.0.0 - '@clinic/doctor': 11.0.0(encoding@0.1.13) - '@clinic/flame': 13.0.0 - '@clinic/heap-profiler': 5.0.0 - any-shell-escape: 0.1.1 - async: 3.2.6 - autocannon: 7.15.0 - commist: 1.1.0 - cross-argv: 1.0.0 - dargs: 7.0.0 - env-string: 1.0.1 - execspawn: 1.0.1 - insight: 0.11.1 - minimist: 1.2.7 - open: 7.4.2 - ora: 5.4.1 - rimraf: 3.0.2 - stream-collector: 1.0.1 - subarg: 1.0.0 - update-notifier: 5.1.0 - transitivePeerDependencies: - - encoding - - supports-color - - clipboard-copy@4.0.1: {} - - cliui@5.0.0: - dependencies: - string-width: 3.1.0 - strip-ansi: 5.2.0 - wrap-ansi: 5.1.0 - cliui@6.0.0: dependencies: string-width: 4.2.3 @@ -34206,8 +32500,6 @@ snapshots: cluster-key-slot@1.1.2: {} - code-point-at@1.1.0: {} - codemirror@6.0.2(@lezer/common@1.3.0): dependencies: '@codemirror/autocomplete': 6.4.0(@codemirror/language@6.3.2)(@codemirror/state@6.2.0)(@codemirror/view@6.7.2)(@lezer/common@1.3.0) @@ -34237,8 +32529,6 @@ snapshots: color-name: 1.1.4 simple-swizzle: 0.2.2 - color-support@1.1.3: {} - color@3.2.1: dependencies: color-convert: 1.9.3 @@ -34250,13 +32540,6 @@ snapshots: color-string: 1.9.1 optional: true - combine-source-map@0.8.0: - dependencies: - convert-source-map: 1.1.3 - inline-source-map: 0.6.3 - lodash.memoize: 3.0.4 - source-map: 0.5.6 - combined-stream@1.0.8: dependencies: delayed-stream: 1.0.0 @@ -34279,11 +32562,6 @@ snapshots: commander@9.5.0: {} - commist@1.1.0: - dependencies: - leven: 2.1.0 - minimist: 1.2.7 - compare-versions@6.1.1: {} component-emitter@1.3.1: {} @@ -34331,33 +32609,6 @@ snapshots: concat-map@0.0.1: {} - concat-stream@1.6.2: - dependencies: - buffer-from: 1.1.2 - inherits: 2.0.4 - readable-stream: 2.3.8 - typedarray: 0.0.6 - - concat-stream@2.0.0: - dependencies: - buffer-from: 1.1.2 - inherits: 2.0.4 - readable-stream: 3.6.2 - typedarray: 0.0.6 - - conf@10.2.0: - dependencies: - ajv: 8.17.1 - ajv-formats: 2.1.1(ajv@8.17.1) - atomically: 1.7.0 - debounce-fn: 4.0.0 - dot-prop: 6.0.1 - env-paths: 2.2.1 - json-schema-typed: 7.0.3 - onetime: 5.1.2 - pkg-up: 3.1.0 - semver: 7.7.3 - confbox@0.1.8: {} confbox@0.2.2: {} @@ -34367,21 +32618,8 @@ snapshots: ini: 1.3.8 proto-list: 1.2.4 - configstore@5.0.1: - dependencies: - dot-prop: 5.3.0 - graceful-fs: 4.2.11 - make-dir: 3.1.0 - unique-string: 2.0.0 - write-file-atomic: 3.0.3 - xdg-basedir: 4.0.0 - consola@3.4.2: {} - console-browserify@1.2.0: {} - - constants-browserify@1.0.0: {} - content-disposition@0.5.4: dependencies: safe-buffer: 5.2.1 @@ -34392,8 +32630,6 @@ snapshots: content-type@1.0.5: {} - convert-source-map@1.1.3: {} - convert-source-map@1.9.0: {} cookie-signature@1.0.6: {} @@ -34490,28 +32726,6 @@ snapshots: crc-32: 1.2.2 readable-stream: 4.7.0 - create-ecdh@4.0.4: - dependencies: - bn.js: 4.12.2 - elliptic: 6.6.1 - - create-hash@1.2.0: - dependencies: - cipher-base: 1.0.7 - inherits: 2.0.4 - md5.js: 1.3.5 - ripemd160: 2.0.3 - sha.js: 2.4.12 - - create-hmac@1.1.7: - dependencies: - cipher-base: 1.0.7 - create-hash: 1.2.0 - inherits: 2.0.4 - ripemd160: 2.0.3 - safe-buffer: 5.2.1 - sha.js: 2.4.12 - crelt@1.0.6: {} cron-parser@4.9.0: @@ -34522,10 +32736,6 @@ snapshots: cronstrue@2.61.0: {} - cross-argv@1.0.0: {} - - cross-argv@2.0.0: {} - cross-env@7.0.3: dependencies: cross-spawn: 7.0.3 @@ -34556,27 +32766,10 @@ snapshots: shebang-command: 2.0.0 which: 2.0.2 - crypto-browserify@3.12.1: - dependencies: - browserify-cipher: 1.0.1 - browserify-sign: 4.2.5 - create-ecdh: 4.0.4 - create-hash: 1.2.0 - create-hmac: 1.1.7 - diffie-hellman: 5.0.3 - hash-base: 3.0.5 - inherits: 2.0.4 - pbkdf2: 3.1.5 - public-encrypt: 4.0.3 - randombytes: 2.1.0 - randomfill: 1.0.4 - crypto-js@4.1.1: {} crypto-js@4.2.0: {} - crypto-random-string@2.0.0: {} - css-in-js-utils@3.1.0: dependencies: hyphenate-style-name: 1.0.4 @@ -34628,10 +32821,6 @@ snapshots: cuid@2.1.8: {} - cwise-compiler@1.1.3: - dependencies: - uniq: 1.0.1 - cytoscape-cose-bilkent@4.1.0(cytoscape@3.33.1): dependencies: cose-base: 1.0.3 @@ -34652,8 +32841,6 @@ snapshots: dependencies: internmap: 2.0.3 - d3-axis@1.0.12: {} - d3-axis@3.0.0: {} d3-brush@3.0.0: @@ -34668,10 +32855,6 @@ snapshots: dependencies: d3-path: 3.1.0 - d3-color@1.4.1: {} - - d3-color@2.0.0: {} - d3-color@3.1.0: {} d3-contour@4.0.2: @@ -34682,15 +32865,8 @@ snapshots: dependencies: delaunator: 5.0.1 - d3-dispatch@1.0.6: {} - d3-dispatch@3.0.1: {} - d3-drag@1.2.5: - dependencies: - d3-dispatch: 1.0.6 - d3-selection: 1.4.2 - d3-drag@3.0.0: dependencies: d3-dispatch: 3.0.1 @@ -34702,54 +32878,26 @@ snapshots: iconv-lite: 0.6.3 rw: 1.3.3 - d3-ease@1.0.7: {} - d3-ease@3.0.1: {} d3-fetch@3.0.1: dependencies: d3-dsv: 3.0.1 - d3-fg@6.14.0: - dependencies: - d3-array: 2.12.1 - d3-dispatch: 1.0.6 - d3-ease: 1.0.7 - d3-hierarchy: 1.1.9 - d3-scale: 3.3.0 - d3-selection: 1.4.2 - d3-zoom: 1.8.3 - escape-string-regexp: 1.0.5 - hsl-to-rgb-for-reals: 1.1.1 - d3-force@3.0.0: dependencies: d3-dispatch: 3.0.1 d3-quadtree: 3.0.1 d3-timer: 3.0.1 - d3-format@1.4.5: {} - - d3-format@2.0.0: {} - d3-format@3.1.0: {} d3-geo@3.1.1: dependencies: d3-array: 3.2.4 - d3-hierarchy@1.1.9: {} - d3-hierarchy@3.1.2: {} - d3-interpolate@1.4.0: - dependencies: - d3-color: 1.4.1 - - d3-interpolate@2.0.1: - dependencies: - d3-color: 2.0.0 - d3-interpolate@3.0.1: dependencies: d3-color: 3.1.0 @@ -34774,14 +32922,6 @@ snapshots: d3-color: 3.1.0 d3-interpolate: 3.0.1 - d3-scale@3.3.0: - dependencies: - d3-array: 2.12.1 - d3-format: 2.0.0 - d3-interpolate: 2.0.1 - d3-time: 2.1.1 - d3-time-format: 2.3.0 - d3-scale@4.0.2: dependencies: d3-array: 3.2.4 @@ -34790,8 +32930,6 @@ snapshots: d3-time: 3.1.0 d3-time-format: 4.1.0 - d3-selection@1.4.2: {} - d3-selection@3.0.0: {} d3-shape@1.3.7: @@ -34802,37 +32940,16 @@ snapshots: dependencies: d3-path: 3.1.0 - d3-time-format@2.3.0: - dependencies: - d3-time: 1.1.0 - d3-time-format@4.1.0: dependencies: d3-time: 3.1.0 - d3-time@1.1.0: {} - - d3-time@2.1.1: - dependencies: - d3-array: 2.12.1 - d3-time@3.1.0: dependencies: d3-array: 3.2.4 - d3-timer@1.0.10: {} - d3-timer@3.0.1: {} - d3-transition@1.3.2: - dependencies: - d3-color: 1.4.1 - d3-dispatch: 1.0.6 - d3-ease: 1.0.7 - d3-interpolate: 1.4.0 - d3-selection: 1.4.2 - d3-timer: 1.0.10 - d3-transition@3.0.1(d3-selection@3.0.0): dependencies: d3-color: 3.1.0 @@ -34842,14 +32959,6 @@ snapshots: d3-selection: 3.0.0 d3-timer: 3.0.1 - d3-zoom@1.8.3: - dependencies: - d3-dispatch: 1.0.6 - d3-drag: 1.2.5 - d3-interpolate: 1.4.0 - d3-selection: 1.4.2 - d3-transition: 1.3.2 - d3-zoom@3.0.0: dependencies: d3-dispatch: 3.0.1 @@ -34891,11 +33000,6 @@ snapshots: d3-transition: 3.0.1(d3-selection@3.0.0) d3-zoom: 3.0.0 - d@1.0.2: - dependencies: - es5-ext: 0.10.64 - type: 2.7.3 - dagre-d3-es@7.0.11: dependencies: d3: 7.9.0 @@ -34903,12 +33007,6 @@ snapshots: damerau-levenshtein@1.0.8: {} - dargs@7.0.0: {} - - dash-ast@1.0.0: {} - - dash-ast@2.0.1: {} - dashdash@1.14.1: dependencies: assert-plus: 1.0.0 @@ -34941,10 +33039,6 @@ snapshots: dayjs@1.11.18: {} - debounce-fn@4.0.0: - dependencies: - mimic-fn: 3.1.0 - debounce@1.2.1: {} debounce@2.0.0: {} @@ -35074,20 +33168,8 @@ snapshots: deprecation@2.3.1: {} - deps-sort@2.0.1: - dependencies: - JSONStream: 1.3.5 - shasum-object: 1.0.1 - subarg: 1.0.0 - through2: 2.0.5 - dequal@2.0.3: {} - des.js@1.1.0: - dependencies: - inherits: 2.0.4 - minimalistic-assert: 1.0.1 - destr@2.0.3: {} destroy@1.2.0: {} @@ -35123,22 +33205,12 @@ snapshots: diff@5.1.0: {} - diffie-hellman@5.0.3: - dependencies: - bn.js: 4.12.2 - miller-rabin: 4.0.1 - randombytes: 2.1.0 - dir-glob@3.0.1: dependencies: path-type: 4.0.0 discontinuous-range@1.0.0: {} - distributions@2.2.0: - dependencies: - cephes: 2.0.0 - dlv@1.1.3: {} docker-compose@0.24.8: @@ -35189,8 +33261,6 @@ snapshots: domhandler: 5.0.3 entities: 4.5.0 - domain-browser@1.2.0: {} - domelementtype@2.3.0: {} domhandler@5.0.3: @@ -35207,14 +33277,6 @@ snapshots: domelementtype: 2.3.0 domhandler: 5.0.3 - dot-prop@5.3.0: - dependencies: - is-obj: 2.0.0 - - dot-prop@6.0.1: - dependencies: - is-obj: 2.0.0 - dotenv@16.0.3: {} dotenv@16.4.4: {} @@ -35239,12 +33301,6 @@ snapshots: es-errors: 1.3.0 gopd: 1.2.0 - dup@1.0.0: {} - - duplexer2@0.1.4: - dependencies: - readable-stream: 2.3.8 - duplexer3@0.1.5: {} duplexer@0.1.2: {} @@ -35319,18 +33375,6 @@ snapshots: electron-to-chromium@1.5.98: {} - elliptic@6.6.1: - dependencies: - bn.js: 4.12.2 - brorand: 1.1.0 - hash.js: 1.1.7 - hmac-drbg: 1.0.1 - inherits: 2.0.4 - minimalistic-assert: 1.0.1 - minimalistic-crypto-utils: 1.0.1 - - emoji-regex@7.0.3: {} - emoji-regex@8.0.0: {} emoji-regex@9.2.2: {} @@ -35351,10 +33395,6 @@ snapshots: dependencies: once: 1.4.0 - endpoint@0.4.5: - dependencies: - inherits: 2.0.4 - engine.io-client@6.5.3(bufferutil@4.0.9)(supports-color@10.0.0): dependencies: '@socket.io/component-emitter': 3.1.0 @@ -35406,8 +33446,6 @@ snapshots: env-paths@2.2.1: {} - env-string@1.0.1: {} - environment@1.1.0: {} err-code@2.0.3: {} @@ -35552,42 +33590,6 @@ snapshots: is-date-object: 1.0.5 is-symbol: 1.0.4 - es5-ext@0.10.64: - dependencies: - es6-iterator: 2.0.3 - es6-symbol: 3.1.4 - esniff: 2.0.1 - next-tick: 1.1.0 - - es6-iterator@2.0.3: - dependencies: - d: 1.0.2 - es5-ext: 0.10.64 - es6-symbol: 3.1.4 - - es6-map@0.1.5: - dependencies: - d: 1.0.2 - es5-ext: 0.10.64 - es6-iterator: 2.0.3 - es6-set: 0.1.6 - es6-symbol: 3.1.4 - event-emitter: 0.3.5 - - es6-set@0.1.6: - dependencies: - d: 1.0.2 - es5-ext: 0.10.64 - es6-iterator: 2.0.3 - es6-symbol: 3.1.4 - event-emitter: 0.3.5 - type: 2.7.3 - - es6-symbol@3.1.4: - dependencies: - d: 1.0.2 - ext: 1.7.0 - esbuild-android-64@0.15.18: optional: true @@ -35839,8 +33841,6 @@ snapshots: escalade@3.2.0: {} - escape-goat@2.1.1: {} - escape-html@1.0.3: {} escape-string-regexp@1.0.5: {} @@ -35849,15 +33849,6 @@ snapshots: escape-string-regexp@5.0.0: {} - escodegen@1.14.3: - dependencies: - esprima: 4.0.1 - estraverse: 4.3.0 - esutils: 2.0.3 - optionator: 0.8.3 - optionalDependencies: - source-map: 0.6.1 - escodegen@2.1.0: dependencies: esprima: 4.0.1 @@ -36129,13 +34120,6 @@ snapshots: esm-env@1.2.2: {} - esniff@2.0.1: - dependencies: - d: 1.0.2 - es5-ext: 0.10.64 - event-emitter: 0.3.5 - type: 2.7.3 - espree@9.4.1: dependencies: acorn: 8.12.1 @@ -36166,10 +34150,6 @@ snapshots: estraverse@5.3.0: {} - estree-is-function@1.0.0: {} - - estree-is-member-expression@1.0.0: {} - estree-util-attach-comments@2.1.0: dependencies: '@types/estree': 1.0.8 @@ -36231,11 +34211,6 @@ snapshots: - bufferutil - utf-8-validate - event-emitter@0.3.5: - dependencies: - d: 1.0.2 - es5-ext: 0.10.64 - event-target-shim@5.0.1: {} event-target-shim@6.0.2: {} @@ -36262,29 +34237,12 @@ snapshots: dependencies: eventsource-parser: 3.0.3 - evp_bytestokey@1.0.3: - dependencies: - md5.js: 1.3.5 - safe-buffer: 5.2.1 - evt@2.4.13: dependencies: minimal-polyfills: 2.2.2 run-exclusive: 2.2.18 tsafe: 1.4.1 - execa@4.1.0: - dependencies: - cross-spawn: 7.0.6 - get-stream: 5.2.0 - human-signals: 1.1.1 - is-stream: 2.0.1 - merge-stream: 2.0.0 - npm-run-path: 4.0.1 - onetime: 5.1.2 - signal-exit: 3.0.7 - strip-final-newline: 2.0.0 - execa@5.1.1: dependencies: cross-spawn: 7.0.6 @@ -36309,10 +34267,6 @@ snapshots: signal-exit: 4.1.0 strip-final-newline: 3.0.0 - execspawn@1.0.1: - dependencies: - util-extend: 1.0.3 - exit-hook@2.2.1: {} expand-template@2.0.3: {} @@ -36398,10 +34352,6 @@ snapshots: exsolve@1.0.7: {} - ext@1.7.0: - dependencies: - type: 2.7.3 - extend@3.0.2: {} extendable-error@0.1.7: {} @@ -36547,10 +34497,6 @@ snapshots: fft.js@4.0.4: {} - figures@2.0.0: - dependencies: - escape-string-regexp: 1.0.5 - file-entry-cache@6.0.1: dependencies: flat-cache: 3.0.4 @@ -36603,10 +34549,6 @@ snapshots: fast-querystring: 1.1.2 safe-regex2: 5.0.0 - find-up@3.0.0: - dependencies: - locate-path: 3.0.0 - find-up@4.1.0: dependencies: locate-path: 5.0.0 @@ -36628,17 +34570,11 @@ snapshots: micromatch: 4.0.8 pkg-dir: 4.2.0 - flame-gradient@1.0.0: - dependencies: - sinusoidal-decimal: 1.0.0 - flat-cache@3.0.4: dependencies: flatted: 3.2.7 rimraf: 3.0.2 - flatstr@1.0.12: {} - flatted@3.2.7: {} follow-redirects@1.15.9: {} @@ -36647,10 +34583,6 @@ snapshots: dependencies: is-callable: 1.2.7 - for-each@0.3.5: - dependencies: - is-callable: 1.2.7 - foreground-child@3.1.1: dependencies: cross-spawn: 7.0.6 @@ -36726,15 +34658,6 @@ snapshots: fresh@2.0.0: {} - from2-string@1.1.0: - dependencies: - from2: 2.3.0 - - from2@2.3.0: - dependencies: - inherits: 2.0.4 - readable-stream: 2.3.8 - fs-constants@1.0.0: {} fs-extra@10.1.0: @@ -36743,12 +34666,6 @@ snapshots: jsonfile: 6.1.0 universalify: 2.0.0 - fs-extra@11.3.2: - dependencies: - graceful-fs: 4.2.11 - jsonfile: 6.1.0 - universalify: 2.0.0 - fs-extra@7.0.1: dependencies: graceful-fs: 4.2.11 @@ -36795,22 +34712,12 @@ snapshots: functions-have-names@1.2.3: {} - generate-function@2.3.1: - dependencies: - is-property: 1.0.2 - - generate-object-property@1.2.0: - dependencies: - is-property: 1.0.2 - generic-names@4.0.0: dependencies: loader-utils: 3.2.1 gensync@1.0.0-beta.2: {} - get-assigned-identifiers@1.2.0: {} - get-caller-file@2.0.5: {} get-intrinsic@1.2.4: @@ -36978,10 +34885,6 @@ snapshots: minipass: 4.2.8 path-scurry: 1.11.1 - global-dirs@3.0.1: - dependencies: - ini: 2.0.0 - globals@11.12.0: {} globals@13.19.0: @@ -37098,12 +35001,6 @@ snapshots: hard-rejection@2.1.0: {} - has-ansi@2.0.0: - dependencies: - ansi-regex: 2.1.1 - - has-async-hooks@1.0.0: {} - has-bigints@1.0.2: {} has-flag@3.0.0: {} @@ -37126,31 +35023,10 @@ snapshots: dependencies: has-symbols: 1.1.0 - has-unicode@2.0.1: {} - - has-yarn@2.1.0: {} - has@1.0.3: dependencies: function-bind: 1.1.2 - hash-base@3.0.5: - dependencies: - inherits: 2.0.4 - safe-buffer: 5.2.1 - - hash-base@3.1.2: - dependencies: - inherits: 2.0.4 - readable-stream: 2.3.8 - safe-buffer: 5.2.1 - to-buffer: 1.2.2 - - hash.js@1.1.7: - dependencies: - inherits: 2.0.4 - minimalistic-assert: 1.0.1 - hasown@2.0.2: dependencies: function-bind: 1.1.2 @@ -37297,35 +35173,10 @@ snapshots: property-information: 7.0.0 space-separated-tokens: 2.0.2 - hdr-histogram-js@3.0.1: - dependencies: - '@assemblyscript/loader': 0.19.23 - base64-js: 1.5.1 - pako: 1.0.11 - - hdr-histogram-percentiles-obj@3.0.0: {} - hexoid@1.0.0: {} - hidden-markov-model-tf@4.0.0(@tensorflow/tfjs-core@3.21.0(encoding@0.1.13)): - dependencies: - '@tensorflow/tfjs-core': 3.21.0(encoding@0.1.13) - ml-kmeans: 4.2.1 - ndarray: 1.0.19 - ndarray-cholesky-factorization: 1.0.2 - ndarray-determinant: 1.0.0 - ndarray-inv: 0.2.0 - seedrandom: 3.0.5 - semver: 6.3.1 - highlight.js@10.7.3: {} - hmac-drbg@1.0.1: - dependencies: - hash.js: 1.1.7 - minimalistic-assert: 1.0.1 - minimalistic-crypto-utils: 1.0.1 - hoist-non-react-statics@3.3.2: dependencies: react-is: 16.13.1 @@ -37338,8 +35189,6 @@ snapshots: dependencies: lru-cache: 7.18.3 - hsl-to-rgb-for-reals@1.1.1: {} - html-escaper@2.0.2: {} html-tags@3.3.1: {} @@ -37356,8 +35205,6 @@ snapshots: html-void-elements@3.0.0: {} - htmlescape@1.1.1: {} - htmlparser2@8.0.2: dependencies: domelementtype: 2.3.0 @@ -37375,8 +35222,6 @@ snapshots: statuses: 2.0.1 toidentifier: 1.0.1 - http-parser-js@0.5.10: {} - http-proxy-agent@7.0.2: dependencies: agent-base: 7.1.4 @@ -37390,8 +35235,6 @@ snapshots: jsprim: 1.4.2 sshpk: 1.18.0 - https-browserify@1.0.0: {} - https-proxy-agent@5.0.1: dependencies: agent-base: 6.0.2 @@ -37408,8 +35251,6 @@ snapshots: human-id@1.0.2: {} - human-signals@1.1.1: {} - human-signals@2.1.0: {} human-signals@5.0.0: {} @@ -37420,18 +35261,6 @@ snapshots: dependencies: ms: 2.1.3 - hyperid@3.3.0: - dependencies: - buffer: 5.7.1 - uuid: 8.3.2 - uuid-parse: 1.1.0 - - hyperscript-attribute-to-property@1.0.2: {} - - hyperx@2.5.4: - dependencies: - hyperscript-attribute-to-property: 1.0.2 - hyphenate-style-name@1.0.4: {} iconv-lite@0.4.24: @@ -37475,8 +35304,6 @@ snapshots: cjs-module-lexer: 1.2.3 module-details-from-path: 1.0.3 - import-lazy@2.1.0: {} - import-meta-resolve@4.1.0: {} imurmurhash@0.1.4: {} @@ -37490,20 +35317,12 @@ snapshots: once: 1.4.0 wrappy: 1.0.2 - inherits@2.0.3: {} - inherits@2.0.4: {} ini@1.3.8: {} - ini@2.0.0: {} - ini@5.0.0: {} - inline-source-map@0.6.3: - dependencies: - source-map: 0.5.6 - inline-style-parser@0.1.1: {} inline-style-parser@0.2.4: {} @@ -37517,47 +35336,6 @@ snapshots: react: 18.2.0 react-dom: 18.2.0(react@18.2.0) - inquirer@6.5.2: - dependencies: - ansi-escapes: 3.2.0 - chalk: 2.4.2 - cli-cursor: 2.1.0 - cli-width: 2.2.1 - external-editor: 3.1.0 - figures: 2.0.0 - lodash: 4.17.21 - mute-stream: 0.0.7 - run-async: 2.4.1 - rxjs: 6.6.7 - string-width: 2.1.1 - strip-ansi: 5.2.0 - through: 2.3.8 - - insert-module-globals@7.2.1: - dependencies: - JSONStream: 1.3.5 - acorn-node: 1.8.2 - combine-source-map: 0.8.0 - concat-stream: 1.6.2 - is-buffer: 1.1.6 - path-is-absolute: 1.0.1 - process: 0.11.10 - through2: 2.0.5 - undeclared-identifiers: 1.1.3 - xtend: 4.0.2 - - insight@0.11.1: - dependencies: - async: 2.6.4 - chalk: 4.1.2 - conf: 10.2.0 - inquirer: 6.5.2 - lodash.debounce: 4.0.8 - os-name: 4.0.1 - request: 2.88.2 - tough-cookie: 4.1.4 - uuid: 8.3.2 - install@0.13.0: {} internal-slot@1.0.4: @@ -37607,8 +35385,6 @@ snapshots: transitivePeerDependencies: - supports-color - iota-array@1.0.0: {} - ip-address@9.0.5: dependencies: jsbn: 1.1.0 @@ -37655,23 +35431,15 @@ snapshots: dependencies: binary-extensions: 2.2.0 - is-boolean-attribute@0.0.1: {} - is-boolean-object@1.1.2: dependencies: call-bind: 1.0.8 has-tostringtag: 1.0.2 - is-buffer@1.1.6: {} - is-buffer@2.0.5: {} is-callable@1.2.7: {} - is-ci@2.0.0: - dependencies: - ci-info: 2.0.0 - is-ci@3.0.1: dependencies: ci-info: 3.8.0 @@ -37700,12 +35468,6 @@ snapshots: is-extglob@2.1.1: {} - is-fullwidth-code-point@1.0.0: - dependencies: - number-is-nan: 1.0.1 - - is-fullwidth-code-point@2.0.0: {} - is-fullwidth-code-point@3.0.0: {} is-generator-function@1.0.10: @@ -37724,11 +35486,6 @@ snapshots: dependencies: is-docker: 3.0.0 - is-installed-globally@0.4.0: - dependencies: - global-dirs: 3.0.1 - is-path-inside: 3.0.3 - is-interactive@1.0.0: {} is-negative-zero@2.0.2: {} @@ -37737,16 +35494,12 @@ snapshots: is-network-error@1.0.0: {} - is-npm@5.0.0: {} - is-number-object@1.0.7: dependencies: has-tostringtag: 1.0.2 is-number@7.0.0: {} - is-obj@2.0.0: {} - is-path-inside@3.0.3: {} is-plain-obj@1.1.0: {} @@ -37759,8 +35512,6 @@ snapshots: is-promise@4.0.0: {} - is-property@1.0.2: {} - is-reference@3.0.3: dependencies: '@types/estree': 1.0.8 @@ -37800,10 +35551,6 @@ snapshots: dependencies: which-typed-array: 1.1.15 - is-typed-array@1.1.15: - dependencies: - which-typed-array: 1.1.19 - is-typedarray@1.0.0: {} is-unicode-supported@0.1.0: {} @@ -37816,8 +35563,6 @@ snapshots: is-windows@1.0.2: {} - is-wsl@1.1.0: {} - is-wsl@2.2.0: dependencies: is-docker: 2.2.1 @@ -37826,8 +35571,6 @@ snapshots: dependencies: is-inside-container: 1.0.0 - is-yarn-global@0.3.0: {} - isarray@1.0.0: {} isarray@2.0.5: {} @@ -37971,8 +35714,6 @@ snapshots: json-schema-traverse@1.0.0: {} - json-schema-typed@7.0.3: {} - json-schema@0.4.0: {} json-stable-stringify-without-jsonify@1.0.1: {} @@ -38013,8 +35754,6 @@ snapshots: jsonify@0.0.1: {} - jsonparse@1.3.1: {} - jsonpath-plus@10.3.0: dependencies: '@jsep-plugin/assignment': 1.3.0(jsep@1.4.0) @@ -38025,12 +35764,6 @@ snapshots: jsonpointer@5.0.1: {} - jsonstream2@3.0.0: - dependencies: - jsonparse: 1.3.1 - through2: 3.0.2 - type-component: 0.0.1 - jsonwebtoken@9.0.2: dependencies: jws: 3.2.3 @@ -38085,11 +35818,6 @@ snapshots: kolorist@1.8.0: {} - labeled-stream-splicer@2.0.2: - dependencies: - inherits: 2.0.4 - stream-splicer: 2.0.1 - langium@3.3.1: dependencies: chevrotain: 11.0.3 @@ -38115,10 +35843,6 @@ snapshots: dependencies: language-subtag-registry: 0.3.22 - latest-version@5.1.0: - dependencies: - package-json: 6.5.0 - layerr@2.0.1: {} layout-base@1.0.2: {} @@ -38174,13 +35898,6 @@ snapshots: lefthook-windows-arm64: 1.11.3 lefthook-windows-x64: 1.11.3 - leven@2.1.0: {} - - levn@0.3.0: - dependencies: - prelude-ls: 1.1.2 - type-check: 0.3.2 - levn@0.4.1: dependencies: prelude-ls: 1.2.1 @@ -38282,11 +35999,6 @@ snapshots: locate-character@3.0.0: {} - locate-path@3.0.0: - dependencies: - p-locate: 3.0.0 - path-exists: 3.0.0 - locate-path@5.0.0: dependencies: p-locate: 4.1.0 @@ -38305,18 +36017,12 @@ snapshots: lodash.castarray@4.4.0: {} - lodash.chunk@4.2.0: {} - - lodash.clonedeep@4.5.0: {} - lodash.debounce@4.0.8: {} lodash.defaults@4.2.0: {} lodash.escaperegexp@4.1.2: {} - lodash.flatten@4.4.0: {} - lodash.groupby@4.6.0: {} lodash.includes@4.3.0: {} @@ -38339,8 +36045,6 @@ snapshots: lodash.isundefined@3.0.1: {} - lodash.memoize@3.0.4: {} - lodash.merge@4.6.2: {} lodash.omit@4.5.0: {} @@ -38362,8 +36066,6 @@ snapshots: chalk: 4.1.2 is-unicode-supported: 0.1.0 - long@4.0.0: {} - long@5.2.3: {} longest-streak@3.1.0: {} @@ -38374,8 +36076,6 @@ snapshots: loupe@3.1.3: {} - lower-case@1.1.4: {} - lowercase-keys@1.0.1: {} lowercase-keys@2.0.0: {} @@ -38428,16 +36128,6 @@ snapshots: lz-string@1.4.4: {} - macos-release@2.5.1: {} - - magic-string@0.23.2: - dependencies: - sourcemap-codec: 1.4.8 - - magic-string@0.25.1: - dependencies: - sourcemap-codec: 1.4.8 - magic-string@0.30.17: dependencies: '@jridgewell/sourcemap-codec': 1.5.0 @@ -38458,16 +36148,10 @@ snapshots: '@babel/types': 7.27.0 source-map-js: 1.2.1 - make-dir@3.1.0: - dependencies: - semver: 6.3.1 - make-dir@4.0.0: dependencies: semver: 7.7.3 - manage-path@2.0.0: {} - map-obj@1.0.1: {} map-obj@4.3.0: {} @@ -38510,12 +36194,6 @@ snapshots: marked: 7.0.4 react: 18.3.1 - md5.js@1.3.5: - dependencies: - hash-base: 3.0.5 - inherits: 2.0.4 - safe-buffer: 5.2.1 - mdast-util-definitions@5.1.1: dependencies: '@types/mdast': 3.0.10 @@ -38816,10 +36494,6 @@ snapshots: merge-descriptors@2.0.0: {} - merge-source-map@1.0.4: - dependencies: - source-map: 0.5.6 - merge-stream@2.0.0: {} merge2@1.4.1: {} @@ -39266,11 +36940,6 @@ snapshots: braces: 3.0.3 picomatch: 2.3.1 - miller-rabin@4.0.1: - dependencies: - bn.js: 4.12.2 - brorand: 1.1.0 - mime-db@1.52.0: {} mime-db@1.53.0: {} @@ -39289,12 +36958,8 @@ snapshots: mime@3.0.0: {} - mimic-fn@1.2.0: {} - mimic-fn@2.1.0: {} - mimic-fn@3.1.0: {} - mimic-fn@4.0.0: {} mimic-response@1.0.1: {} @@ -39305,23 +36970,10 @@ snapshots: mini-svg-data-uri@1.4.4: {} - minify-stream@2.1.0: - dependencies: - concat-stream: 2.0.0 - convert-source-map: 1.9.0 - duplexify: 4.1.3 - from2-string: 1.1.0 - terser: 4.8.1 - xtend: 4.0.2 - minimal-polyfills@2.2.2: {} minimal-polyfills@2.2.3: {} - minimalistic-assert@1.0.1: {} - - minimalistic-crypto-utils@1.0.1: {} - minimatch@10.0.1: dependencies: brace-expansion: 2.0.1 @@ -39414,33 +37066,11 @@ snapshots: ml-array-max: 1.2.4 ml-array-min: 1.2.3 - ml-distance-euclidean@2.0.0: {} - - ml-kmeans@4.2.1: - dependencies: - ml-distance-euclidean: 2.0.0 - ml-matrix: 5.3.0 - ml-nearest-vector: 2.0.1 - ml-random: 0.5.0 - - ml-matrix@5.3.0: - dependencies: - ml-array-max: 1.2.4 - ml-array-rescale: 1.3.7 - ml-matrix@6.12.1: dependencies: is-any-array: 2.0.1 ml-array-rescale: 1.3.7 - ml-nearest-vector@2.0.1: - dependencies: - ml-distance-euclidean: 2.0.0 - - ml-random@0.5.0: - dependencies: - ml-xsadd: 2.0.0 - ml-spectra-processing@14.13.0: dependencies: binary-search: 1.3.6 @@ -39450,8 +37080,6 @@ snapshots: ml-matrix: 6.12.1 ml-xsadd: 3.0.1 - ml-xsadd@2.0.0: {} - ml-xsadd@3.0.1: {} mlly@1.7.1: @@ -39468,24 +37096,6 @@ snapshots: pkg-types: 1.3.1 ufo: 1.6.1 - module-deps@6.2.3: - dependencies: - JSONStream: 1.3.5 - browser-resolve: 2.0.0 - cached-path-relative: 1.1.0 - concat-stream: 1.6.2 - defined: 1.0.1 - detective: 5.2.1 - duplexer2: 0.1.4 - inherits: 2.0.4 - parents: 1.0.1 - readable-stream: 2.3.8 - resolve: 1.22.8 - stream-combiner2: 1.1.1 - subarg: 1.0.0 - through2: 2.0.5 - xtend: 4.0.2 - module-details-from-path@1.0.3: {} moo@0.5.2: {} @@ -39500,8 +37110,6 @@ snapshots: transitivePeerDependencies: - supports-color - morphdom@2.7.7: {} - mri@1.2.0: {} mrmime@1.0.1: {} @@ -39516,19 +37124,8 @@ snapshots: multipasta@0.2.5: {} - multistream@2.1.1: - dependencies: - inherits: 2.0.4 - readable-stream: 2.3.8 - mustache@4.2.0: {} - mute-stream@0.0.7: {} - - mutexify@1.4.0: - dependencies: - queue-tick: 1.0.1 - mz@2.7.0: dependencies: any-promise: 1.3.0 @@ -39551,29 +37148,6 @@ snapshots: stacktrace-js: 2.0.2 stylis: 4.3.0 - nanoassert@1.1.0: {} - - nanobench@2.1.1: - dependencies: - browser-process-hrtime: 0.1.3 - chalk: 1.1.3 - mutexify: 1.4.0 - pretty-hrtime: 1.0.3 - - nanohtml@1.10.0: - dependencies: - acorn-node: 1.8.2 - camel-case: 3.0.0 - convert-source-map: 1.9.0 - estree-is-member-expression: 1.0.0 - hyperx: 2.5.4 - is-boolean-attribute: 0.0.1 - nanoassert: 1.1.0 - nanobench: 2.1.1 - normalize-html-whitespace: 0.2.0 - through2: 2.0.5 - transform-ast: 2.4.4 - nanoid@3.3.11: {} nanoid@3.3.8: {} @@ -39590,47 +37164,6 @@ snapshots: natural-compare@1.4.0: {} - ndarray-blas-level1@1.1.3: {} - - ndarray-cholesky-factorization@1.0.2: - dependencies: - ndarray: 1.0.19 - ndarray-blas-level1: 1.1.3 - ndarray-scratch: 1.2.0 - - ndarray-crout-decomposition@1.1.0: {} - - ndarray-determinant@1.0.0: - dependencies: - ndarray-crout-decomposition: 1.1.0 - ndarray-diagonal: 1.0.0 - ndarray-ops: 1.2.2 - ndarray-scratch: 1.2.0 - - ndarray-diagonal@1.0.0: - dependencies: - ndarray: 1.0.19 - - ndarray-inv@0.2.0: - dependencies: - ndarray: 1.0.19 - ndarray-scratch: 1.2.0 - - ndarray-ops@1.2.2: - dependencies: - cwise-compiler: 1.1.3 - - ndarray-scratch@1.2.0: - dependencies: - ndarray: 1.0.19 - ndarray-ops: 1.2.2 - typedarray-pool: 1.2.0 - - ndarray@1.0.19: - dependencies: - iota-array: 1.0.0 - is-buffer: 1.1.6 - nearley@2.20.1: dependencies: commander: 2.20.3 @@ -39652,8 +37185,6 @@ snapshots: optionalDependencies: '@rollup/rollup-linux-x64-gnu': 4.53.2 - next-tick@1.1.0: {} - next@14.1.0(@opentelemetry/api@1.9.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1): dependencies: '@next/env': 14.1.0 @@ -39786,10 +37317,6 @@ snapshots: nice-try@1.0.5: {} - no-case@2.3.2: - dependencies: - lower-case: 1.1.4 - node-abi@3.75.0: dependencies: semver: 7.7.3 @@ -39839,8 +37366,6 @@ snapshots: dependencies: abbrev: 2.0.0 - normalize-html-whitespace@0.2.0: {} - normalize-package-data@2.5.0: dependencies: hosted-git-info: 2.8.9 @@ -39907,8 +37432,6 @@ snapshots: num2fraction@1.2.2: {} - number-is-nan@1.0.1: {} - nypm@0.3.9: dependencies: citty: 0.1.6 @@ -40033,16 +37556,10 @@ snapshots: on-headers@1.0.2: {} - on-net-listen@1.1.2: {} - once@1.4.0: dependencies: wrappy: 1.0.2 - onetime@2.0.1: - dependencies: - mimic-fn: 1.2.0 - onetime@5.1.2: dependencies: mimic-fn: 2.1.0 @@ -40066,11 +37583,6 @@ snapshots: is-inside-container: 1.0.0 is-wsl: 3.1.0 - open@7.4.2: - dependencies: - is-docker: 2.2.1 - is-wsl: 2.2.0 - open@8.4.0: dependencies: define-lazy-prop: 2.0.0 @@ -40155,19 +37667,6 @@ snapshots: jose: 6.0.8 oauth4webapi: 3.3.0 - opn@5.5.0: - dependencies: - is-wsl: 1.1.0 - - optionator@0.8.3: - dependencies: - deep-is: 0.1.4 - fast-levenshtein: 2.0.6 - levn: 0.3.0 - prelude-ls: 1.1.2 - type-check: 0.3.2 - word-wrap: 1.2.3 - optionator@0.9.1: dependencies: deep-is: 0.1.4 @@ -40189,13 +37688,6 @@ snapshots: strip-ansi: 6.0.1 wcwidth: 1.0.1 - os-browserify@0.3.0: {} - - os-name@4.0.1: - dependencies: - macos-release: 2.5.1 - windows-release: 4.0.0 - os-paths@7.4.0: optionalDependencies: fsevents: 2.3.3 @@ -40238,10 +37730,6 @@ snapshots: dependencies: yocto-queue: 1.1.1 - p-locate@3.0.0: - dependencies: - p-limit: 2.3.0 - p-locate@4.1.0: dependencies: p-limit: 2.3.0 @@ -40328,24 +37816,10 @@ snapshots: pako@0.2.9: {} - pako@1.0.11: {} - parent-module@1.0.1: dependencies: callsites: 3.1.0 - parents@1.0.1: - dependencies: - path-platform: 0.11.15 - - parse-asn1@5.1.9: - dependencies: - asn1.js: 4.10.1 - browserify-aes: 1.2.0 - evp_bytestokey: 1.0.3 - pbkdf2: 3.1.5 - safe-buffer: 5.2.1 - parse-duration@2.1.4: {} parse-entities@4.0.0: @@ -40398,12 +37872,8 @@ snapshots: dependencies: event-target-shim: 6.0.2 - path-browserify@1.0.1: {} - path-data-parser@0.1.0: {} - path-exists@3.0.0: {} - path-exists@4.0.0: {} path-exists@5.0.0: {} @@ -40418,8 +37888,6 @@ snapshots: path-parse@1.0.7: {} - path-platform@0.11.15: {} - path-scurry@1.11.1: dependencies: lru-cache: 10.4.3 @@ -40446,15 +37914,6 @@ snapshots: pathval@2.0.0: {} - pbkdf2@3.1.5: - dependencies: - create-hash: 1.2.0 - create-hmac: 1.1.7 - ripemd160: 2.0.3 - safe-buffer: 5.2.1 - sha.js: 2.4.12 - to-buffer: 1.2.2 - peberminta@0.9.0: {} peek-readable@5.4.2: {} @@ -40628,10 +38087,6 @@ snapshots: exsolve: 1.0.7 pathe: 2.0.3 - pkg-up@3.1.0: - dependencies: - find-up: 3.0.0 - platform@1.3.6: {} playwright-core@1.37.0: {} @@ -40663,13 +38118,6 @@ snapshots: postcss: 6.0.23 postcss-value-parser: 3.3.1 - postcss-import@13.0.0(postcss@8.5.6): - dependencies: - postcss: 8.5.6 - postcss-value-parser: 4.2.0 - read-cache: 1.0.0 - resolve: 1.22.8 - postcss-import@15.1.0(postcss@8.5.4): dependencies: postcss: 8.5.4 @@ -40932,8 +38380,6 @@ snapshots: path-exists: 4.0.0 which-pm: 2.0.0 - prelude-ls@1.1.2: {} - prelude-ls@1.2.1: {} prepend-http@2.0.0: {} @@ -40946,8 +38392,6 @@ snapshots: prettier@3.0.0: {} - pretty-bytes@5.6.0: {} - pretty-format@27.5.1: dependencies: ansi-regex: 5.0.1 @@ -41090,23 +38534,6 @@ snapshots: '@types/node': 18.19.20 long: 5.2.3 - protocol-buffers-encodings@1.2.0: - dependencies: - b4a: 1.6.6 - signed-varint: 2.0.1 - varint: 5.0.0 - - protocol-buffers-schema@3.6.0: {} - - protocol-buffers@4.2.0: - dependencies: - generate-function: 2.3.1 - generate-object-property: 1.2.0 - protocol-buffers-encodings: 1.2.0 - protocol-buffers-schema: 3.6.0 - signed-varint: 2.0.1 - varint: 5.0.2 - proxy-addr@2.0.7: dependencies: forwarded: 0.2.0 @@ -41131,15 +38558,6 @@ snapshots: psl@1.9.0: {} - public-encrypt@4.0.3: - dependencies: - bn.js: 4.12.2 - browserify-rsa: 4.1.1 - create-hash: 1.2.0 - parse-asn1: 5.1.9 - randombytes: 2.1.0 - safe-buffer: 5.2.1 - pump@2.0.1: dependencies: end-of-stream: 1.4.4 @@ -41156,20 +38574,10 @@ snapshots: inherits: 2.0.4 pump: 2.0.1 - pumpify@2.0.1: - dependencies: - duplexify: 4.1.3 - inherits: 2.0.4 - pump: 3.0.2 - punycode@1.4.1: {} punycode@2.2.0: {} - pupa@2.1.1: - dependencies: - escape-goat: 2.1.1 - puppeteer-core@24.15.0(bufferutil@4.0.9): dependencies: '@puppeteer/browsers': 2.10.6 @@ -41214,24 +38622,12 @@ snapshots: quansync@0.2.11: {} - querystring-es3@0.2.1: {} - - querystringify@2.2.0: {} - queue-microtask@1.2.3: {} - queue-tick@1.0.1: {} - quick-format-unescaped@4.0.4: {} quick-lru@4.0.1: {} - quote-stream@1.0.2: - dependencies: - buffer-equal: 0.0.1 - minimist: 1.2.7 - through2: 2.0.5 - railroad-diagrams@1.0.0: {} randexp@0.4.6: @@ -41247,11 +38643,6 @@ snapshots: dependencies: safe-buffer: 5.2.1 - randomfill@1.0.4: - dependencies: - randombytes: 2.1.0 - safe-buffer: 5.2.1 - range-parser@1.2.1: {} raw-body@2.5.2: @@ -41702,10 +39093,6 @@ snapshots: dependencies: pify: 2.3.0 - read-only-stream@2.0.0: - dependencies: - readable-stream: 2.3.8 - read-pkg-up@7.0.1: dependencies: find-up: 4.1.0 @@ -41881,8 +39268,6 @@ snapshots: hast-util-raw: 9.1.0 vfile: 6.0.3 - reinterval@1.1.0: {} - remark-frontmatter@4.0.1: dependencies: '@types/mdast': 3.0.10 @@ -42063,8 +39448,6 @@ snapshots: requireindex@1.2.0: {} - requires-port@1.0.0: {} - resend@3.2.0: dependencies: '@react-email/render': 0.0.12 @@ -42100,11 +39483,6 @@ snapshots: dependencies: lowercase-keys: 1.0.1 - restore-cursor@2.0.0: - dependencies: - onetime: 2.0.1 - signal-exit: 3.0.7 - restore-cursor@3.1.0: dependencies: onetime: 5.1.2 @@ -42114,8 +39492,6 @@ snapshots: ret@0.5.0: {} - retimer@3.0.0: {} - retry@0.12.0: {} retry@0.13.1: {} @@ -42143,11 +39519,6 @@ snapshots: glob: 11.0.0 package-json-from-dist: 1.0.0 - ripemd160@2.0.3: - dependencies: - hash-base: 3.1.2 - inherits: 2.0.4 - robot3@0.4.1: {} robust-predicates@3.0.2: {} @@ -42200,8 +39571,6 @@ snapshots: run-applescript@7.0.0: {} - run-async@2.4.1: {} - run-exclusive@2.2.18: dependencies: minimal-polyfills: 2.2.3 @@ -42214,10 +39583,6 @@ snapshots: rw@1.3.3: {} - rxjs@6.6.7: - dependencies: - tslib: 1.14.1 - rxjs@7.8.2: dependencies: tslib: 2.8.1 @@ -42281,16 +39646,6 @@ snapshots: ajv-formats: 2.1.1(ajv@8.17.1) ajv-keywords: 5.1.0(ajv@8.17.1) - scope-analyzer@2.1.2: - dependencies: - array-from: 2.1.1 - dash-ast: 2.0.1 - es6-map: 0.1.5 - es6-set: 0.1.6 - es6-symbol: 3.1.4 - estree-is-function: 1.0.0 - get-assigned-identifiers: 1.2.0 - screenfull@5.2.0: {} secure-json-parse@2.7.0: {} @@ -42308,10 +39663,6 @@ snapshots: '@types/semver': 6.2.3 semver: 6.3.1 - semver-diff@3.1.1: - dependencies: - semver: 6.3.1 - semver@5.7.1: {} semver@6.3.1: {} @@ -42425,14 +39776,6 @@ snapshots: setprototypeof@1.2.0: {} - sha.js@2.4.12: - dependencies: - inherits: 2.0.4 - safe-buffer: 5.2.1 - to-buffer: 1.2.2 - - shallow-copy@0.0.1: {} - sharp@0.33.5: dependencies: color: 4.2.3 @@ -42492,10 +39835,6 @@ snapshots: '@img/sharp-win32-x64': 0.34.5 optional: true - shasum-object@1.0.1: - dependencies: - fast-safe-stringify: 2.1.1 - shebang-command@1.2.0: dependencies: shebang-regex: 1.0.0 @@ -42529,10 +39868,6 @@ snapshots: shimmer@1.2.1: {} - showdown@1.9.1: - dependencies: - yargs: 14.2.3 - side-channel-list@1.0.0: dependencies: es-errors: 1.3.0 @@ -42567,10 +39902,6 @@ snapshots: signal-exit@4.1.0: {} - signed-varint@2.0.1: - dependencies: - varint: 5.0.2 - simple-concat@1.0.1: {} simple-get@4.0.1: @@ -42594,12 +39925,6 @@ snapshots: simplur@3.0.1: {} - single-line-log@1.1.2: - dependencies: - string-width: 1.0.2 - - sinusoidal-decimal@1.0.0: {} - sirv@2.0.4: dependencies: '@polka/url': 1.0.0-next.28 @@ -42714,11 +40039,6 @@ snapshots: ip-address: 9.0.5 smart-buffer: 4.2.0 - sonic-boom@1.4.1: - dependencies: - atomic-sleep: 1.0.0 - flatstr: 1.0.12 - sonic-boom@4.2.0: dependencies: atomic-sleep: 1.0.0 @@ -42754,8 +40074,6 @@ snapshots: dependencies: whatwg-url: 7.1.0 - sourcemap-codec@1.4.8: {} - space-separated-tokens@2.0.2: {} spawndamnit@2.0.0: @@ -42858,27 +40176,6 @@ snapshots: standard-as-callback@2.1.0: {} - static-eval@2.1.1: - dependencies: - escodegen: 2.1.0 - - static-module@3.0.4: - dependencies: - acorn-node: 1.8.2 - concat-stream: 1.6.2 - convert-source-map: 1.9.0 - duplexer2: 0.1.4 - escodegen: 1.14.3 - has: 1.0.3 - magic-string: 0.25.1 - merge-source-map: 1.0.4 - object-inspect: 1.13.4 - readable-stream: 2.3.8 - scope-analyzer: 2.1.2 - shallow-copy: 0.0.1 - static-eval: 2.1.1 - through2: 2.0.5 - statuses@2.0.1: {} std-env@3.7.0: {} @@ -42887,43 +40184,12 @@ snapshots: std-env@3.9.0: {} - stream-browserify@3.0.0: - dependencies: - inherits: 2.0.4 - readable-stream: 3.6.2 - stream-buffers@3.0.2: {} - stream-collector@1.0.1: - dependencies: - once: 1.4.0 - - stream-combiner2@1.1.1: - dependencies: - duplexer2: 0.1.4 - readable-stream: 2.3.8 - - stream-http@3.2.0: - dependencies: - builtin-status-codes: 3.0.0 - inherits: 2.0.4 - readable-stream: 3.6.2 - xtend: 4.0.2 - stream-shift@1.0.3: {} stream-slice@0.1.2: {} - stream-splicer@2.0.1: - dependencies: - inherits: 2.0.4 - readable-stream: 2.3.8 - - stream-template@0.0.10: - dependencies: - end-of-stream: 1.4.4 - readable-stream: 2.3.8 - stream-transform@2.1.3: dependencies: mixme: 0.5.4 @@ -42968,11 +40234,6 @@ snapshots: - '@types/react' - supports-color - streaming-json-stringify@3.1.0: - dependencies: - json-stringify-safe: 5.0.1 - readable-stream: 2.3.8 - streamsearch@1.1.0: {} streamx@2.22.0: @@ -42986,23 +40247,6 @@ snapshots: string-hash@1.1.3: {} - string-width@1.0.2: - dependencies: - code-point-at: 1.1.0 - is-fullwidth-code-point: 1.0.0 - strip-ansi: 3.0.1 - - string-width@2.1.1: - dependencies: - is-fullwidth-code-point: 2.0.0 - strip-ansi: 4.0.0 - - string-width@3.1.0: - dependencies: - emoji-regex: 7.0.3 - is-fullwidth-code-point: 2.0.0 - strip-ansi: 5.2.0 - string-width@4.2.3: dependencies: emoji-regex: 8.0.0 @@ -43076,18 +40320,6 @@ snapshots: character-entities-html4: 2.1.0 character-entities-legacy: 3.0.0 - strip-ansi@3.0.1: - dependencies: - ansi-regex: 2.1.1 - - strip-ansi@4.0.0: - dependencies: - ansi-regex: 3.0.1 - - strip-ansi@5.2.0: - dependencies: - ansi-regex: 4.1.1 - strip-ansi@6.0.1: dependencies: ansi-regex: 5.0.1 @@ -43156,10 +40388,6 @@ snapshots: stylis@4.3.6: {} - subarg@1.0.0: - dependencies: - minimist: 1.2.7 - sucrase@3.35.0: dependencies: '@jridgewell/gen-mapping': 0.3.8 @@ -43170,8 +40398,6 @@ snapshots: pirates: 4.0.5 ts-interface-checker: 0.1.13 - summary@2.1.0: {} - superagent@9.0.2: dependencies: component-emitter: 1.3.1 @@ -43201,8 +40427,6 @@ snapshots: supports-color@10.0.0: {} - supports-color@2.0.0: {} - supports-color@5.5.0: dependencies: has-flag: 3.0.0 @@ -43286,10 +40510,6 @@ snapshots: '@pkgr/utils': 2.3.1 tslib: 2.8.1 - syntax-error@1.4.0: - dependencies: - acorn-node: 1.8.2 - systeminformation@5.23.8: {} table@6.9.0: @@ -43300,8 +40520,6 @@ snapshots: string-width: 4.2.3 strip-ansi: 6.0.1 - tachyons@4.12.0: {} - tailwind-merge@1.12.0: {} tailwind-merge@2.2.0: @@ -43523,13 +40741,6 @@ snapshots: '@swc/core': 1.3.101(@swc/helpers@0.5.15) esbuild: 0.19.11 - terser@4.8.1: - dependencies: - acorn: 8.15.0 - commander: 2.20.3 - source-map: 0.6.1 - source-map-support: 0.5.21 - terser@5.44.1: dependencies: '@jridgewell/source-map': 0.3.3 @@ -43592,23 +40803,6 @@ snapshots: readable-stream: 2.3.8 xtend: 4.0.2 - through2@3.0.2: - dependencies: - inherits: 2.0.4 - readable-stream: 3.6.2 - - through2@4.0.2: - dependencies: - readable-stream: 3.6.2 - - through@2.3.8: {} - - timers-browserify@1.4.2: - dependencies: - process: 0.11.10 - - timestring@6.0.0: {} - tiny-case@1.0.3: {} tiny-glob@0.2.9: @@ -43679,12 +40873,6 @@ snapshots: tmp@0.2.3: {} - to-buffer@1.2.2: - dependencies: - isarray: 2.0.5 - safe-buffer: 5.2.1 - typed-array-buffer: 1.0.3 - to-fast-properties@2.0.0: {} to-readable-stream@1.0.0: {} @@ -43715,29 +40903,12 @@ snapshots: psl: 1.9.0 punycode: 2.2.0 - tough-cookie@4.1.4: - dependencies: - psl: 1.9.0 - punycode: 2.2.0 - universalify: 0.2.0 - url-parse: 1.5.10 - tr46@0.0.3: {} tr46@1.0.1: dependencies: punycode: 2.2.0 - transform-ast@2.4.4: - dependencies: - acorn-node: 1.8.2 - convert-source-map: 1.9.0 - dash-ast: 1.0.0 - is-buffer: 2.0.5 - magic-string: 0.23.2 - merge-source-map: 1.0.4 - nanobench: 2.1.1 - tree-kill@1.2.2: {} trim-lines@3.0.1: {} @@ -43905,13 +41076,6 @@ snapshots: optionalDependencies: fsevents: 2.3.3 - ttest@3.0.0: - dependencies: - distributions: 2.2.0 - summary: 2.1.0 - - tty-browserify@0.0.1: {} - tty-table@4.1.6: dependencies: chalk: 4.1.2 @@ -43932,10 +41096,6 @@ snapshots: turbo-darwin-arm64@1.10.3: optional: true - turbo-json-parse@2.3.0: - dependencies: - generate-function: 2.3.1 - turbo-linux-64@1.10.3: optional: true @@ -43961,16 +41121,10 @@ snapshots: tweetnacl@0.14.5: {} - type-check@0.3.2: - dependencies: - prelude-ls: 1.1.2 - type-check@0.4.0: dependencies: prelude-ls: 1.2.1 - type-component@0.0.1: {} - type-fest@0.13.1: {} type-fest@0.20.2: {} @@ -43996,20 +41150,12 @@ snapshots: media-typer: 1.1.0 mime-types: 3.0.0 - type@2.7.3: {} - typed-array-buffer@1.0.2: dependencies: call-bind: 1.0.8 es-errors: 1.3.0 is-typed-array: 1.1.13 - typed-array-buffer@1.0.3: - dependencies: - call-bound: 1.0.4 - es-errors: 1.3.0 - is-typed-array: 1.1.15 - typed-array-byte-length@1.0.1: dependencies: call-bind: 1.0.8 @@ -44048,17 +41194,6 @@ snapshots: typed-query-selector@2.12.0: {} - typedarray-pool@1.2.0: - dependencies: - bit-twiddle: 1.0.2 - dup: 1.0.0 - - typedarray-to-buffer@3.1.5: - dependencies: - is-typedarray: 1.0.0 - - typedarray@0.0.6: {} - typescript@5.1.6: {} typescript@5.3.3: {} @@ -44081,8 +41216,6 @@ snapshots: dependencies: layerr: 2.0.1 - umd@3.0.3: {} - unbox-primitive@1.0.2: dependencies: call-bind: 1.0.8 @@ -44092,14 +41225,6 @@ snapshots: uncrypto@0.1.3: {} - undeclared-identifiers@1.1.3: - dependencies: - acorn-node: 1.8.2 - dash-ast: 1.0.0 - get-assigned-identifiers: 1.2.0 - simple-concat: 1.0.1 - xtend: 4.0.2 - undici-types@5.26.5: {} undici-types@6.20.0: {} @@ -44136,8 +41261,6 @@ snapshots: trough: 2.1.0 vfile: 6.0.3 - uniq@1.0.1: {} - unique-filename@3.0.0: dependencies: unique-slug: 4.0.0 @@ -44146,10 +41269,6 @@ snapshots: dependencies: imurmurhash: 0.1.4 - unique-string@2.0.0: - dependencies: - crypto-random-string: 2.0.0 - unist-util-find-after@5.0.0: dependencies: '@types/unist': 3.0.3 @@ -44229,8 +41348,6 @@ snapshots: universalify@0.1.2: {} - universalify@0.2.0: {} - universalify@2.0.0: {} unpipe@1.0.0: {} @@ -44253,23 +41370,6 @@ snapshots: escalade: 3.2.0 picocolors: 1.1.1 - update-notifier@5.1.0: - dependencies: - boxen: 5.1.2 - chalk: 4.1.2 - configstore: 5.0.1 - has-yarn: 2.1.0 - import-lazy: 2.1.0 - is-ci: 2.0.0 - is-installed-globally: 0.4.0 - is-npm: 5.0.0 - is-yarn-global: 0.3.0 - latest-version: 5.1.0 - pupa: 2.1.1 - semver: 7.7.3 - semver-diff: 3.1.1 - xdg-basedir: 4.0.0 - uploadthing@7.1.0(express@5.0.1)(fastify@5.4.0)(next@14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1))(tailwindcss@3.4.1): dependencies: '@effect/platform': 0.63.2(@effect/schema@0.72.2(effect@3.7.2))(effect@3.7.2) @@ -44283,8 +41383,6 @@ snapshots: next: 14.2.21(@opentelemetry/api@1.9.0)(@playwright/test@1.37.0)(react-dom@18.2.0(react@18.3.1))(react@18.3.1) tailwindcss: 3.4.1 - upper-case@1.1.3: {} - uri-js@4.4.1: dependencies: punycode: 2.2.0 @@ -44293,16 +41391,6 @@ snapshots: dependencies: prepend-http: 2.0.0 - url-parse@1.5.10: - dependencies: - querystringify: 2.2.0 - requires-port: 1.0.0 - - url@0.11.4: - dependencies: - punycode: 1.4.1 - qs: 6.14.0 - urlpattern-polyfill@9.0.0: {} use-callback-ref@1.3.3(@types/react@18.2.69)(react@18.2.0): @@ -44359,12 +41447,6 @@ snapshots: util-deprecate@1.0.2: {} - util-extend@1.0.3: {} - - util@0.10.4: - dependencies: - inherits: 2.0.3 - util@0.12.5: dependencies: inherits: 2.0.4 @@ -44375,8 +41457,6 @@ snapshots: utils-merge@1.0.1: {} - uuid-parse@1.1.0: {} - uuid@10.0.0: {} uuid@11.1.0: {} @@ -44417,10 +41497,6 @@ snapshots: validate.io-function@1.0.2: {} - varint@5.0.0: {} - - varint@5.0.2: {} - vary@1.1.2: {} verror@1.10.0: @@ -44593,8 +41669,6 @@ snapshots: - supports-color - terser - vm-browserify@1.1.2: {} - vscode-jsonrpc@8.2.0: {} vscode-languageserver-protocol@3.17.5: @@ -44656,8 +41730,6 @@ snapshots: web-streams-polyfill@4.0.0-beta.3: {} - webfontloader@1.6.28: {} - webidl-conversions@3.0.1: {} webidl-conversions@4.0.2: {} @@ -44782,16 +41854,6 @@ snapshots: gopd: 1.2.0 has-tostringtag: 1.0.2 - which-typed-array@1.1.19: - dependencies: - available-typed-arrays: 1.0.7 - call-bind: 1.0.8 - call-bound: 1.0.4 - for-each: 0.3.5 - get-proto: 1.0.1 - gopd: 1.2.0 - has-tostringtag: 1.0.2 - which@1.3.1: dependencies: isexe: 2.0.0 @@ -44809,22 +41871,8 @@ snapshots: siginfo: 2.0.0 stackback: 0.0.2 - widest-line@3.1.0: - dependencies: - string-width: 4.2.3 - - windows-release@4.0.0: - dependencies: - execa: 4.1.0 - word-wrap@1.2.3: {} - wrap-ansi@5.1.0: - dependencies: - ansi-styles: 3.2.1 - string-width: 3.1.0 - strip-ansi: 5.2.0 - wrap-ansi@6.2.0: dependencies: ansi-styles: 4.3.0 @@ -44845,13 +41893,6 @@ snapshots: wrappy@1.0.2: {} - write-file-atomic@3.0.3: - dependencies: - imurmurhash: 0.1.4 - is-typedarray: 1.0.0 - signal-exit: 3.0.7 - typedarray-to-buffer: 3.1.5 - ws@7.5.9(bufferutil@4.0.9): optionalDependencies: bufferutil: 4.0.9 @@ -44882,8 +41923,6 @@ snapshots: optionalDependencies: fsevents: 2.3.3 - xdg-basedir@4.0.0: {} - xdg-portable@10.6.0: dependencies: os-paths: 7.4.0 @@ -44910,11 +41949,6 @@ snapshots: yaml@2.7.1: {} - yargs-parser@15.0.3: - dependencies: - camelcase: 5.3.1 - decamelize: 1.2.0 - yargs-parser@18.1.3: dependencies: camelcase: 5.3.1 @@ -44924,20 +41958,6 @@ snapshots: yargs-parser@21.1.1: {} - yargs@14.2.3: - dependencies: - cliui: 5.0.0 - decamelize: 1.2.0 - find-up: 3.0.0 - get-caller-file: 2.0.5 - require-directory: 2.1.1 - require-main-filename: 2.0.0 - set-blocking: 2.0.0 - string-width: 3.1.0 - which-module: 2.0.0 - y18n: 4.0.3 - yargs-parser: 15.0.3 - yargs@15.4.1: dependencies: cliui: 6.0.0