@nice2dev/game-engine 1.3.14 → 1.3.16

package/dist/cjs/build-cloud/BuildOrchestration.js

@@ -1,1132 +1,1093 @@
-'use strict';
-
-/**
- * @file BuildOrchestration.ts
- * @description Build Orchestration system for managing cloud builds
- * PRO-1.7.4: Build Orchestration
- *
- * Features:
- * - Build Queue Manager (Kubernetes-based job scheduler)
- * - Priority queues (paid vs free tier)
- * - Concurrent build limits
- * - Auto-scaling workers
- * - Spot instance support
- * - Build Agent Pool management
- * - Artifact Storage (S3/MinIO)
- * - Build Notifications (webhooks, email, Slack, Discord)
- * - Build Analytics
- */
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 class BuildQueueManager {
-    constructor() {
-        this.queues = new Map();
-        this.jobs = new Map();
-        this.jobQueues = new Map(); // queue name -> job IDs
-        this.callbacks = {};
-        // Create default queues
-        this.createDefaultQueues();
-    }
-    createDefaultQueues() {
-        const defaultQueues = [
-            {
-                name: 'free-linux',
-                priority: 'low',
-                maxConcurrent: 2,
-                maxQueueSize: 100,
-                buildTimeout: 1800000, // 30 min
-                supportedEngines: ['unity', 'godot', 'nice2dev'],
-                supportedPlatforms: ['linux', 'webgl', 'web'],
-                isPaidTier: false,
-                rateLimitPerHour: 5,
-            },
-            {
-                name: 'free-windows',
-                priority: 'low',
-                maxConcurrent: 2,
-                maxQueueSize: 100,
-                buildTimeout: 1800000,
-                supportedEngines: ['unity', 'godot', 'unreal', 'nice2dev'],
-                supportedPlatforms: ['windows', 'android'],
-                isPaidTier: false,
-                rateLimitPerHour: 5,
-            },
-            {
-                name: 'pro-priority',
-                priority: 'high',
-                maxConcurrent: 10,
-                maxQueueSize: 500,
-                buildTimeout: 7200000, // 2 hours
-                supportedEngines: ['unity', 'godot', 'unreal', 'nice2dev'],
-                supportedPlatforms: ['*'],
-                isPaidTier: true,
-            },
-            {
-                name: 'enterprise',
-                priority: 'critical',
-                maxConcurrent: 50,
-                maxQueueSize: 1000,
-                buildTimeout: 14400000, // 4 hours
-                supportedEngines: ['unity', 'godot', 'unreal', 'nice2dev'],
-                supportedPlatforms: ['*'],
-                isPaidTier: true,
-            },
-        ];
-        for (const queue of defaultQueues) {
-            this.queues.set(queue.name, queue);
-            this.jobQueues.set(queue.name, []);
-        }
-    }
-    // ─── Queue Management ──────────────────────────────────
-    createQueue(config) {
-        this.queues.set(config.name, config);
-        this.jobQueues.set(config.name, []);
-    }
-    getQueue(name) {
-        return this.queues.get(name);
-    }
-    getQueues() {
-        return Array.from(this.queues.values());
-    }
-    deleteQueue(name) {
-        if (!this.queues.has(name)) {
-            return false;
-        }
-        // Cancel all jobs in queue
-        const queueJobs = this.jobQueues.get(name) ?? [];
-        for (const jobId of queueJobs) {
-            this.cancelJob(jobId);
-        }
-        this.queues.delete(name);
-        this.jobQueues.delete(name);
-        return true;
-    }
-    // ─── Job Management ────────────────────────────────────
-    submitJob(engine, platform, buildConfig, options) {
-        const jobId = this.generateJobId();
-        const priority = options?.priority ?? 'normal';
-        // Find appropriate queue
-        const queueName = this.findQueueForJob(engine, platform, priority);
-        if (!queueName) {
-            throw new Error(`No available queue for ${engine}/${platform}`);
-        }
-        const queue = this.queues.get(queueName);
-        const queueJobs = this.jobQueues.get(queueName);
-        // Check queue limits
-        if (queueJobs.length >= queue.maxQueueSize) {
-            throw new Error(`Queue ${queueName} is full`);
-        }
-        const job = {
-            id: jobId,
-            userId: options?.userId ?? 'anonymous',
-            engine,
-            platform,
-            priority,
-            status: 'queued',
-            queuePosition: queueJobs.length + 1,
-            createdAt: Date.now(),
-            buildConfig,
-            retryCount: 0,
-            maxRetries: options?.maxRetries ?? 3,
-            estimatedWaitTime: this.estimateWaitTime(queueName),
-            estimatedBuildTime: this.estimateBuildTime(engine, platform),
-        };
-        this.jobs.set(jobId, job);
-        queueJobs.push(jobId);
-        this.callbacks.onJobQueued?.(job);
-        return job;
-    }
-    findQueueForJob(engine, platform, priority) {
-        for (const [name, queue] of this.queues) {
-            if (!queue.supportedEngines.includes(engine)) {
-                continue;
-            }
-            if (!queue.supportedPlatforms.includes('*') && !queue.supportedPlatforms.includes(platform)) {
-                continue;
-            }
-            if (this.getPriorityLevel(priority) > this.getPriorityLevel(queue.priority)) {
-                continue;
-            }
-            return name;
-        }
-        return null;
-    }
-    getPriorityLevel(priority) {
-        const levels = {
-            low: 0,
-            normal: 1,
-            high: 2,
-            critical: 3,
-        };
-        return levels[priority];
-    }
-    generateJobId() {
-        return `job-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-    }
-    estimateWaitTime(queueName) {
-        const queue = this.queues.get(queueName);
-        const queueJobs = this.jobQueues.get(queueName);
-        if (!queue || !queueJobs) {
-            return 0;
-        }
-        // Simple estimation: position * average build time / concurrent builds
-        const avgBuildTime = 600000; // 10 minutes average
-        return (queueJobs.length * avgBuildTime) / queue.maxConcurrent;
-    }
-    estimateBuildTime(engine, _platform) {
-        // Rough estimates in ms
-        const estimates = {
-            unity: 900000, // 15 minutes
-            godot: 300000, // 5 minutes
-            unreal: 1800000, // 30 minutes
-            nice2dev: 120000, // 2 minutes
-        };
-        return estimates[engine] ?? 600000;
-    }
-    cancelJob(jobId) {
-        const job = this.jobs.get(jobId);
-        if (!job) {
-            return false;
-        }
-        if (job.status === 'completed' || job.status === 'cancelled') {
-            return false;
-        }
-        job.status = 'cancelled';
-        job.completedAt = Date.now();
-        // Remove from queue
-        for (const [queueName, queueJobs] of this.jobQueues) {
-            const idx = queueJobs.indexOf(jobId);
-            if (idx !== -1) {
-                queueJobs.splice(idx, 1);
-                this.updateQueuePositions(queueName);
-                break;
-            }
-        }
-        this.callbacks.onJobCancelled?.(job);
-        return true;
-    }
-    updateQueuePositions(queueName) {
-        const queueJobs = this.jobQueues.get(queueName);
-        if (!queueJobs) {
-            return;
-        }
-        for (let i = 0; i < queueJobs.length; i++) {
-            const job = this.jobs.get(queueJobs[i]);
-            if (job && job.status === 'queued') {
-                job.queuePosition = i + 1;
-            }
-        }
-    }
-    getJob(jobId) {
-        return this.jobs.get(jobId);
-    }
-    getJobsByUser(userId) {
-        return Array.from(this.jobs.values()).filter((job) => job.userId === userId);
-    }
-    getJobsByStatus(status) {
-        return Array.from(this.jobs.values()).filter((job) => job.status === status);
-    }
-    // ─── Job Assignment ────────────────────────────────────
-    assignJobToAgent(jobId, agentId) {
-        const job = this.jobs.get(jobId);
-        if (!job || job.status !== 'queued') {
-            return false;
-        }
-        job.status = 'assigned';
-        job.assignedAgentId = agentId;
-        job.startedAt = Date.now();
-        this.callbacks.onJobAssigned?.(job, agentId);
-        return true;
-    }
-    startJob(jobId) {
-        const job = this.jobs.get(jobId);
-        if (!job || job.status !== 'assigned') {
-            return false;
-        }
-        job.status = 'running';
-        this.callbacks.onJobStarted?.(job);
-        return true;
-    }
-    completeJob(jobId, artifacts) {
-        const job = this.jobs.get(jobId);
-        if (!job || job.status !== 'running') {
-            return false;
-        }
-        job.status = 'completed';
-        job.completedAt = Date.now();
-        job.artifacts = artifacts;
-        this.callbacks.onJobCompleted?.(job);
-        return true;
-    }
-    failJob(jobId, error) {
-        const job = this.jobs.get(jobId);
-        if (!job) {
-            return false;
-        }
-        job.error = error;
-        // Check if should retry
-        if (job.retryCount < job.maxRetries) {
-            job.retryCount++;
-            job.status = 'queued';
-            job.assignedAgentId = undefined;
-            job.startedAt = undefined;
-            this.callbacks.onJobRetry?.(job);
-        }
-        else {
-            job.status = 'failed';
-            job.completedAt = Date.now();
-            this.callbacks.onJobFailed?.(job, error);
-        }
-        return true;
-    }
-    // ─── Queue Stats ───────────────────────────────────────
-    getQueueStats(queueName) {
-        const queue = this.queues.get(queueName);
-        const queueJobs = this.jobQueues.get(queueName);
-        if (!queue || !queueJobs) {
-            return undefined;
-        }
-        let running = 0;
-        let waiting = 0;
-        for (const jobId of queueJobs) {
-            const job = this.jobs.get(jobId);
-            if (!job) {
-                continue;
-            }
-            if (job.status === 'running') {
-                running++;
-            }
-            else if (job.status === 'queued') {
-                waiting++;
-            }
-        }
-        return {
-            queueName,
-            totalJobs: queueJobs.length,
-            runningJobs: running,
-            waitingJobs: waiting,
-            maxConcurrent: queue.maxConcurrent,
-            maxQueueSize: queue.maxQueueSize,
-            utilizationPercent: (running / queue.maxConcurrent) * 100,
-            estimatedWaitTime: this.estimateWaitTime(queueName),
-        };
-    }
-    getAllQueueStats() {
-        return Array.from(this.queues.keys())
-            .map((name) => this.getQueueStats(name))
-            .filter(Boolean);
-    }
-    // ─── Callbacks ─────────────────────────────────────────
-    setCallbacks(callbacks) {
-        this.callbacks = { ...this.callbacks, ...callbacks };
-    }
+  constructor() {
+    this.queues = /* @__PURE__ */ new Map();
+    this.jobs = /* @__PURE__ */ new Map();
+    this.jobQueues = /* @__PURE__ */ new Map();
+    this.callbacks = {};
+    this.createDefaultQueues();
+  }
+  createDefaultQueues() {
+    const defaultQueues = [
+      {
+        name: "free-linux",
+        priority: "low",
+        maxConcurrent: 2,
+        maxQueueSize: 100,
+        buildTimeout: 18e5,
+        // 30 min
+        supportedEngines: ["unity", "godot", "nice2dev"],
+        supportedPlatforms: ["linux", "webgl", "web"],
+        isPaidTier: false,
+        rateLimitPerHour: 5
+      },
+      {
+        name: "free-windows",
+        priority: "low",
+        maxConcurrent: 2,
+        maxQueueSize: 100,
+        buildTimeout: 18e5,
+        supportedEngines: ["unity", "godot", "unreal", "nice2dev"],
+        supportedPlatforms: ["windows", "android"],
+        isPaidTier: false,
+        rateLimitPerHour: 5
+      },
+      {
+        name: "pro-priority",
+        priority: "high",
+        maxConcurrent: 10,
+        maxQueueSize: 500,
+        buildTimeout: 72e5,
+        // 2 hours
+        supportedEngines: ["unity", "godot", "unreal", "nice2dev"],
+        supportedPlatforms: ["*"],
+        isPaidTier: true
+      },
+      {
+        name: "enterprise",
+        priority: "critical",
+        maxConcurrent: 50,
+        maxQueueSize: 1e3,
+        buildTimeout: 144e5,
+        // 4 hours
+        supportedEngines: ["unity", "godot", "unreal", "nice2dev"],
+        supportedPlatforms: ["*"],
+        isPaidTier: true
+      }
+    ];
+    for (const queue of defaultQueues) {
+      this.queues.set(queue.name, queue);
+      this.jobQueues.set(queue.name, []);
+    }
+  }
+  // ─── Queue Management ──────────────────────────────────
+  createQueue(config) {
+    this.queues.set(config.name, config);
+    this.jobQueues.set(config.name, []);
+  }
+  getQueue(name) {
+    return this.queues.get(name);
+  }
+  getQueues() {
+    return Array.from(this.queues.values());
+  }
+  deleteQueue(name) {
+    if (!this.queues.has(name)) {
+      return false;
+    }
+    const queueJobs = this.jobQueues.get(name) ?? [];
+    for (const jobId of queueJobs) {
+      this.cancelJob(jobId);
+    }
+    this.queues.delete(name);
+    this.jobQueues.delete(name);
+    return true;
+  }
+  // ─── Job Management ────────────────────────────────────
+  submitJob(engine, platform, buildConfig, options) {
+    const jobId = this.generateJobId();
+    const priority = options?.priority ?? "normal";
+    const queueName = this.findQueueForJob(engine, platform, priority);
+    if (!queueName) {
+      throw new Error(`No available queue for ${engine}/${platform}`);
+    }
+    const queue = this.queues.get(queueName);
+    const queueJobs = this.jobQueues.get(queueName);
+    if (queueJobs.length >= queue.maxQueueSize) {
+      throw new Error(`Queue ${queueName} is full`);
+    }
+    const job = {
+      id: jobId,
+      userId: options?.userId ?? "anonymous",
+      engine,
+      platform,
+      priority,
+      status: "queued",
+      queuePosition: queueJobs.length + 1,
+      createdAt: Date.now(),
+      buildConfig,
+      retryCount: 0,
+      maxRetries: options?.maxRetries ?? 3,
+      estimatedWaitTime: this.estimateWaitTime(queueName),
+      estimatedBuildTime: this.estimateBuildTime(engine, platform)
+    };
+    this.jobs.set(jobId, job);
+    queueJobs.push(jobId);
+    this.callbacks.onJobQueued?.(job);
+    return job;
+  }
+  findQueueForJob(engine, platform, priority) {
+    for (const [name, queue] of this.queues) {
+      if (!queue.supportedEngines.includes(engine)) {
+        continue;
+      }
+      if (!queue.supportedPlatforms.includes("*") && !queue.supportedPlatforms.includes(platform)) {
+        continue;
+      }
+      if (this.getPriorityLevel(priority) > this.getPriorityLevel(queue.priority)) {
+        continue;
+      }
+      return name;
+    }
+    return null;
+  }
+  getPriorityLevel(priority) {
+    const levels = {
+      low: 0,
+      normal: 1,
+      high: 2,
+      critical: 3
+    };
+    return levels[priority];
+  }
+  generateJobId() {
+    return `job-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+  estimateWaitTime(queueName) {
+    const queue = this.queues.get(queueName);
+    const queueJobs = this.jobQueues.get(queueName);
+    if (!queue || !queueJobs) {
+      return 0;
+    }
+    const avgBuildTime = 6e5;
+    return queueJobs.length * avgBuildTime / queue.maxConcurrent;
+  }
+  estimateBuildTime(engine, _platform) {
+    const estimates = {
+      unity: 9e5,
+      // 15 minutes
+      godot: 3e5,
+      // 5 minutes
+      unreal: 18e5,
+      // 30 minutes
+      nice2dev: 12e4
+      // 2 minutes
+    };
+    return estimates[engine] ?? 6e5;
+  }
+  cancelJob(jobId) {
+    const job = this.jobs.get(jobId);
+    if (!job) {
+      return false;
+    }
+    if (job.status === "completed" || job.status === "cancelled") {
+      return false;
+    }
+    job.status = "cancelled";
+    job.completedAt = Date.now();
+    for (const [queueName, queueJobs] of this.jobQueues) {
+      const idx = queueJobs.indexOf(jobId);
+      if (idx !== -1) {
+        queueJobs.splice(idx, 1);
+        this.updateQueuePositions(queueName);
+        break;
+      }
+    }
+    this.callbacks.onJobCancelled?.(job);
+    return true;
+  }
+  updateQueuePositions(queueName) {
+    const queueJobs = this.jobQueues.get(queueName);
+    if (!queueJobs) {
+      return;
+    }
+    for (let i = 0; i < queueJobs.length; i++) {
+      const job = this.jobs.get(queueJobs[i]);
+      if (job && job.status === "queued") {
+        job.queuePosition = i + 1;
+      }
+    }
+  }
+  getJob(jobId) {
+    return this.jobs.get(jobId);
+  }
+  getJobsByUser(userId) {
+    return Array.from(this.jobs.values()).filter((job) => job.userId === userId);
+  }
+  getJobsByStatus(status) {
+    return Array.from(this.jobs.values()).filter((job) => job.status === status);
+  }
+  // ─── Job Assignment ────────────────────────────────────
+  assignJobToAgent(jobId, agentId) {
+    const job = this.jobs.get(jobId);
+    if (!job || job.status !== "queued") {
+      return false;
+    }
+    job.status = "assigned";
+    job.assignedAgentId = agentId;
+    job.startedAt = Date.now();
+    this.callbacks.onJobAssigned?.(job, agentId);
+    return true;
+  }
+  startJob(jobId) {
+    const job = this.jobs.get(jobId);
+    if (!job || job.status !== "assigned") {
+      return false;
+    }
+    job.status = "running";
+    this.callbacks.onJobStarted?.(job);
+    return true;
+  }
+  completeJob(jobId, artifacts) {
+    const job = this.jobs.get(jobId);
+    if (!job || job.status !== "running") {
+      return false;
+    }
+    job.status = "completed";
+    job.completedAt = Date.now();
+    job.artifacts = artifacts;
+    this.callbacks.onJobCompleted?.(job);
+    return true;
+  }
+  failJob(jobId, error) {
+    const job = this.jobs.get(jobId);
+    if (!job) {
+      return false;
+    }
+    job.error = error;
+    if (job.retryCount < job.maxRetries) {
+      job.retryCount++;
+      job.status = "queued";
+      job.assignedAgentId = void 0;
+      job.startedAt = void 0;
+      this.callbacks.onJobRetry?.(job);
+    } else {
+      job.status = "failed";
+      job.completedAt = Date.now();
+      this.callbacks.onJobFailed?.(job, error);
+    }
+    return true;
+  }
+  // ─── Queue Stats ───────────────────────────────────────
+  getQueueStats(queueName) {
+    const queue = this.queues.get(queueName);
+    const queueJobs = this.jobQueues.get(queueName);
+    if (!queue || !queueJobs) {
+      return void 0;
+    }
+    let running = 0;
+    let waiting = 0;
+    for (const jobId of queueJobs) {
+      const job = this.jobs.get(jobId);
+      if (!job) {
+        continue;
+      }
+      if (job.status === "running") {
+        running++;
+      } else if (job.status === "queued") {
+        waiting++;
+      }
+    }
+    return {
+      queueName,
+      totalJobs: queueJobs.length,
+      runningJobs: running,
+      waitingJobs: waiting,
+      maxConcurrent: queue.maxConcurrent,
+      maxQueueSize: queue.maxQueueSize,
+      utilizationPercent: running / queue.maxConcurrent * 100,
+      estimatedWaitTime: this.estimateWaitTime(queueName)
+    };
+  }
+  getAllQueueStats() {
+    return Array.from(this.queues.keys()).map((name) => this.getQueueStats(name)).filter(Boolean);
+  }
+  // ─── Callbacks ─────────────────────────────────────────
+  setCallbacks(callbacks) {
+    this.callbacks = { ...this.callbacks, ...callbacks };
+  }
 }
 class BuildAgentPool {
-    constructor() {
-        this.agents = new Map();
-        this.pools = new Map();
-        this.callbacks = {};
-        this.heartbeatInterval = 30000; // 30 seconds
-        this.heartbeatTimeout = 90000; // 90 seconds
-        // Create default pools
-        this.createDefaultPools();
-    }
-    createDefaultPools() {
-        const defaultPools = [
-            {
-                name: 'linux-pool',
-                minAgents: 2,
-                maxAgents: 20,
-                agentTemplate: {
-                    os: 'linux',
-                    supportedEngines: ['unity', 'godot', 'nice2dev'],
-                    supportedPlatforms: ['linux', 'webgl', 'web', 'android'],
-                    cpuCores: 8,
-                    memoryGB: 32,
-                    diskGB: 500,
-                },
-                autoScaling: true,
-                scaleUpThreshold: 5,
-                scaleDownThreshold: 300000, // 5 minutes
-                useSpotInstances: true,
-                spotPercentage: 50,
-            },
-            {
-                name: 'windows-pool',
-                minAgents: 2,
-                maxAgents: 20,
-                agentTemplate: {
-                    os: 'windows',
-                    supportedEngines: ['unity', 'godot', 'unreal', 'nice2dev'],
-                    supportedPlatforms: ['windows', 'android', 'uwp'],
-                    cpuCores: 16,
-                    memoryGB: 64,
-                    diskGB: 1000,
-                },
-                autoScaling: true,
-                scaleUpThreshold: 3,
-                scaleDownThreshold: 300000,
-                useSpotInstances: true,
-                spotPercentage: 30,
-            },
-            {
-                name: 'macos-pool',
-                minAgents: 1,
-                maxAgents: 10,
-                agentTemplate: {
-                    os: 'macos',
-                    supportedEngines: ['unity', 'godot', 'unreal', 'nice2dev'],
-                    supportedPlatforms: ['macos', 'ios', 'tvos'],
-                    cpuCores: 8,
-                    memoryGB: 32,
-                    diskGB: 500,
-                },
-                autoScaling: true,
-                scaleUpThreshold: 2,
-                scaleDownThreshold: 600000, // 10 minutes (more expensive)
-                useSpotInstances: false,
-                spotPercentage: 0,
-            },
-        ];
-        for (const pool of defaultPools) {
-            this.pools.set(pool.name, pool);
-        }
-    }
-    // ─── Pool Management ───────────────────────────────────
-    createPool(config) {
-        this.pools.set(config.name, config);
-    }
-    getPool(name) {
-        return this.pools.get(name);
-    }
-    getPools() {
-        return Array.from(this.pools.values());
-    }
-    deletePool(name) {
-        return this.pools.delete(name);
-    }
-    // ─── Agent Management ──────────────────────────────────
-    registerAgent(agent) {
-        const fullAgent = {
-            ...agent,
-            id: this.generateAgentId(),
-            lastHeartbeat: Date.now(),
-            jobsCompleted: 0,
-            jobsFailed: 0,
-            avgBuildTime: 0,
-        };
-        this.agents.set(fullAgent.id, fullAgent);
-        this.callbacks.onAgentRegistered?.(fullAgent);
-        return fullAgent;
-    }
-    generateAgentId() {
-        return `agent-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-    }
-    unregisterAgent(agentId) {
-        const agent = this.agents.get(agentId);
-        if (!agent) {
-            return false;
-        }
-        // If agent has a job, mark it for reassignment
+  // 90 seconds
+  constructor() {
+    this.agents = /* @__PURE__ */ new Map();
+    this.pools = /* @__PURE__ */ new Map();
+    this.callbacks = {};
+    this.heartbeatInterval = 3e4;
+    this.heartbeatTimeout = 9e4;
+    this.createDefaultPools();
+  }
+  createDefaultPools() {
+    const defaultPools = [
+      {
+        name: "linux-pool",
+        minAgents: 2,
+        maxAgents: 20,
+        agentTemplate: {
+          os: "linux",
+          supportedEngines: ["unity", "godot", "nice2dev"],
+          supportedPlatforms: ["linux", "webgl", "web", "android"],
+          cpuCores: 8,
+          memoryGB: 32,
+          diskGB: 500
+        },
+        autoScaling: true,
+        scaleUpThreshold: 5,
+        scaleDownThreshold: 3e5,
+        // 5 minutes
+        useSpotInstances: true,
+        spotPercentage: 50
+      },
+      {
+        name: "windows-pool",
+        minAgents: 2,
+        maxAgents: 20,
+        agentTemplate: {
+          os: "windows",
+          supportedEngines: ["unity", "godot", "unreal", "nice2dev"],
+          supportedPlatforms: ["windows", "android", "uwp"],
+          cpuCores: 16,
+          memoryGB: 64,
+          diskGB: 1e3
+        },
+        autoScaling: true,
+        scaleUpThreshold: 3,
+        scaleDownThreshold: 3e5,
+        useSpotInstances: true,
+        spotPercentage: 30
+      },
+      {
+        name: "macos-pool",
+        minAgents: 1,
+        maxAgents: 10,
+        agentTemplate: {
+          os: "macos",
+          supportedEngines: ["unity", "godot", "unreal", "nice2dev"],
+          supportedPlatforms: ["macos", "ios", "tvos"],
+          cpuCores: 8,
+          memoryGB: 32,
+          diskGB: 500
+        },
+        autoScaling: true,
+        scaleUpThreshold: 2,
+        scaleDownThreshold: 6e5,
+        // 10 minutes (more expensive)
+        useSpotInstances: false,
+        spotPercentage: 0
+      }
+    ];
+    for (const pool of defaultPools) {
+      this.pools.set(pool.name, pool);
+    }
+  }
+  // ─── Pool Management ───────────────────────────────────
+  createPool(config) {
+    this.pools.set(config.name, config);
+  }
+  getPool(name) {
+    return this.pools.get(name);
+  }
+  getPools() {
+    return Array.from(this.pools.values());
+  }
+  deletePool(name) {
+    return this.pools.delete(name);
+  }
+  // ─── Agent Management ──────────────────────────────────
+  registerAgent(agent) {
+    const fullAgent = {
+      ...agent,
+      id: this.generateAgentId(),
+      lastHeartbeat: Date.now(),
+      jobsCompleted: 0,
+      jobsFailed: 0,
+      avgBuildTime: 0
+    };
+    this.agents.set(fullAgent.id, fullAgent);
+    this.callbacks.onAgentRegistered?.(fullAgent);
+    return fullAgent;
+  }
+  generateAgentId() {
+    return `agent-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+  unregisterAgent(agentId) {
+    const agent = this.agents.get(agentId);
+    if (!agent) {
+      return false;
+    }
+    if (agent.currentJobId) {
+      this.callbacks.onAgentLostJob?.(agent, agent.currentJobId);
+    }
+    this.agents.delete(agentId);
+    this.callbacks.onAgentUnregistered?.(agent);
+    return true;
+  }
+  getAgent(agentId) {
+    return this.agents.get(agentId);
+  }
+  getAgents() {
+    return Array.from(this.agents.values());
+  }
+  getAgentsByStatus(status) {
+    return Array.from(this.agents.values()).filter((a) => a.status === status);
+  }
+  getAgentsByOS(os) {
+    return Array.from(this.agents.values()).filter((a) => a.os === os);
+  }
+  getIdleAgents() {
+    return this.getAgentsByStatus("idle");
+  }
+  // ─── Agent Lifecycle ───────────────────────────────────
+  heartbeat(agentId) {
+    const agent = this.agents.get(agentId);
+    if (!agent) {
+      return false;
+    }
+    agent.lastHeartbeat = Date.now();
+    if (agent.status === "offline") {
+      agent.status = agent.currentJobId ? "busy" : "idle";
+      this.callbacks.onAgentOnline?.(agent);
+    }
+    return true;
+  }
+  checkAgentHealth() {
+    const now = Date.now();
+    for (const agent of this.agents.values()) {
+      if (now - agent.lastHeartbeat > this.heartbeatTimeout && agent.status !== "offline") {
+        agent.status = "offline";
+        this.callbacks.onAgentOffline?.(agent);
         if (agent.currentJobId) {
-            this.callbacks.onAgentLostJob?.(agent, agent.currentJobId);
+          this.callbacks.onAgentLostJob?.(agent, agent.currentJobId);
         }
-        this.agents.delete(agentId);
-        this.callbacks.onAgentUnregistered?.(agent);
-        return true;
-    }
-    getAgent(agentId) {
-        return this.agents.get(agentId);
-    }
-    getAgents() {
-        return Array.from(this.agents.values());
-    }
-    getAgentsByStatus(status) {
-        return Array.from(this.agents.values()).filter((a) => a.status === status);
-    }
-    getAgentsByOS(os) {
-        return Array.from(this.agents.values()).filter((a) => a.os === os);
-    }
-    getIdleAgents() {
-        return this.getAgentsByStatus('idle');
-    }
-    // ─── Agent Lifecycle ───────────────────────────────────
-    heartbeat(agentId) {
-        const agent = this.agents.get(agentId);
-        if (!agent) {
-            return false;
-        }
-        agent.lastHeartbeat = Date.now();
-        // Update status if was offline
-        if (agent.status === 'offline') {
-            agent.status = agent.currentJobId ? 'busy' : 'idle';
-            this.callbacks.onAgentOnline?.(agent);
-        }
-        return true;
-    }
-    checkAgentHealth() {
+      }
+    }
+  }
+  assignJob(agentId, jobId) {
+    const agent = this.agents.get(agentId);
+    if (!agent || agent.status !== "idle") {
+      return false;
+    }
+    agent.status = "busy";
+    agent.currentJobId = jobId;
+    this.callbacks.onAgentBusy?.(agent, jobId);
+    return true;
+  }
+  completeJob(agentId, success, buildTime) {
+    const agent = this.agents.get(agentId);
+    if (!agent || !agent.currentJobId) {
+      return false;
+    }
+    const jobId = agent.currentJobId;
+    agent.currentJobId = void 0;
+    agent.status = "idle";
+    if (success) {
+      agent.jobsCompleted++;
+      const totalTime = agent.avgBuildTime * (agent.jobsCompleted - 1) + buildTime;
+      agent.avgBuildTime = totalTime / agent.jobsCompleted;
+    } else {
+      agent.jobsFailed++;
+    }
+    this.callbacks.onAgentIdle?.(agent, jobId);
+    return true;
+  }
+  // ─── Auto-scaling ──────────────────────────────────────
+  evaluateScaling(queueManager) {
+    const decisions = [];
+    for (const [poolName, pool] of this.pools) {
+      if (!pool.autoScaling) {
+        continue;
+      }
+      const poolAgents = Array.from(this.agents.values()).filter(
+        (a) => a.os === pool.agentTemplate.os && a.region === (pool.agentTemplate.region ?? "default")
+      );
+      const idleAgents = poolAgents.filter((a) => a.status === "idle");
+      poolAgents.filter((a) => a.status === "busy");
+      const queueStats = queueManager.getAllQueueStats();
+      const waitingJobs = queueStats.reduce((sum, s) => sum + s.waitingJobs, 0);
+      if (waitingJobs >= pool.scaleUpThreshold && poolAgents.length < pool.maxAgents) {
+        const toAdd = Math.min(Math.ceil(waitingJobs / 2), pool.maxAgents - poolAgents.length);
+        decisions.push({
+          pool: poolName,
+          action: "scale_up",
+          count: toAdd,
+          reason: `${waitingJobs} jobs waiting, threshold is ${pool.scaleUpThreshold}`,
+          useSpot: pool.useSpotInstances && Math.random() < pool.spotPercentage / 100
+        });
+      }
+      if (idleAgents.length > 0 && poolAgents.length > pool.minAgents) {
         const now = Date.now();
-        for (const agent of this.agents.values()) {
-            if (now - agent.lastHeartbeat > this.heartbeatTimeout && agent.status !== 'offline') {
-                agent.status = 'offline';
-                this.callbacks.onAgentOffline?.(agent);
-                // Handle lost job
-                if (agent.currentJobId) {
-                    this.callbacks.onAgentLostJob?.(agent, agent.currentJobId);
-                }
-            }
-        }
-    }
-    assignJob(agentId, jobId) {
-        const agent = this.agents.get(agentId);
-        if (!agent || agent.status !== 'idle') {
-            return false;
-        }
-        agent.status = 'busy';
-        agent.currentJobId = jobId;
-        this.callbacks.onAgentBusy?.(agent, jobId);
-        return true;
-    }
-    completeJob(agentId, success, buildTime) {
-        const agent = this.agents.get(agentId);
-        if (!agent || !agent.currentJobId) {
-            return false;
-        }
-        const jobId = agent.currentJobId;
-        agent.currentJobId = undefined;
-        agent.status = 'idle';
-        if (success) {
-            agent.jobsCompleted++;
-            // Update average build time
-            const totalTime = agent.avgBuildTime * (agent.jobsCompleted - 1) + buildTime;
-            agent.avgBuildTime = totalTime / agent.jobsCompleted;
-        }
-        else {
-            agent.jobsFailed++;
-        }
-        this.callbacks.onAgentIdle?.(agent, jobId);
-        return true;
-    }
-    // ─── Auto-scaling ──────────────────────────────────────
-    evaluateScaling(queueManager) {
-        const decisions = [];
-        for (const [poolName, pool] of this.pools) {
-            if (!pool.autoScaling) {
-                continue;
-            }
-            const poolAgents = Array.from(this.agents.values()).filter((a) => a.os === pool.agentTemplate.os && a.region === (pool.agentTemplate.region ?? 'default'));
-            const idleAgents = poolAgents.filter((a) => a.status === 'idle');
-            poolAgents.filter((a) => a.status === 'busy');
-            // Get queue pressure
-            const queueStats = queueManager.getAllQueueStats();
-            const waitingJobs = queueStats.reduce((sum, s) => sum + s.waitingJobs, 0);
-            // Scale up decision
-            if (waitingJobs >= pool.scaleUpThreshold && poolAgents.length < pool.maxAgents) {
-                const toAdd = Math.min(Math.ceil(waitingJobs / 2), pool.maxAgents - poolAgents.length);
-                decisions.push({
-                    pool: poolName,
-                    action: 'scale_up',
-                    count: toAdd,
-                    reason: `${waitingJobs} jobs waiting, threshold is ${pool.scaleUpThreshold}`,
-                    useSpot: pool.useSpotInstances && Math.random() < pool.spotPercentage / 100,
-                });
-            }
-            // Scale down decision
-            if (idleAgents.length > 0 && poolAgents.length > pool.minAgents) {
-                // Check idle time
-                const now = Date.now();
-                const longIdleAgents = idleAgents.filter((a) => {
-                    // Estimate idle time based on last heartbeat
-                    const idleTime = now - a.lastHeartbeat;
-                    return idleTime > pool.scaleDownThreshold;
-                });
-                // Prefer removing spot instances first
-                const spotAgents = longIdleAgents.filter((a) => a.instanceType === 'spot');
-                const toRemove = spotAgents.length > 0 ? spotAgents : longIdleAgents;
-                if (toRemove.length > 0) {
-                    const removeCount = Math.min(toRemove.length, poolAgents.length - pool.minAgents);
-                    decisions.push({
-                        pool: poolName,
-                        action: 'scale_down',
-                        count: removeCount,
-                        reason: `${longIdleAgents.length} agents idle for ${pool.scaleDownThreshold}ms`,
-                        agentIds: toRemove.slice(0, removeCount).map((a) => a.id),
-                    });
-                }
-            }
-        }
-        return decisions;
-    }
-    // ─── Stats ─────────────────────────────────────────────
-    getPoolStats(poolName) {
-        const pool = this.pools.get(poolName);
-        if (!pool) {
-            return undefined;
-        }
-        const poolAgents = Array.from(this.agents.values()).filter((a) => a.os === pool.agentTemplate.os);
-        return {
-            poolName,
-            totalAgents: poolAgents.length,
-            idleAgents: poolAgents.filter((a) => a.status === 'idle').length,
-            busyAgents: poolAgents.filter((a) => a.status === 'busy').length,
-            offlineAgents: poolAgents.filter((a) => a.status === 'offline').length,
-            spotAgents: poolAgents.filter((a) => a.instanceType === 'spot').length,
-            dedicatedAgents: poolAgents.filter((a) => a.instanceType === 'dedicated').length,
-            minAgents: pool.minAgents,
-            maxAgents: pool.maxAgents,
-            avgBuildTime: this.calculateAvgBuildTime(poolAgents),
-            totalJobsCompleted: poolAgents.reduce((sum, a) => sum + a.jobsCompleted, 0),
-            totalJobsFailed: poolAgents.reduce((sum, a) => sum + a.jobsFailed, 0),
-        };
-    }
-    calculateAvgBuildTime(agents) {
-        const agentsWithJobs = agents.filter((a) => a.jobsCompleted > 0);
-        if (agentsWithJobs.length === 0) {
-            return 0;
+        const longIdleAgents = idleAgents.filter((a) => {
+          const idleTime = now - a.lastHeartbeat;
+          return idleTime > pool.scaleDownThreshold;
+        });
+        const spotAgents = longIdleAgents.filter((a) => a.instanceType === "spot");
+        const toRemove = spotAgents.length > 0 ? spotAgents : longIdleAgents;
+        if (toRemove.length > 0) {
+          const removeCount = Math.min(toRemove.length, poolAgents.length - pool.minAgents);
+          decisions.push({
+            pool: poolName,
+            action: "scale_down",
+            count: removeCount,
+            reason: `${longIdleAgents.length} agents idle for ${pool.scaleDownThreshold}ms`,
+            agentIds: toRemove.slice(0, removeCount).map((a) => a.id)
+          });
         }
-        const totalWeightedTime = agentsWithJobs.reduce((sum, a) => sum + a.avgBuildTime * a.jobsCompleted, 0);
-        const totalJobs = agentsWithJobs.reduce((sum, a) => sum + a.jobsCompleted, 0);
-        return totalWeightedTime / totalJobs;
-    }
-    getAllPoolStats() {
-        return Array.from(this.pools.keys())
-            .map((name) => this.getPoolStats(name))
-            .filter(Boolean);
-    }
-    // ─── Callbacks ─────────────────────────────────────────
-    setCallbacks(callbacks) {
-        this.callbacks = { ...this.callbacks, ...callbacks };
-    }
+      }
+    }
+    return decisions;
+  }
+  // ─── Stats ─────────────────────────────────────────────
+  getPoolStats(poolName) {
+    const pool = this.pools.get(poolName);
+    if (!pool) {
+      return void 0;
+    }
+    const poolAgents = Array.from(this.agents.values()).filter(
+      (a) => a.os === pool.agentTemplate.os
+    );
+    return {
+      poolName,
+      totalAgents: poolAgents.length,
+      idleAgents: poolAgents.filter((a) => a.status === "idle").length,
+      busyAgents: poolAgents.filter((a) => a.status === "busy").length,
+      offlineAgents: poolAgents.filter((a) => a.status === "offline").length,
+      spotAgents: poolAgents.filter((a) => a.instanceType === "spot").length,
+      dedicatedAgents: poolAgents.filter((a) => a.instanceType === "dedicated").length,
+      minAgents: pool.minAgents,
+      maxAgents: pool.maxAgents,
+      avgBuildTime: this.calculateAvgBuildTime(poolAgents),
+      totalJobsCompleted: poolAgents.reduce((sum, a) => sum + a.jobsCompleted, 0),
+      totalJobsFailed: poolAgents.reduce((sum, a) => sum + a.jobsFailed, 0)
+    };
+  }
+  calculateAvgBuildTime(agents) {
+    const agentsWithJobs = agents.filter((a) => a.jobsCompleted > 0);
+    if (agentsWithJobs.length === 0) {
+      return 0;
+    }
+    const totalWeightedTime = agentsWithJobs.reduce(
+      (sum, a) => sum + a.avgBuildTime * a.jobsCompleted,
+      0
+    );
+    const totalJobs = agentsWithJobs.reduce((sum, a) => sum + a.jobsCompleted, 0);
+    return totalWeightedTime / totalJobs;
+  }
+  getAllPoolStats() {
+    return Array.from(this.pools.keys()).map((name) => this.getPoolStats(name)).filter(Boolean);
+  }
+  // ─── Callbacks ─────────────────────────────────────────
+  setCallbacks(callbacks) {
+    this.callbacks = { ...this.callbacks, ...callbacks };
+  }
 }
 class ArtifactStorage {
-    constructor(config) {
-        this.artifacts = new Map();
-        this.config = config;
-    }
-    async uploadArtifact(jobId, name, data, options) {
-        const artifactId = this.generateArtifactId();
-        const path = `${jobId}/${artifactId}/${name}`;
-        // Calculate size and checksum
-        const size = typeof data === 'string' ? data.length : data instanceof Blob ? data.size : data.byteLength;
-        const checksum = await this.calculateChecksum(data);
-        // Check size limit
-        if (size > this.config.maxArtifactSize) {
-            throw new Error(`Artifact size ${size} exceeds limit ${this.config.maxArtifactSize}`);
-        }
-        const retentionDays = options?.retentionDays ?? this.config.retentionDays;
-        const expiresAt = Date.now() + retentionDays * 24 * 60 * 60 * 1000;
-        const artifact = {
-            id: artifactId,
-            jobId,
-            name,
-            path,
-            size,
-            checksum,
-            contentType: options?.contentType ?? 'application/octet-stream',
-            uploadedAt: Date.now(),
-            expiresAt,
-            metadata: options?.metadata ?? {},
-        };
-        // Generate download URL
-        if (this.config.signedUrls) {
-            artifact.downloadUrl = await this.generateSignedUrl(path);
-        }
-        else if (this.config.cdnUrl) {
-            artifact.downloadUrl = `${this.config.cdnUrl}/${path}`;
-        }
-        // In production, this would upload to the actual storage
-        this.artifacts.set(artifactId, artifact);
-        return artifact;
-    }
-    generateArtifactId() {
-        return `art-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-    }
-    async calculateChecksum(data) {
-        // Simplified checksum - in production use SHA-256
-        let input;
-        if (typeof data === 'string') {
-            input = new TextEncoder().encode(data).buffer;
-        }
-        else if (data instanceof Blob) {
-            input = await data.arrayBuffer();
-        }
-        else {
-            input = data;
-        }
-        const bytes = new Uint8Array(input);
-        let hash = 0;
-        for (let i = 0; i < bytes.length; i++) {
-            hash = ((hash << 5) - hash + bytes[i]) | 0;
-        }
-        return Math.abs(hash).toString(16).padStart(8, '0');
-    }
-    async generateSignedUrl(path) {
-        const expiration = Math.floor(Date.now() / 1000) + this.config.signedUrlExpiration;
-        const signature = await this.generateSignature(path, expiration);
-        const baseUrl = this.config.cdnUrl ?? `${this.config.endpoint}/${this.config.bucket}`;
-        return `${baseUrl}/${path}?expires=${expiration}&signature=${signature}`;
-    }
-    async generateSignature(path, expiration) {
-        // Simplified signature - in production use HMAC-SHA256
-        const data = `${path}:${expiration}:${this.config.secretKey ?? 'secret'}`;
-        let hash = 0;
-        for (let i = 0; i < data.length; i++) {
-            hash = ((hash << 5) - hash + data.charCodeAt(i)) | 0;
-        }
-        return Math.abs(hash).toString(16);
-    }
-    async getArtifact(artifactId) {
-        return this.artifacts.get(artifactId);
-    }
-    async getArtifactsByJob(jobId) {
-        return Array.from(this.artifacts.values()).filter((a) => a.jobId === jobId);
-    }
-    async deleteArtifact(artifactId) {
-        return this.artifacts.delete(artifactId);
-    }
-    async deleteArtifactsByJob(jobId) {
-        let deleted = 0;
-        for (const [id, artifact] of this.artifacts) {
-            if (artifact.jobId === jobId) {
-                this.artifacts.delete(id);
-                deleted++;
-            }
-        }
-        return deleted;
-    }
-    async cleanupExpiredArtifacts() {
-        const now = Date.now();
-        let deleted = 0;
-        for (const [id, artifact] of this.artifacts) {
-            if (artifact.expiresAt < now) {
-                this.artifacts.delete(id);
-                deleted++;
-            }
-        }
-        return deleted;
-    }
-    getStorageStats() {
-        let totalSize = 0;
-        let artifactCount = 0;
-        for (const artifact of this.artifacts.values()) {
-            totalSize += artifact.size;
-            artifactCount++;
-        }
-        return {
-            artifactCount,
-            totalSize,
-            bucket: this.config.bucket,
-            region: this.config.region,
-        };
-    }
+  constructor(config) {
+    this.artifacts = /* @__PURE__ */ new Map();
+    this.config = config;
+  }
+  async uploadArtifact(jobId, name, data, options) {
+    const artifactId = this.generateArtifactId();
+    const path = `${jobId}/${artifactId}/${name}`;
+    const size = typeof data === "string" ? data.length : data instanceof Blob ? data.size : data.byteLength;
+    const checksum = await this.calculateChecksum(data);
+    if (size > this.config.maxArtifactSize) {
+      throw new Error(`Artifact size ${size} exceeds limit ${this.config.maxArtifactSize}`);
+    }
+    const retentionDays = options?.retentionDays ?? this.config.retentionDays;
+    const expiresAt = Date.now() + retentionDays * 24 * 60 * 60 * 1e3;
+    const artifact = {
+      id: artifactId,
+      jobId,
+      name,
+      path,
+      size,
+      checksum,
+      contentType: options?.contentType ?? "application/octet-stream",
+      uploadedAt: Date.now(),
+      expiresAt,
+      metadata: options?.metadata ?? {}
+    };
+    if (this.config.signedUrls) {
+      artifact.downloadUrl = await this.generateSignedUrl(path);
+    } else if (this.config.cdnUrl) {
+      artifact.downloadUrl = `${this.config.cdnUrl}/${path}`;
+    }
+    this.artifacts.set(artifactId, artifact);
+    return artifact;
+  }
+  generateArtifactId() {
+    return `art-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+  async calculateChecksum(data) {
+    let input;
+    if (typeof data === "string") {
+      input = new TextEncoder().encode(data).buffer;
+    } else if (data instanceof Blob) {
+      input = await data.arrayBuffer();
+    } else {
+      input = data;
+    }
+    const bytes = new Uint8Array(input);
+    let hash = 0;
+    for (let i = 0; i < bytes.length; i++) {
+      hash = (hash << 5) - hash + bytes[i] | 0;
+    }
+    return Math.abs(hash).toString(16).padStart(8, "0");
+  }
+  async generateSignedUrl(path) {
+    const expiration = Math.floor(Date.now() / 1e3) + this.config.signedUrlExpiration;
+    const signature = await this.generateSignature(path, expiration);
+    const baseUrl = this.config.cdnUrl ?? `${this.config.endpoint}/${this.config.bucket}`;
+    return `${baseUrl}/${path}?expires=${expiration}&signature=${signature}`;
+  }
+  async generateSignature(path, expiration) {
+    const data = `${path}:${expiration}:${this.config.secretKey ?? "secret"}`;
+    let hash = 0;
+    for (let i = 0; i < data.length; i++) {
+      hash = (hash << 5) - hash + data.charCodeAt(i) | 0;
+    }
+    return Math.abs(hash).toString(16);
+  }
+  async getArtifact(artifactId) {
+    return this.artifacts.get(artifactId);
+  }
+  async getArtifactsByJob(jobId) {
+    return Array.from(this.artifacts.values()).filter((a) => a.jobId === jobId);
+  }
+  async deleteArtifact(artifactId) {
+    return this.artifacts.delete(artifactId);
+  }
+  async deleteArtifactsByJob(jobId) {
+    let deleted = 0;
+    for (const [id, artifact] of this.artifacts) {
+      if (artifact.jobId === jobId) {
+        this.artifacts.delete(id);
+        deleted++;
+      }
+    }
+    return deleted;
+  }
+  async cleanupExpiredArtifacts() {
+    const now = Date.now();
+    let deleted = 0;
+    for (const [id, artifact] of this.artifacts) {
+      if (artifact.expiresAt < now) {
+        this.artifacts.delete(id);
+        deleted++;
+      }
+    }
+    return deleted;
+  }
+  getStorageStats() {
+    let totalSize = 0;
+    let artifactCount = 0;
+    for (const artifact of this.artifacts.values()) {
+      totalSize += artifact.size;
+      artifactCount++;
+    }
+    return {
+      artifactCount,
+      totalSize,
+      bucket: this.config.bucket,
+      region: this.config.region
+    };
+  }
 }
 class BuildNotifications {
-    constructor() {
-        this.configs = new Map();
-    }
-    addConfig(name, config) {
-        this.configs.set(name, config);
-    }
-    removeConfig(name) {
-        return this.configs.delete(name);
-    }
-    getConfig(name) {
-        return this.configs.get(name);
-    }
-    async notify(payload) {
-        const results = [];
-        for (const [name, config] of this.configs) {
-            if (!config.enabled) {
-                continue;
-            }
-            if (!config.events.includes(payload.event)) {
-                continue;
-            }
-            try {
-                await this.sendNotification(config, payload);
-                results.push({ name, success: true });
-            }
-            catch (error) {
-                results.push({
-                    name,
-                    success: false,
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                });
-            }
+  constructor() {
+    this.configs = /* @__PURE__ */ new Map();
+  }
+  addConfig(name, config) {
+    this.configs.set(name, config);
+  }
+  removeConfig(name) {
+    return this.configs.delete(name);
+  }
+  getConfig(name) {
+    return this.configs.get(name);
+  }
+  async notify(payload) {
+    const results = [];
+    for (const [name, config] of this.configs) {
+      if (!config.enabled) {
+        continue;
+      }
+      if (!config.events.includes(payload.event)) {
+        continue;
+      }
+      try {
+        await this.sendNotification(config, payload);
+        results.push({ name, success: true });
+      } catch (error) {
+        results.push({
+          name,
+          success: false,
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+    }
+    return results;
+  }
+  async sendNotification(config, payload) {
+    switch (config.type) {
+      case "webhook":
+        await this.sendWebhook(config.webhookUrl, payload);
+        break;
+      case "slack":
+        await this.sendSlack(config.slack, payload);
+        break;
+      case "discord":
+        await this.sendDiscord(config.discord, payload);
+        break;
+      case "github":
+        await this.sendGitHubStatus(config.github, payload);
+        break;
+      case "gitlab":
+        await this.sendGitLabStatus(config.gitlab, payload);
+        break;
+      case "email":
+        console.log(`Would send email to: ${config.emails?.join(", ")}`);
+        break;
+    }
+  }
+  async sendWebhook(url, payload) {
+    console.log(`Webhook to ${url}:`, JSON.stringify(payload));
+  }
+  async sendSlack(config, payload) {
+    const color = this.getStatusColor(payload.job.status);
+    const slackPayload = {
+      channel: config.channel,
+      username: config.username ?? "Nice2Dev Build",
+      icon_emoji: config.iconEmoji ?? ":hammer:",
+      attachments: [
+        {
+          color,
+          title: `Build ${payload.event.replace("_", " ").toUpperCase()}`,
+          text: payload.message,
+          fields: [
+            { title: "Job ID", value: payload.job.id, short: true },
+            { title: "Engine", value: payload.job.engine, short: true },
+            { title: "Platform", value: payload.job.platform, short: true },
+            { title: "Status", value: payload.job.status, short: true }
+          ],
+          footer: "Nice2Dev Build Cloud",
+          ts: Math.floor(payload.timestamp / 1e3)
         }
-        return results;
-    }
-    async sendNotification(config, payload) {
-        switch (config.type) {
-            case 'webhook':
-                await this.sendWebhook(config.webhookUrl, payload);
-                break;
-            case 'slack':
-                await this.sendSlack(config.slack, payload);
-                break;
-            case 'discord':
-                await this.sendDiscord(config.discord, payload);
-                break;
-            case 'github':
-                await this.sendGitHubStatus(config.github, payload);
-                break;
-            case 'gitlab':
-                await this.sendGitLabStatus(config.gitlab, payload);
-                break;
-            case 'email':
-                // Email would require SMTP configuration
-                console.log(`Would send email to: ${config.emails?.join(', ')}`);
-                break;
+      ]
+    };
+    console.log(`Slack webhook:`, JSON.stringify(slackPayload));
+  }
+  async sendDiscord(config, payload) {
+    const color = this.getStatusColorInt(payload.job.status);
+    const discordPayload = {
+      username: config.username ?? "Nice2Dev Build",
+      avatar_url: config.avatarUrl,
+      embeds: [
+        {
+          title: `Build ${payload.event.replace("_", " ").toUpperCase()}`,
+          description: payload.message,
+          color,
+          fields: [
+            { name: "Job ID", value: payload.job.id, inline: true },
+            { name: "Engine", value: payload.job.engine, inline: true },
+            { name: "Platform", value: payload.job.platform, inline: true },
+            { name: "Status", value: payload.job.status, inline: true }
+          ],
+          footer: { text: "Nice2Dev Build Cloud" },
+          timestamp: new Date(payload.timestamp).toISOString()
         }
-    }
-    async sendWebhook(url, payload) {
-        // In production, use fetch
-        console.log(`Webhook to ${url}:`, JSON.stringify(payload));
-    }
-    async sendSlack(config, payload) {
-        const color = this.getStatusColor(payload.job.status);
-        const slackPayload = {
-            channel: config.channel,
-            username: config.username ?? 'Nice2Dev Build',
-            icon_emoji: config.iconEmoji ?? ':hammer:',
-            attachments: [
-                {
-                    color,
-                    title: `Build ${payload.event.replace('_', ' ').toUpperCase()}`,
-                    text: payload.message,
-                    fields: [
-                        { title: 'Job ID', value: payload.job.id, short: true },
-                        { title: 'Engine', value: payload.job.engine, short: true },
-                        { title: 'Platform', value: payload.job.platform, short: true },
-                        { title: 'Status', value: payload.job.status, short: true },
-                    ],
-                    footer: 'Nice2Dev Build Cloud',
-                    ts: Math.floor(payload.timestamp / 1000),
-                },
-            ],
-        };
-        console.log(`Slack webhook:`, JSON.stringify(slackPayload));
-    }
-    async sendDiscord(config, payload) {
-        const color = this.getStatusColorInt(payload.job.status);
-        const discordPayload = {
-            username: config.username ?? 'Nice2Dev Build',
-            avatar_url: config.avatarUrl,
-            embeds: [
-                {
-                    title: `Build ${payload.event.replace('_', ' ').toUpperCase()}`,
-                    description: payload.message,
-                    color,
-                    fields: [
-                        { name: 'Job ID', value: payload.job.id, inline: true },
-                        { name: 'Engine', value: payload.job.engine, inline: true },
-                        { name: 'Platform', value: payload.job.platform, inline: true },
-                        { name: 'Status', value: payload.job.status, inline: true },
-                    ],
-                    footer: { text: 'Nice2Dev Build Cloud' },
-                    timestamp: new Date(payload.timestamp).toISOString(),
-                },
-            ],
-        };
-        console.log(`Discord webhook:`, JSON.stringify(discordPayload));
-    }
-    async sendGitHubStatus(config, payload) {
-        const state = this.getGitHubState(payload.job.status);
-        const statusPayload = {
-            state,
-            target_url: payload.artifactUrl,
-            description: payload.message.slice(0, 140),
-            context: `Nice2Dev/${payload.job.engine}/${payload.job.platform}`,
-        };
-        console.log(`GitHub status for ${config.owner}/${config.repo}:`, JSON.stringify(statusPayload));
-    }
-    async sendGitLabStatus(config, payload) {
-        const state = this.getGitLabState(payload.job.status);
-        const statusPayload = {
-            state,
-            target_url: payload.artifactUrl,
-            description: payload.message.slice(0, 255),
-            name: `Nice2Dev/${payload.job.engine}/${payload.job.platform}`,
-        };
-        console.log(`GitLab status for project ${config.projectId}:`, JSON.stringify(statusPayload));
-    }
-    getStatusColor(status) {
-        const colors = {
-            completed: '#36a64f',
-            failed: '#d00000',
-            cancelled: '#808080',
-            running: '#2196f3',
-            queued: '#ffc107',
-        };
-        return colors[status] ?? '#808080';
-    }
-    getStatusColorInt(status) {
-        const colors = {
-            completed: 0x36a64f,
-            failed: 0xd00000,
-            cancelled: 0x808080,
-            running: 0x2196f3,
-            queued: 0xffc107,
-        };
-        return colors[status] ?? 0x808080;
-    }
-    getGitHubState(status) {
-        const states = {
-            completed: 'success',
-            failed: 'failure',
-            cancelled: 'error',
-            running: 'pending',
-            queued: 'pending',
-        };
-        return states[status] ?? 'pending';
-    }
-    getGitLabState(status) {
-        const states = {
-            completed: 'success',
-            failed: 'failed',
-            cancelled: 'canceled',
-            running: 'running',
-            queued: 'pending',
-        };
-        return states[status] ?? 'pending';
-    }
+      ]
+    };
+    console.log(`Discord webhook:`, JSON.stringify(discordPayload));
+  }
+  async sendGitHubStatus(config, payload) {
+    const state = this.getGitHubState(payload.job.status);
+    const statusPayload = {
+      state,
+      target_url: payload.artifactUrl,
+      description: payload.message.slice(0, 140),
+      context: `Nice2Dev/${payload.job.engine}/${payload.job.platform}`
+    };
+    console.log(`GitHub status for ${config.owner}/${config.repo}:`, JSON.stringify(statusPayload));
+  }
+  async sendGitLabStatus(config, payload) {
+    const state = this.getGitLabState(payload.job.status);
+    const statusPayload = {
+      state,
+      target_url: payload.artifactUrl,
+      description: payload.message.slice(0, 255),
+      name: `Nice2Dev/${payload.job.engine}/${payload.job.platform}`
+    };
+    console.log(`GitLab status for project ${config.projectId}:`, JSON.stringify(statusPayload));
+  }
+  getStatusColor(status) {
+    const colors = {
+      completed: "#36a64f",
+      failed: "#d00000",
+      cancelled: "#808080",
+      running: "#2196f3",
+      queued: "#ffc107"
+    };
+    return colors[status] ?? "#808080";
+  }
+  getStatusColorInt(status) {
+    const colors = {
+      completed: 3581519,
+      failed: 13631488,
+      cancelled: 8421504,
+      running: 2201331,
+      queued: 16761095
+    };
+    return colors[status] ?? 8421504;
+  }
+  getGitHubState(status) {
+    const states = {
+      completed: "success",
+      failed: "failure",
+      cancelled: "error",
+      running: "pending",
+      queued: "pending"
+    };
+    return states[status] ?? "pending";
+  }
+  getGitLabState(status) {
+    const states = {
+      completed: "success",
+      failed: "failed",
+      cancelled: "canceled",
+      running: "running",
+      queued: "pending"
+    };
+    return states[status] ?? "pending";
+  }
 }
 class BuildAnalytics {
-    constructor() {
-        this.buildHistory = [];
-        this.data = this.createEmptyData();
-    }
-    createEmptyData() {
-        return {
-            totalBuilds: 0,
-            successfulBuilds: 0,
-            failedBuilds: 0,
-            cancelledBuilds: 0,
-            successRate: 0,
-            avgBuildTime: 0,
-            avgWaitTime: 0,
-            totalBuildTime: 0,
-            buildsByEngine: { unity: 0, godot: 0, unreal: 0, nice2dev: 0 },
-            buildsByPlatform: {},
-            buildsByDay: {},
-            peakConcurrentBuilds: 0,
-            estimatedCost: 0,
-        };
-    }
-    recordBuild(jobId, engine, platform, status, waitTime, buildTime) {
-        const timestamp = Date.now();
-        const day = new Date(timestamp).toISOString().slice(0, 10);
-        this.buildHistory.push({
-            jobId,
-            engine,
-            platform,
-            status,
-            waitTime,
-            buildTime,
-            timestamp,
-        });
-        // Update counters
-        this.data.totalBuilds++;
-        if (status === 'completed') {
-            this.data.successfulBuilds++;
-        }
-        else if (status === 'failed') {
-            this.data.failedBuilds++;
-        }
-        else if (status === 'cancelled') {
-            this.data.cancelledBuilds++;
-        }
-        // Update rates
-        this.data.successRate = this.data.successfulBuilds / this.data.totalBuilds;
-        // Update times
-        this.data.totalBuildTime += buildTime;
-        this.data.avgBuildTime = this.data.totalBuildTime / this.data.totalBuilds;
-        const totalWaitTime = this.buildHistory.reduce((sum, b) => sum + b.waitTime, 0);
-        this.data.avgWaitTime = totalWaitTime / this.buildHistory.length;
-        // Update by engine
-        this.data.buildsByEngine[engine]++;
-        // Update by platform
-        this.data.buildsByPlatform[platform] = (this.data.buildsByPlatform[platform] ?? 0) + 1;
-        // Update by day
-        this.data.buildsByDay[day] = (this.data.buildsByDay[day] ?? 0) + 1;
-        // Update cost estimate (rough: $0.01 per minute)
-        this.data.estimatedCost += (buildTime / 60000) * 0.01;
-    }
-    updateConcurrentBuilds(count) {
-        if (count > this.data.peakConcurrentBuilds) {
-            this.data.peakConcurrentBuilds = count;
-        }
-    }
-    getData() {
-        return { ...this.data };
-    }
-    getDataForPeriod(startDate, endDate) {
-        const startTs = startDate.getTime();
-        const endTs = endDate.getTime();
-        const filteredBuilds = this.buildHistory.filter((b) => b.timestamp >= startTs && b.timestamp <= endTs);
-        const data = this.createEmptyData();
-        for (const build of filteredBuilds) {
-            const day = new Date(build.timestamp).toISOString().slice(0, 10);
-            data.totalBuilds++;
-            if (build.status === 'completed') {
-                data.successfulBuilds++;
-            }
-            else if (build.status === 'failed') {
-                data.failedBuilds++;
-            }
-            else if (build.status === 'cancelled') {
-                data.cancelledBuilds++;
-            }
-            data.totalBuildTime += build.buildTime;
-            data.buildsByEngine[build.engine]++;
-            data.buildsByPlatform[build.platform] = (data.buildsByPlatform[build.platform] ?? 0) + 1;
-            data.buildsByDay[day] = (data.buildsByDay[day] ?? 0) + 1;
-            data.estimatedCost += (build.buildTime / 60000) * 0.01;
-        }
-        if (data.totalBuilds > 0) {
-            data.successRate = data.successfulBuilds / data.totalBuilds;
-            data.avgBuildTime = data.totalBuildTime / data.totalBuilds;
-            data.avgWaitTime =
-                filteredBuilds.reduce((sum, b) => sum + b.waitTime, 0) / filteredBuilds.length;
-        }
-        return data;
-    }
-    getTopPlatforms(limit = 5) {
-        return Object.entries(this.data.buildsByPlatform)
-            .sort((a, b) => b[1] - a[1])
-            .slice(0, limit)
-            .map(([platform, count]) => ({ platform, count }));
-    }
-    getRecentBuilds(limit = 10) {
-        return this.buildHistory.slice(-limit).reverse();
-    }
-    clearHistory() {
-        this.buildHistory = [];
-        this.data = this.createEmptyData();
-    }
+  constructor() {
+    this.buildHistory = [];
+    this.data = this.createEmptyData();
+  }
+  createEmptyData() {
+    return {
+      totalBuilds: 0,
+      successfulBuilds: 0,
+      failedBuilds: 0,
+      cancelledBuilds: 0,
+      successRate: 0,
+      avgBuildTime: 0,
+      avgWaitTime: 0,
+      totalBuildTime: 0,
+      buildsByEngine: { unity: 0, godot: 0, unreal: 0, nice2dev: 0 },
+      buildsByPlatform: {},
+      buildsByDay: {},
+      peakConcurrentBuilds: 0,
+      estimatedCost: 0
+    };
+  }
+  recordBuild(jobId, engine, platform, status, waitTime, buildTime) {
+    const timestamp = Date.now();
+    const day = new Date(timestamp).toISOString().slice(0, 10);
+    this.buildHistory.push({
+      jobId,
+      engine,
+      platform,
+      status,
+      waitTime,
+      buildTime,
+      timestamp
+    });
+    this.data.totalBuilds++;
+    if (status === "completed") {
+      this.data.successfulBuilds++;
+    } else if (status === "failed") {
+      this.data.failedBuilds++;
+    } else if (status === "cancelled") {
+      this.data.cancelledBuilds++;
+    }
+    this.data.successRate = this.data.successfulBuilds / this.data.totalBuilds;
+    this.data.totalBuildTime += buildTime;
+    this.data.avgBuildTime = this.data.totalBuildTime / this.data.totalBuilds;
+    const totalWaitTime = this.buildHistory.reduce((sum, b) => sum + b.waitTime, 0);
+    this.data.avgWaitTime = totalWaitTime / this.buildHistory.length;
+    this.data.buildsByEngine[engine]++;
+    this.data.buildsByPlatform[platform] = (this.data.buildsByPlatform[platform] ?? 0) + 1;
+    this.data.buildsByDay[day] = (this.data.buildsByDay[day] ?? 0) + 1;
+    this.data.estimatedCost += buildTime / 6e4 * 0.01;
+  }
+  updateConcurrentBuilds(count) {
+    if (count > this.data.peakConcurrentBuilds) {
+      this.data.peakConcurrentBuilds = count;
+    }
+  }
+  getData() {
+    return { ...this.data };
+  }
+  getDataForPeriod(startDate, endDate) {
+    const startTs = startDate.getTime();
+    const endTs = endDate.getTime();
+    const filteredBuilds = this.buildHistory.filter(
+      (b) => b.timestamp >= startTs && b.timestamp <= endTs
+    );
+    const data = this.createEmptyData();
+    for (const build of filteredBuilds) {
+      const day = new Date(build.timestamp).toISOString().slice(0, 10);
+      data.totalBuilds++;
+      if (build.status === "completed") {
+        data.successfulBuilds++;
+      } else if (build.status === "failed") {
+        data.failedBuilds++;
+      } else if (build.status === "cancelled") {
+        data.cancelledBuilds++;
+      }
+      data.totalBuildTime += build.buildTime;
+      data.buildsByEngine[build.engine]++;
+      data.buildsByPlatform[build.platform] = (data.buildsByPlatform[build.platform] ?? 0) + 1;
+      data.buildsByDay[day] = (data.buildsByDay[day] ?? 0) + 1;
+      data.estimatedCost += build.buildTime / 6e4 * 0.01;
+    }
+    if (data.totalBuilds > 0) {
+      data.successRate = data.successfulBuilds / data.totalBuilds;
+      data.avgBuildTime = data.totalBuildTime / data.totalBuilds;
+      data.avgWaitTime = filteredBuilds.reduce((sum, b) => sum + b.waitTime, 0) / filteredBuilds.length;
+    }
+    return data;
+  }
+  getTopPlatforms(limit = 5) {
+    return Object.entries(this.data.buildsByPlatform).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([platform, count]) => ({ platform, count }));
+  }
+  getRecentBuilds(limit = 10) {
+    return this.buildHistory.slice(-limit).reverse();
+  }
+  clearHistory() {
+    this.buildHistory = [];
+    this.data = this.createEmptyData();
+  }
 }
-// ============================================================
-// Factory Functions
-// ============================================================
 function createBuildQueueManager() {
-    return new BuildQueueManager();
+  return new BuildQueueManager();
 }
 function createBuildAgentPool() {
-    return new BuildAgentPool();
+  return new BuildAgentPool();
 }
 function createArtifactStorage(config) {
-    return new ArtifactStorage(config);
+  return new ArtifactStorage(config);
 }
 function createBuildNotifications() {
-    return new BuildNotifications();
+  return new BuildNotifications();
 }
 function createBuildAnalytics() {
-    return new BuildAnalytics();
+  return new BuildAnalytics();
 }
 function createBuildOrchestrator(config) {
-    return new BuildOrchestrator(config?.queueManager ?? createBuildQueueManager(), config?.agentPool ?? createBuildAgentPool(), config?.storage ??
-        createArtifactStorage({
-            type: 'local',
-            bucket: 'builds',
-            retentionDays: 7,
-            maxArtifactSize: 5000000000,
-            signedUrls: true,
-            signedUrlExpiration: 3600,
-        }), config?.notifications ?? createBuildNotifications(), config?.analytics ?? createBuildAnalytics());
+  return new BuildOrchestrator(
+    config?.queueManager ?? createBuildQueueManager(),
+    config?.agentPool ?? createBuildAgentPool(),
+    config?.storage ?? createArtifactStorage({
+      type: "local",
+      bucket: "builds",
+      retentionDays: 7,
+      maxArtifactSize: 5e9,
+      signedUrls: true,
+      signedUrlExpiration: 3600
+    }),
+    config?.notifications ?? createBuildNotifications(),
+    config?.analytics ?? createBuildAnalytics()
+  );
 }
-// ============================================================
-// Build Orchestrator (combines all components)
-// ============================================================
 class BuildOrchestrator {
-    constructor(queueManager, agentPool, storage, notifications, analytics) {
-        this.queueManager = queueManager;
-        this.agentPool = agentPool;
-        this.storage = storage;
-        this.notifications = notifications;
-        this.analytics = analytics;
-        this.setupCallbacks();
-    }
-    setupCallbacks() {
-        // Wire up queue callbacks
-        this.queueManager.setCallbacks({
-            onJobQueued: (job) => {
-                this.notifications.notify({
-                    event: 'build_queued',
-                    timestamp: Date.now(),
-                    job: {
-                        id: job.id,
-                        userId: job.userId,
-                        engine: job.engine,
-                        platform: job.platform,
-                        status: job.status,
-                    },
-                    message: `Build ${job.id} queued for ${job.engine}/${job.platform}`,
-                });
-            },
-            onJobStarted: (job) => {
-                this.notifications.notify({
-                    event: 'build_started',
-                    timestamp: Date.now(),
-                    job: {
-                        id: job.id,
-                        userId: job.userId,
-                        engine: job.engine,
-                        platform: job.platform,
-                        status: job.status,
-                    },
-                    message: `Build ${job.id} started`,
-                });
-                this.analytics.updateConcurrentBuilds(this.queueManager.getJobsByStatus('running').length);
-            },
-            onJobCompleted: (job) => {
-                const waitTime = job.startedAt - job.createdAt;
-                const buildTime = job.completedAt - job.startedAt;
-                this.analytics.recordBuild(job.id, job.engine, job.platform, job.status, waitTime, buildTime);
-                this.notifications.notify({
-                    event: 'build_completed',
-                    timestamp: Date.now(),
-                    job: {
-                        id: job.id,
-                        userId: job.userId,
-                        engine: job.engine,
-                        platform: job.platform,
-                        status: job.status,
-                    },
-                    message: `Build ${job.id} completed successfully`,
-                    artifactUrl: job.artifacts?.[0]?.downloadUrl,
-                });
-            },
-            onJobFailed: (job, error) => {
-                const waitTime = job.startedAt ? job.startedAt - job.createdAt : 0;
-                const buildTime = job.completedAt && job.startedAt ? job.completedAt - job.startedAt : 0;
-                this.analytics.recordBuild(job.id, job.engine, job.platform, job.status, waitTime, buildTime);
-                this.notifications.notify({
-                    event: 'build_failed',
-                    timestamp: Date.now(),
-                    job: {
-                        id: job.id,
-                        userId: job.userId,
-                        engine: job.engine,
-                        platform: job.platform,
-                        status: job.status,
-                    },
-                    message: `Build ${job.id} failed: ${error}`,
-                    details: { error },
-                });
-            },
+  constructor(queueManager, agentPool, storage, notifications, analytics) {
+    this.queueManager = queueManager;
+    this.agentPool = agentPool;
+    this.storage = storage;
+    this.notifications = notifications;
+    this.analytics = analytics;
+    this.setupCallbacks();
+  }
+  setupCallbacks() {
+    this.queueManager.setCallbacks({
+      onJobQueued: (job) => {
+        this.notifications.notify({
+          event: "build_queued",
+          timestamp: Date.now(),
+          job: {
+            id: job.id,
+            userId: job.userId,
+            engine: job.engine,
+            platform: job.platform,
+            status: job.status
+          },
+          message: `Build ${job.id} queued for ${job.engine}/${job.platform}`
         });
-    }
-    async submitBuild(engine, platform, buildConfig, options) {
-        return this.queueManager.submitJob(engine, platform, buildConfig, options);
-    }
-    getStats() {
-        return {
-            queues: this.queueManager.getAllQueueStats(),
-            pools: this.agentPool.getAllPoolStats(),
-            storage: this.storage.getStorageStats(),
-            analytics: this.analytics.getData(),
-        };
-    }
+      },
+      onJobStarted: (job) => {
+        this.notifications.notify({
+          event: "build_started",
+          timestamp: Date.now(),
+          job: {
+            id: job.id,
+            userId: job.userId,
+            engine: job.engine,
+            platform: job.platform,
+            status: job.status
+          },
+          message: `Build ${job.id} started`
+        });
+        this.analytics.updateConcurrentBuilds(this.queueManager.getJobsByStatus("running").length);
+      },
+      onJobCompleted: (job) => {
+        const waitTime = job.startedAt - job.createdAt;
+        const buildTime = job.completedAt - job.startedAt;
+        this.analytics.recordBuild(
+          job.id,
+          job.engine,
+          job.platform,
+          job.status,
+          waitTime,
+          buildTime
+        );
+        this.notifications.notify({
+          event: "build_completed",
+          timestamp: Date.now(),
+          job: {
+            id: job.id,
+            userId: job.userId,
+            engine: job.engine,
+            platform: job.platform,
+            status: job.status
+          },
+          message: `Build ${job.id} completed successfully`,
+          artifactUrl: job.artifacts?.[0]?.downloadUrl
+        });
+      },
+      onJobFailed: (job, error) => {
+        const waitTime = job.startedAt ? job.startedAt - job.createdAt : 0;
+        const buildTime = job.completedAt && job.startedAt ? job.completedAt - job.startedAt : 0;
+        this.analytics.recordBuild(
+          job.id,
+          job.engine,
+          job.platform,
+          job.status,
+          waitTime,
+          buildTime
+        );
+        this.notifications.notify({
+          event: "build_failed",
+          timestamp: Date.now(),
+          job: {
+            id: job.id,
+            userId: job.userId,
+            engine: job.engine,
+            platform: job.platform,
+            status: job.status
+          },
+          message: `Build ${job.id} failed: ${error}`,
+          details: { error }
+        });
+      }
+    });
+  }
+  async submitBuild(engine, platform, buildConfig, options) {
+    return this.queueManager.submitJob(engine, platform, buildConfig, options);
+  }
+  getStats() {
+    return {
+      queues: this.queueManager.getAllQueueStats(),
+      pools: this.agentPool.getAllPoolStats(),
+      storage: this.storage.getStorageStats(),
+      analytics: this.analytics.getData()
+    };
+  }
 }
-
 exports.ArtifactStorage = ArtifactStorage;
 exports.BuildAgentPool = BuildAgentPool;
 exports.BuildAnalytics = BuildAnalytics;