@jadenrazo/cloudcost-mcp 0.1.9 → 0.3.0

package/dist/index.js

@@ -1,4294 +1,33 @@
 #!/usr/bin/env node
 import {
-  getAwsInstances,
-  getAzureVmSizes,
-  getGcpComputePricing,
-  getGcpDiskPricing,
-  getGcpMachineTypes,
-  getGcpSqlPricing,
-  getGcpStoragePricing,
-  getInstanceMap,
-  getRegionMappings,
-  getResourceEquivalents,
-  getStorageMap
-} from "./chunk-KZJSZMWM.js";
-
-// src/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-// src/config.ts
-import { readFileSync, existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-
-// src/types/config.ts
-var DEFAULT_CONFIG = {
-  cache: {
-    ttl_seconds: 86400,
-    db_path: ""
-  },
-  pricing: {
-    monthly_hours: 730,
-    default_currency: "USD",
-    aws_pricing_region: "us-east-1"
-  },
-  logging: {
-    level: "info"
-  }
-};
-
-// src/config.ts
-function getConfigDir() {
-  return join(homedir(), ".cloudcost");
-}
-function loadFileConfig() {
-  const configPath = join(getConfigDir(), "config.json");
-  if (!existsSync(configPath)) return {};
-  try {
-    return JSON.parse(readFileSync(configPath, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function loadEnvConfig() {
-  const config = {};
-  const env = process.env;
-  if (env.CLOUDCOST_CACHE_TTL || env.CLOUDCOST_CACHE_PATH) {
-    config.cache = {
-      ttl_seconds: env.CLOUDCOST_CACHE_TTL ? parseInt(env.CLOUDCOST_CACHE_TTL, 10) : DEFAULT_CONFIG.cache.ttl_seconds,
-      db_path: env.CLOUDCOST_CACHE_PATH ?? ""
-    };
-  }
-  if (env.CLOUDCOST_LOG_LEVEL) {
-    config.logging = {
-      level: env.CLOUDCOST_LOG_LEVEL
-    };
-  }
-  if (env.CLOUDCOST_MONTHLY_HOURS) {
-    config.pricing = {
-      ...DEFAULT_CONFIG.pricing,
-      monthly_hours: parseInt(env.CLOUDCOST_MONTHLY_HOURS, 10)
-    };
-  }
-  return config;
-}
-function loadConfig() {
-  const fileConfig = loadFileConfig();
-  const envConfig = loadEnvConfig();
-  const defaultDbPath = join(getConfigDir(), "cache.db");
-  return {
-    cache: {
-      ...DEFAULT_CONFIG.cache,
-      db_path: defaultDbPath,
-      ...fileConfig.cache,
-      ...envConfig.cache
-    },
-    pricing: {
-      ...DEFAULT_CONFIG.pricing,
-      ...fileConfig.pricing,
-      ...envConfig.pricing
-    },
-    logging: {
-      ...DEFAULT_CONFIG.logging,
-      ...fileConfig.logging,
-      ...envConfig.logging
-    }
-  };
-}
-
-// src/logger.ts
-var LEVEL_ORDER = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3
-};
-var currentLevel = "info";
-function setLogLevel(level) {
-  currentLevel = level;
-}
-function shouldLog(level) {
-  return LEVEL_ORDER[level] >= LEVEL_ORDER[currentLevel];
-}
-function log(level, message, data) {
-  if (!shouldLog(level)) return;
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const entry = data ? `[${timestamp}] ${level.toUpperCase()}: ${message} ${JSON.stringify(data)}` : `[${timestamp}] ${level.toUpperCase()}: ${message}`;
-  process.stderr.write(entry + "\n");
-}
-var logger = {
-  debug: (msg, data) => log("debug", msg, data),
-  info: (msg, data) => log("info", msg, data),
-  warn: (msg, data) => log("warn", msg, data),
-  error: (msg, data) => log("error", msg, data)
-};
-
-// src/pricing/cache.ts
-import Database from "better-sqlite3";
-import { mkdirSync } from "fs";
-import { dirname } from "path";
-var SCHEMA = `
-  CREATE TABLE IF NOT EXISTS pricing_cache (
-    key        TEXT PRIMARY KEY,
-    data       TEXT NOT NULL,
-    provider   TEXT NOT NULL,
-    service    TEXT NOT NULL,
-    region     TEXT NOT NULL,
-    created_at TEXT NOT NULL,
-    expires_at TEXT NOT NULL
-  );
-  CREATE INDEX IF NOT EXISTS idx_pricing_cache_provider   ON pricing_cache (provider);
-  CREATE INDEX IF NOT EXISTS idx_pricing_cache_expires_at ON pricing_cache (expires_at);
-`;
-var PricingCache = class {
-  db;
-  constructor(dbPath) {
-    mkdirSync(dirname(dbPath), { recursive: true });
-    this.db = new Database(dbPath);
-    this.db.pragma("journal_mode = WAL");
-    this.db.pragma("foreign_keys = ON");
-    this.db.exec(SCHEMA);
-    logger.debug("PricingCache initialised", { dbPath });
-  }
-  /**
-   * Retrieve a cached value by key. Returns null when the entry does not exist
-   * or has already expired; expired rows are deleted as a side-effect so the
-   * table self-trims on read.
-   */
-  get(key) {
-    const row = this.db.prepare(
-      "SELECT * FROM pricing_cache WHERE key = ?"
-    ).get(key);
-    if (!row) return null;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    if (row.expires_at <= now) {
-      this.db.prepare("DELETE FROM pricing_cache WHERE key = ?").run(key);
-      logger.debug("Cache miss (expired)", { key });
-      return null;
-    }
-    logger.debug("Cache hit", { key });
-    return JSON.parse(row.data);
-  }
-  /**
-   * Store a value in the cache.
-   *
-   * The composite key convention for pricing lookups is:
-   *   `{provider}/{service}/{region}/{resource_type}`
-   *
-   * Callers are responsible for constructing the key before calling this
-   * method; the method itself treats the key as an opaque string so it can
-   * be reused for other cache domains in the future.
-   */
-  set(key, data, provider, service, region, ttlSeconds) {
-    const now = /* @__PURE__ */ new Date();
-    const expiresAt = new Date(now.getTime() + ttlSeconds * 1e3);
-    this.db.prepare(
-      `INSERT INTO pricing_cache (key, data, provider, service, region, created_at, expires_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?)
-         ON CONFLICT (key) DO UPDATE SET
-           data       = excluded.data,
-           provider   = excluded.provider,
-           service    = excluded.service,
-           region     = excluded.region,
-           created_at = excluded.created_at,
-           expires_at = excluded.expires_at`
-    ).run(
-      key,
-      JSON.stringify(data),
-      provider,
-      service,
-      region,
-      now.toISOString(),
-      expiresAt.toISOString()
-    );
-    logger.debug("Cache set", { key, ttlSeconds });
-  }
-  /** Remove a single cache entry. */
-  invalidate(key) {
-    const result = this.db.prepare("DELETE FROM pricing_cache WHERE key = ?").run(key);
-    logger.debug("Cache invalidated", { key, removed: result.changes });
-  }
-  /** Remove every cache entry belonging to a provider. */
-  invalidateByProvider(provider) {
-    const result = this.db.prepare("DELETE FROM pricing_cache WHERE provider = ?").run(provider);
-    logger.debug("Cache invalidated by provider", {
-      provider,
-      removed: result.changes
-    });
-  }
-  /**
-   * Delete all entries whose expiry timestamp is in the past.
-   * Returns the number of rows removed.
-   */
-  cleanup() {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const result = this.db.prepare("DELETE FROM pricing_cache WHERE expires_at <= ?").run(now);
-    const removed = result.changes;
-    logger.debug("Cache cleanup complete", { removed });
-    return removed;
-  }
-  /** Return aggregate statistics about the current cache state. */
-  getStats() {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const totals = this.db.prepare(
-      `SELECT
-           COUNT(*)                        AS total_entries,
-           COALESCE(SUM(LENGTH(data)), 0)  AS size_bytes
-         FROM pricing_cache`
-    ).get();
-    const expired = this.db.prepare(
-      "SELECT COUNT(*) AS expired_entries FROM pricing_cache WHERE expires_at <= ?"
-    ).get(now);
-    return {
-      total_entries: totals.total_entries,
-      expired_entries: expired.expired_entries,
-      size_bytes: totals.size_bytes
-    };
-  }
-  /** Close the underlying database connection. */
-  close() {
-    this.db.close();
-    logger.debug("PricingCache closed");
-  }
-};
-
-// src/pricing/aws/aws-normalizer.ts
-function extractUsdPrice(priceDimensions) {
-  for (const dim of Object.values(priceDimensions)) {
-    const usd = dim?.pricePerUnit?.USD;
-    if (usd !== void 0) {
-      const val = parseFloat(usd);
-      if (!isNaN(val)) return val;
-    }
-  }
-  return 0;
-}
-function extractUnit(priceDimensions) {
-  for (const dim of Object.values(priceDimensions)) {
-    if (dim?.unit) return String(dim.unit);
-  }
-  return "Hrs";
-}
-function extractFromTerms(onDemandTerms, defaultUnit) {
-  for (const skuTerms of Object.values(onDemandTerms)) {
-    if (skuTerms?.priceDimensions) {
-      return {
-        price: extractUsdPrice(skuTerms.priceDimensions),
-        unit: extractUnit(skuTerms.priceDimensions)
-      };
-    }
-    for (const offerTerm of Object.values(skuTerms ?? {})) {
-      const dims = offerTerm?.priceDimensions;
-      if (dims) {
-        return {
-          price: extractUsdPrice(dims),
-          unit: extractUnit(dims)
-        };
-      }
-    }
-  }
-  return { price: 0, unit: defaultUnit };
-}
-function normalizeAwsCompute(rawProduct, rawPrice, region) {
-  const attrs = rawProduct?.attributes ?? {};
-  const terms = rawPrice?.terms?.OnDemand ?? {};
-  const { price, unit } = extractFromTerms(terms, "Hrs");
-  return {
-    provider: "aws",
-    service: "ec2",
-    resource_type: attrs.instanceType ?? "unknown",
-    region,
-    unit,
-    price_per_unit: price,
-    currency: "USD",
-    description: attrs.instanceType ? `AWS EC2 ${attrs.instanceType} (${attrs.operatingSystem ?? "Linux"})` : void 0,
-    attributes: {
-      instance_type: attrs.instanceType ?? "",
-      vcpu: attrs.vcpu ?? "",
-      memory: attrs.memory ?? "",
-      operating_system: attrs.operatingSystem ?? "Linux",
-      tenancy: attrs.tenancy ?? "Shared",
-      pricing_source: "live"
-    },
-    effective_date: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function normalizeAwsDatabase(rawProduct, rawPrice, region) {
-  const attrs = rawProduct?.attributes ?? {};
-  const terms = rawPrice?.terms?.OnDemand ?? {};
-  const { price, unit } = extractFromTerms(terms, "Hrs");
-  return {
-    provider: "aws",
-    service: "rds",
-    resource_type: attrs.instanceType ?? "unknown",
-    region,
-    unit,
-    price_per_unit: price,
-    currency: "USD",
-    description: attrs.instanceType ? `AWS RDS ${attrs.instanceType} (${attrs.databaseEngine ?? "MySQL"})` : void 0,
-    attributes: {
-      instance_type: attrs.instanceType ?? "",
-      database_engine: attrs.databaseEngine ?? "",
-      deployment_option: attrs.deploymentOption ?? "Single-AZ",
-      vcpu: attrs.vcpu ?? "",
-      memory: attrs.memory ?? "",
-      pricing_source: "live"
-    },
-    effective_date: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function normalizeAwsStorage(rawProduct, rawPrice, region) {
-  const attrs = rawProduct?.attributes ?? {};
-  const terms = rawPrice?.terms?.OnDemand ?? {};
-  const { price, unit } = extractFromTerms(terms, "GB-Mo");
-  const volumeType = attrs.volumeApiName ?? attrs.volumeType ?? "gp3";
-  return {
-    provider: "aws",
-    service: "ebs",
-    resource_type: volumeType,
-    region,
-    unit,
-    price_per_unit: price,
-    currency: "USD",
-    description: `AWS EBS ${volumeType} volume`,
-    attributes: {
-      volume_type: volumeType,
-      max_iops: attrs.maxIopsvolume ?? "",
-      max_throughput: attrs.maxThroughputvolume ?? "",
-      pricing_source: "live"
-    },
-    effective_date: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-
-// src/pricing/aws/bulk-loader.ts
-function parseCsvLine(line) {
-  const fields = [];
-  let i = 0;
-  const len = line.length;
-  while (i <= len) {
-    if (i === len) {
-      if (fields.length > 0 && line[len - 1] === ",") {
-        fields.push("");
-      }
-      break;
-    }
-    if (line[i] === '"') {
-      i++;
-      let field = "";
-      while (i < len) {
-        if (line[i] === '"') {
-          if (i + 1 < len && line[i + 1] === '"') {
-            field += '"';
-            i += 2;
-          } else {
-            i++;
-            break;
-          }
-        } else {
-          field += line[i];
-          i++;
-        }
-      }
-      fields.push(field);
-      if (i < len && line[i] === ",") i++;
-    } else {
-      const start = i;
-      while (i < len && line[i] !== ",") i++;
-      fields.push(line.slice(start, i));
-      if (i < len) i++;
-    }
-  }
-  return fields;
-}
-var EC2_BASE_PRICES = {
-  "t2.micro": 0.0116,
-  "t2.small": 0.023,
-  "t2.medium": 0.0464,
-  "t2.large": 0.0928,
-  "t3.micro": 0.0104,
-  "t3.small": 0.0208,
-  "t3.medium": 0.0416,
-  "t3.large": 0.0832,
-  "t3.xlarge": 0.1664,
-  "t3.2xlarge": 0.3328,
-  "t3a.micro": 94e-4,
-  "t3a.small": 0.0188,
-  "t3a.medium": 0.0376,
-  "t3a.large": 0.0752,
-  "t3a.xlarge": 0.1504,
-  "t4g.micro": 84e-4,
-  "t4g.small": 0.0168,
-  "t4g.medium": 0.0336,
-  "t4g.large": 0.0672,
-  "t4g.xlarge": 0.1344,
-  "m5.large": 0.096,
-  "m5.xlarge": 0.192,
-  "m5.2xlarge": 0.384,
-  "m5.4xlarge": 0.768,
-  "m5a.large": 0.086,
-  "m5a.xlarge": 0.172,
-  "m5a.2xlarge": 0.344,
-  "m5a.4xlarge": 0.688,
-  "m6i.large": 0.096,
-  "m6i.xlarge": 0.192,
-  "m6i.2xlarge": 0.384,
-  "m6i.4xlarge": 0.768,
-  "m6i.8xlarge": 1.536,
-  "m6g.large": 0.077,
-  "m6g.xlarge": 0.154,
-  "m6g.2xlarge": 0.308,
-  "m6g.4xlarge": 0.616,
-  "m7i.large": 0.1008,
-  "m7i.xlarge": 0.2016,
-  "m7i.2xlarge": 0.4032,
-  "m7g.large": 0.0816,
-  "m7g.xlarge": 0.1632,
-  "m7g.2xlarge": 0.3264,
-  "m7g.4xlarge": 0.6528,
-  "c5.large": 0.085,
-  "c5.xlarge": 0.17,
-  "c5.2xlarge": 0.34,
-  "c5a.large": 0.077,
-  "c5a.xlarge": 0.154,
-  "c5a.2xlarge": 0.308,
-  "c6i.large": 0.085,
-  "c6i.xlarge": 0.17,
-  "c6i.2xlarge": 0.34,
-  "c6g.large": 0.068,
-  "c6g.xlarge": 0.136,
-  "c6g.2xlarge": 0.272,
-  "c6g.4xlarge": 0.544,
-  "c7i.large": 0.089,
-  "c7i.xlarge": 0.178,
-  "c7i.2xlarge": 0.357,
-  "c7g.large": 0.072,
-  "c7g.xlarge": 0.145,
-  "c7g.2xlarge": 0.29,
-  "c7g.4xlarge": 0.58,
-  "r5.large": 0.126,
-  "r5.xlarge": 0.252,
-  "r5.2xlarge": 0.504,
-  "r5a.large": 0.113,
-  "r5a.xlarge": 0.226,
-  "r5a.2xlarge": 0.452,
-  "r6i.large": 0.126,
-  "r6i.xlarge": 0.252,
-  "r6i.2xlarge": 0.504,
-  "r6g.large": 0.101,
-  "r6g.xlarge": 0.202,
-  "r6g.2xlarge": 0.403,
-  "r6g.4xlarge": 0.806,
-  "r7i.large": 0.133,
-  "r7i.xlarge": 0.266,
-  "r7i.2xlarge": 0.532,
-  "r7g.large": 0.107,
-  "r7g.xlarge": 0.214,
-  "r7g.2xlarge": 0.428,
-  "r7g.4xlarge": 0.856
-};
-var RDS_BASE_PRICES = {
-  "db.t3.micro": 0.017,
-  "db.t3.small": 0.034,
-  "db.t3.medium": 0.068,
-  "db.t3.large": 0.136,
-  "db.t4g.micro": 0.016,
-  "db.t4g.small": 0.032,
-  "db.t4g.medium": 0.065,
-  "db.t4g.large": 0.129,
-  "db.t4g.xlarge": 0.258,
-  "db.m5.large": 0.171,
-  "db.m5.xlarge": 0.342,
-  "db.m6g.large": 0.154,
-  "db.m6g.xlarge": 0.308,
-  "db.m6g.2xlarge": 0.616,
-  "db.m6i.large": 0.171,
-  "db.m6i.xlarge": 0.342,
-  "db.m6i.2xlarge": 0.684,
-  "db.m7g.large": 0.168,
-  "db.m7g.xlarge": 0.336,
-  "db.m7g.2xlarge": 0.672,
-  "db.r5.large": 0.25,
-  "db.r5.xlarge": 0.5,
-  "db.r5.2xlarge": 1,
-  "db.r6g.large": 0.218,
-  "db.r6g.xlarge": 0.437,
-  "db.r6g.2xlarge": 0.874,
-  "db.r6i.large": 0.25,
-  "db.r6i.xlarge": 0.5,
-  "db.r6i.2xlarge": 1
-};
-var EBS_BASE_PRICES = {
-  "gp3": 0.08,
-  "gp2": 0.1,
-  "io2": 0.125,
-  "io1": 0.125,
-  "st1": 0.045,
-  "sc1": 0.015
-};
-var ALB_HOURLY = 0.0225;
-var ALB_LCU_HOURLY = 8e-3;
-var NAT_HOURLY = 0.045;
-var NAT_PER_GB = 0.045;
-var EKS_HOURLY = 0.1;
-var REGION_MULTIPLIERS = {
-  "us-east-1": 1,
-  "us-east-2": 1,
-  "us-west-1": 1.08,
-  "us-west-2": 1,
-  "eu-west-1": 1.1,
-  "eu-west-2": 1.12,
-  "eu-central-1": 1.12,
-  "ap-southeast-1": 1.15,
-  "ap-southeast-2": 1.15,
-  "ap-northeast-1": 1.12,
-  "ap-northeast-2": 1.1,
-  "ap-south-1": 1.08,
-  "sa-east-1": 1.2,
-  "ca-central-1": 1.08,
-  "eu-north-1": 1.1,
-  "eu-south-1": 1.12,
-  "me-south-1": 1.15,
-  "af-south-1": 1.22
-};
-function regionMultiplier(region) {
-  return REGION_MULTIPLIERS[region.toLowerCase()] ?? 1;
-}
-var CACHE_TTL = 86400;
-var BULK_PRICING_BASE = "https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws";
-var AwsBulkLoader = class _AwsBulkLoader {
-  cache;
-  /**
-   * Deduplicates concurrent streaming CSV fetches for the same region.
-   * Keyed by region; value is the in-flight Promise<boolean>.
-   */
-  ec2CsvFetchInProgress = /* @__PURE__ */ new Map();
-  constructor(cache) {
-    this.cache = cache;
-  }
-  // -------------------------------------------------------------------------
-  // Public API
-  // -------------------------------------------------------------------------
-  async getComputePrice(instanceType, region, os = "Linux") {
-    const cacheKey = this.buildCacheKey("ec2", region, instanceType, os);
-    const cached = this.cache.get(cacheKey);
-    if (cached) return cached;
-    try {
-      const csvOk = await this.fetchAndCacheEc2CsvPrices(region);
-      if (csvOk) {
-        const afterCsv = this.cache.get(cacheKey);
-        if (afterCsv) return afterCsv;
-      }
-    } catch (err) {
-      logger.warn("AWS EC2 CSV streaming failed", {
-        region,
-        instanceType,
-        err: err instanceof Error ? err.message : String(err)
-      });
-    }
-    try {
-      const bulk = await this.fetchBulkPricing("AmazonEC2", region);
-      if (bulk) {
-        const result = this.extractEc2Price(bulk, instanceType, region, os);
-        if (result) {
-          this.cache.set(cacheKey, result, "aws", "ec2", region, CACHE_TTL);
-          return result;
-        }
-      }
-    } catch (err) {
-      logger.warn("AWS bulk EC2 JSON fetch failed, using fallback", {
-        region,
-        instanceType,
-        err: err instanceof Error ? err.message : String(err)
-      });
-    }
-    return this.fallbackComputePrice(instanceType, region, os, cacheKey);
-  }
-  async getDatabasePrice(instanceClass, region, engine = "MySQL") {
-    const cacheKey = this.buildCacheKey("rds", region, instanceClass, engine);
-    const cached = this.cache.get(cacheKey);
-    if (cached) return cached;
-    try {
-      const bulk = await this.fetchBulkPricing("AmazonRDS", region);
-      if (bulk) {
-        const result = this.extractRdsPrice(bulk, instanceClass, region, engine);
-        if (result) {
-          this.cache.set(cacheKey, result, "aws", "rds", region, CACHE_TTL);
-          return result;
-        }
-      }
-    } catch (err) {
-      logger.warn("AWS bulk RDS fetch failed, using fallback", {
-        region,
-        instanceClass,
-        err: err instanceof Error ? err.message : String(err)
-      });
-    }
-    return this.fallbackDatabasePrice(instanceClass, region, engine, cacheKey);
-  }
-  async getStoragePrice(volumeType, region) {
-    const cacheKey = this.buildCacheKey("ebs", region, volumeType);
-    const cached = this.cache.get(cacheKey);
-    if (cached) return cached;
-    try {
-      const bulk = await this.fetchBulkPricing("AmazonEC2", region);
-      if (bulk) {
-        const result = this.extractEbsPrice(bulk, volumeType, region);
-        if (result) {
-          this.cache.set(cacheKey, result, "aws", "ebs", region, CACHE_TTL);
-          return result;
-        }
-      }
-    } catch (err) {
-      logger.warn("AWS bulk EBS fetch failed, using fallback", {
-        region,
-        volumeType,
-        err: err instanceof Error ? err.message : String(err)
-      });
-    }
-    return this.fallbackStoragePrice(volumeType, region, cacheKey);
-  }
-  async getLoadBalancerPrice(region) {
-    const multiplier = regionMultiplier(region);
-    return {
-      provider: "aws",
-      service: "elb",
-      resource_type: "alb",
-      region,
-      unit: "Hrs",
-      price_per_unit: ALB_HOURLY * multiplier,
-      currency: "USD",
-      description: "AWS Application Load Balancer (hourly fixed charge)",
-      attributes: {
-        lcu_hourly_price: String(ALB_LCU_HOURLY * multiplier),
-        pricing_model: "fixed_plus_lcu"
-      },
-      effective_date: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  async getNatGatewayPrice(region) {
-    const multiplier = regionMultiplier(region);
-    return {
-      provider: "aws",
-      service: "vpc",
-      resource_type: "nat-gateway",
-      region,
-      unit: "Hrs",
-      price_per_unit: NAT_HOURLY * multiplier,
-      currency: "USD",
-      description: "AWS NAT Gateway (hourly charge + data processing)",
-      attributes: {
-        per_gb_price: String(NAT_PER_GB * multiplier)
-      },
-      effective_date: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  async getKubernetesPrice(region) {
-    const multiplier = regionMultiplier(region);
-    return {
-      provider: "aws",
-      service: "eks",
-      resource_type: "cluster",
-      region,
-      unit: "Hrs",
-      price_per_unit: EKS_HOURLY * multiplier,
-      currency: "USD",
-      description: "AWS EKS control plane (per cluster/hour)",
-      attributes: {},
-      effective_date: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  // -------------------------------------------------------------------------
-  // Internal helpers – EC2 CSV streaming
-  // -------------------------------------------------------------------------
-  /**
-   * Fetch the per-region EC2 pricing CSV from the AWS Bulk Pricing endpoint,
-   * stream it line-by-line, parse every "Compute Instance / OnDemand / Shared"
-   * row for ALL operating systems, and write each extracted price into the
-   * SQLite cache.
-   *
-   * The CSV URL pattern is:
-   *   https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/AmazonEC2/current/{region}/index.csv
-   *
-   * The first ~5 rows of the file are metadata (FormatVersion, Disclaimer,
-   * Publication Date, etc.).  The actual header row is the first row whose
-   * first field is "SKU".
-   *
-   * Returns true when at least one price was extracted and cached.
-   */
-  fetchAndCacheEc2CsvPrices(region) {
-    const inflight = this.ec2CsvFetchInProgress.get(region);
-    if (inflight) return inflight;
-    const promise = this._doFetchAndCacheEc2CsvPrices(region).finally(() => {
-      this.ec2CsvFetchInProgress.delete(region);
-    });
-    this.ec2CsvFetchInProgress.set(region, promise);
-    return promise;
-  }
-  async _doFetchAndCacheEc2CsvPrices(region) {
-    const url = `${BULK_PRICING_BASE}/AmazonEC2/current/${region}/index.csv`;
-    logger.debug("Streaming AWS EC2 CSV pricing", { url, region });
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 12e4);
-    try {
-      const res = await fetch(url, { signal: controller.signal });
-      if (!res.ok) {
-        logger.debug("AWS EC2 CSV fetch returned non-OK status", {
-          region,
-          status: res.status
-        });
-        return false;
-      }
-      if (!res.body) {
-        logger.debug("AWS EC2 CSV response has no body", { region });
-        return false;
-      }
-      const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();
-      let colInstanceType = -1;
-      let colOS = -1;
-      let colTenancy = -1;
-      let colTermType = -1;
-      let colCapacityStatus = -1;
-      let colProductFamily = -1;
-      let colPrice = -1;
-      let colUnit = -1;
-      let headerFound = false;
-      let leftover = "";
-      let cachedCount = 0;
-      const effectiveDate = (/* @__PURE__ */ new Date()).toISOString();
-      while (true) {
-        const { value, done } = await reader.read();
-        if (done) break;
-        const chunk = leftover + value;
-        const lines = chunk.split("\n");
-        leftover = lines.pop() ?? "";
-        for (const rawLine of lines) {
-          const line = rawLine.trimEnd();
-          if (!line) continue;
-          if (!headerFound) {
-            if (line.startsWith('"SKU"') || line.startsWith("SKU")) {
-              const headers = parseCsvLine(line);
-              for (let h = 0; h < headers.length; h++) {
-                const name = headers[h].trim();
-                if (name === "Instance Type") colInstanceType = h;
-                else if (name === "Operating System") colOS = h;
-                else if (name === "Tenancy") colTenancy = h;
-                else if (name === "TermType") colTermType = h;
-                else if (name === "Capacity Status") colCapacityStatus = h;
-                else if (name === "Product Family") colProductFamily = h;
-                else if (name === "PricePerUnit" || name === "Price Per Unit") colPrice = h;
-                else if (name === "Unit") colUnit = h;
-              }
-              if (colInstanceType === -1 || colOS === -1 || colPrice === -1) {
-                logger.debug("AWS EC2 CSV header missing required columns", {
-                  region,
-                  colInstanceType,
-                  colOS,
-                  colPrice
-                });
-                return false;
-              }
-              headerFound = true;
-            }
-            continue;
-          }
-          if (!line.includes("OnDemand") || !line.includes("Compute Instance")) {
-            continue;
-          }
-          const fields = parseCsvLine(line);
-          if (colProductFamily !== -1) {
-            const pf = fields[colProductFamily] ?? "";
-            if (pf !== "Compute Instance") continue;
-          }
-          if (colTenancy !== -1) {
-            const tenancy = fields[colTenancy] ?? "";
-            if (tenancy !== "Shared") continue;
-          }
-          if (colTermType !== -1) {
-            const termType = fields[colTermType] ?? "";
-            if (termType !== "OnDemand") continue;
-          }
-          if (colCapacityStatus !== -1) {
-            const cap = fields[colCapacityStatus] ?? "";
-            if (cap !== "Used") continue;
-          }
-          const instanceType = fields[colInstanceType] ?? "";
-          const os = fields[colOS] ?? "";
-          const rawPrice = fields[colPrice] ?? "";
-          const unit = colUnit !== -1 ? fields[colUnit] ?? "Hrs" : "Hrs";
-          if (!instanceType || !os || !rawPrice) continue;
-          const priceValue = parseFloat(rawPrice);
-          if (!isFinite(priceValue) || priceValue <= 0) continue;
-          const csvCacheKey = `aws/ec2/${region}/${instanceType.toLowerCase()}/${os.toLowerCase()}`;
-          const normalized = {
-            provider: "aws",
-            service: "ec2",
-            resource_type: instanceType,
-            region,
-            unit,
-            price_per_unit: priceValue,
-            currency: "USD",
-            description: `AWS EC2 ${instanceType} (${os}) on-demand`,
-            attributes: {
-              instance_type: instanceType,
-              operating_system: os,
-              tenancy: "Shared",
-              pricing_source: "live"
-            },
-            effective_date: effectiveDate
-          };
-          this.cache.set(csvCacheKey, normalized, "aws", "ec2", region, CACHE_TTL);
-          cachedCount++;
-        }
-      }
-      if (leftover.trim() && headerFound) {
-        const line = leftover.trimEnd();
-        if (line.includes("OnDemand") && line.includes("Compute Instance")) {
-          const fields = parseCsvLine(line);
-          const instanceType = fields[colInstanceType] ?? "";
-          const os = fields[colOS] ?? "";
-          const rawPrice = fields[colPrice] ?? "";
-          const unit = colUnit !== -1 ? fields[colUnit] ?? "Hrs" : "Hrs";
-          const priceValue = parseFloat(rawPrice);
-          if (instanceType && os && isFinite(priceValue) && priceValue > 0) {
-            const csvCacheKey = `aws/ec2/${region}/${instanceType.toLowerCase()}/${os.toLowerCase()}`;
-            this.cache.set(
-              csvCacheKey,
-              {
-                provider: "aws",
-                service: "ec2",
-                resource_type: instanceType,
-                region,
-                unit,
-                price_per_unit: priceValue,
-                currency: "USD",
-                description: `AWS EC2 ${instanceType} (${os}) on-demand`,
-                attributes: {
-                  instance_type: instanceType,
-                  operating_system: os,
-                  tenancy: "Shared",
-                  pricing_source: "live"
-                },
-                effective_date: (/* @__PURE__ */ new Date()).toISOString()
-              },
-              "aws",
-              "ec2",
-              region,
-              CACHE_TTL
-            );
-            cachedCount++;
-          }
-        }
-      }
-      logger.debug("AWS EC2 CSV streaming complete", { region, cachedCount });
-      return cachedCount > 0;
-    } catch (err) {
-      if (err?.name === "AbortError") {
-        logger.debug("AWS EC2 CSV streaming timed out", { region });
-      } else {
-        logger.debug("AWS EC2 CSV streaming error", {
-          region,
-          err: err instanceof Error ? err.message : String(err)
-        });
-      }
-      return false;
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-  // -------------------------------------------------------------------------
-  // Internal helpers – live API fetch
-  // -------------------------------------------------------------------------
-  async fetchBulkPricing(service, region) {
-    const url = `${BULK_PRICING_BASE}/${service}/current/${region}/index.json`;
-    logger.debug("Fetching AWS bulk pricing", { url });
-    const res = await fetch(url, {
-      signal: AbortSignal.timeout(3e4)
-    });
-    if (!res.ok) {
-      throw new Error(`HTTP ${res.status} from ${url}`);
-    }
-    return res.json();
-  }
-  buildCacheKey(service, region, ...parts) {
-    return ["aws", service, region, ...parts].map((p) => p.toLowerCase()).join("/");
-  }
-  // -------------------------------------------------------------------------
-  // Internal helpers – extract prices from bulk JSON
-  // -------------------------------------------------------------------------
-  extractEc2Price(bulk, instanceType, region, os) {
-    const products = bulk?.products ?? {};
-    const onDemand = bulk?.terms?.OnDemand ?? {};
-    const sortedEntries = Object.entries(products).sort(([a], [b]) => a.localeCompare(b));
-    for (const [sku, product] of sortedEntries) {
-      const attrs = product?.attributes ?? {};
-      if (attrs.instanceType === instanceType && (attrs.operatingSystem ?? "").toLowerCase() === os.toLowerCase() && attrs.tenancy === "Shared" && attrs.capacitystatus === "Used") {
-        const priceTerms = onDemand[sku];
-        if (priceTerms) {
-          return normalizeAwsCompute(product, { terms: { OnDemand: { [sku]: priceTerms } } }, region);
-        }
-      }
-    }
-    return null;
-  }
-  extractRdsPrice(bulk, instanceClass, region, engine) {
-    const products = bulk?.products ?? {};
-    const onDemand = bulk?.terms?.OnDemand ?? {};
-    const sortedEntries = Object.entries(products).sort(([a], [b]) => a.localeCompare(b));
-    for (const [sku, product] of sortedEntries) {
-      const attrs = product?.attributes ?? {};
-      if (attrs.instanceType === instanceClass && (attrs.databaseEngine ?? "").toLowerCase().includes(engine.toLowerCase()) && attrs.deploymentOption === "Single-AZ") {
-        const priceTerms = onDemand[sku];
-        if (priceTerms) {
-          return normalizeAwsDatabase(product, { terms: { OnDemand: { [sku]: priceTerms } } }, region);
-        }
-      }
-    }
-    return null;
-  }
-  extractEbsPrice(bulk, volumeType, region) {
-    const products = bulk?.products ?? {};
-    const onDemand = bulk?.terms?.OnDemand ?? {};
-    const sortedEntries = Object.entries(products).sort(([a], [b]) => a.localeCompare(b));
-    for (const [sku, product] of sortedEntries) {
-      const attrs = product?.attributes ?? {};
-      const apiName = (attrs.volumeApiName ?? "").toLowerCase();
-      if (product?.productFamily === "Storage" && (apiName === volumeType.toLowerCase() || (attrs.volumeType ?? "").toLowerCase() === volumeType.toLowerCase())) {
-        const priceTerms = onDemand[sku];
-        if (priceTerms) {
-          return normalizeAwsStorage(product, { terms: { OnDemand: { [sku]: priceTerms } } }, region);
-        }
-      }
-    }
-    return null;
-  }
-  // -------------------------------------------------------------------------
-  // Internal helpers – size interpolation
-  // -------------------------------------------------------------------------
-  /**
-   * AWS instance sizes follow a predictable doubling pattern:
-   * nano → micro → small → medium → large → xlarge → 2xlarge → 4xlarge → 8xlarge → ...
-   * Each step roughly doubles the price. Given a known price at one size,
-   * we can estimate the price for a missing size in the same family.
-   */
-  static SIZE_ORDER = [
-    "nano",
-    "micro",
-    "small",
-    "medium",
-    "large",
-    "xlarge",
-    "2xlarge",
-    "4xlarge",
-    "8xlarge",
-    "12xlarge",
-    "16xlarge",
-    "24xlarge",
-    "32xlarge",
-    "48xlarge"
-  ];
-  interpolatePrice(requestedType, table) {
-    const lower = requestedType.toLowerCase();
-    const lastDot = lower.lastIndexOf(".");
-    if (lastDot === -1) return void 0;
-    const family = lower.slice(0, lastDot);
-    const targetSize = lower.slice(lastDot + 1);
-    const targetIdx = _AwsBulkLoader.SIZE_ORDER.indexOf(targetSize);
-    if (targetIdx === -1) return void 0;
-    let bestKey;
-    let bestIdx = -1;
-    let bestDistance = Infinity;
-    for (const key of Object.keys(table)) {
-      const keyLastDot = key.lastIndexOf(".");
-      if (keyLastDot === -1) continue;
-      const keyFamily = key.slice(0, keyLastDot);
-      const keySize = key.slice(keyLastDot + 1);
-      if (keyFamily !== family) continue;
-      const keyIdx = _AwsBulkLoader.SIZE_ORDER.indexOf(keySize);
-      if (keyIdx === -1) continue;
-      const distance = Math.abs(keyIdx - targetIdx);
-      if (distance < bestDistance) {
-        bestDistance = distance;
-        bestIdx = keyIdx;
-        bestKey = key;
-      }
-    }
-    if (bestKey === void 0 || bestIdx === -1) return void 0;
-    const knownPrice = table[bestKey];
-    const steps = targetIdx - bestIdx;
-    return knownPrice * Math.pow(2, steps);
-  }
-  // -------------------------------------------------------------------------
-  // Internal helpers – fallback hardcoded prices
-  // -------------------------------------------------------------------------
-  fallbackComputePrice(instanceType, region, os, cacheKey) {
-    let basePrice = EC2_BASE_PRICES[instanceType.toLowerCase()];
-    if (basePrice === void 0) {
-      basePrice = this.interpolatePrice(instanceType, EC2_BASE_PRICES) ?? void 0;
-    }
-    if (basePrice === void 0) {
-      logger.warn("No fallback price found for EC2 instance type", { instanceType });
-      return null;
-    }
-    const multiplier = regionMultiplier(region);
-    const result = {
-      provider: "aws",
-      service: "ec2",
-      resource_type: instanceType,
-      region,
-      unit: "Hrs",
-      price_per_unit: basePrice * multiplier,
-      currency: "USD",
-      description: `AWS EC2 ${instanceType} (${os}) \u2013 fallback pricing`,
-      attributes: {
-        instance_type: instanceType,
-        operating_system: os,
-        tenancy: "Shared",
-        pricing_source: "fallback"
-      },
-      effective_date: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.cache.set(cacheKey, result, "aws", "ec2", region, CACHE_TTL);
-    return result;
-  }
-  fallbackDatabasePrice(instanceClass, region, engine, cacheKey) {
-    let basePrice = RDS_BASE_PRICES[instanceClass.toLowerCase()];
-    if (basePrice === void 0) {
-      basePrice = this.interpolatePrice(instanceClass, RDS_BASE_PRICES) ?? void 0;
-    }
-    if (basePrice === void 0) {
-      logger.warn("No fallback price found for RDS instance class", { instanceClass });
-      return null;
-    }
-    const multiplier = regionMultiplier(region);
-    const result = {
-      provider: "aws",
-      service: "rds",
-      resource_type: instanceClass,
-      region,
-      unit: "Hrs",
-      price_per_unit: basePrice * multiplier,
-      currency: "USD",
-      description: `AWS RDS ${instanceClass} (${engine}) \u2013 fallback pricing`,
-      attributes: {
-        instance_type: instanceClass,
-        database_engine: engine,
-        deployment_option: "Single-AZ",
-        pricing_source: "fallback"
-      },
-      effective_date: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.cache.set(cacheKey, result, "aws", "rds", region, CACHE_TTL);
-    return result;
-  }
-  fallbackStoragePrice(volumeType, region, cacheKey) {
-    const basePrice = EBS_BASE_PRICES[volumeType.toLowerCase()];
-    if (basePrice === void 0) {
-      logger.warn("No fallback price found for EBS volume type", { volumeType });
-      return null;
-    }
-    const multiplier = regionMultiplier(region);
-    const result = {
-      provider: "aws",
-      service: "ebs",
-      resource_type: volumeType,
-      region,
-      unit: "GB-Mo",
-      price_per_unit: basePrice * multiplier,
-      currency: "USD",
-      description: `AWS EBS ${volumeType} volume \u2013 fallback pricing`,
-      attributes: {
-        volume_type: volumeType,
-        pricing_source: "fallback"
-      },
-      effective_date: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.cache.set(cacheKey, result, "aws", "ebs", region, CACHE_TTL);
-    return result;
-  }
-};
-
-// src/pricing/azure/azure-normalizer.ts
-function normalizeAzureCompute(item) {
-  return {
-    provider: "azure",
-    service: "virtual-machines",
-    resource_type: item.skuName ?? item.armSkuName ?? "unknown",
-    region: item.armRegionName ?? item.location ?? "",
-    unit: item.unitOfMeasure ?? "1 Hour",
-    price_per_unit: item.retailPrice ?? item.unitPrice ?? 0,
-    currency: item.currencyCode ?? "USD",
-    tier: item.tierMinimumUnits !== void 0 ? String(item.tierMinimumUnits) : void 0,
-    description: item.productName ?? void 0,
-    attributes: {
-      sku_name: item.skuName ?? "",
-      arm_sku_name: item.armSkuName ?? "",
-      service_name: item.serviceName ?? "Virtual Machines",
-      product_name: item.productName ?? "",
-      meter_name: item.meterName ?? "",
-      pricing_source: "azure-retail-api"
-    },
-    effective_date: item.effectiveStartDate ?? (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function normalizeAzureDatabase(item) {
-  return {
-    provider: "azure",
-    service: "azure-database",
-    resource_type: item.skuName ?? item.armSkuName ?? "unknown",
-    region: item.armRegionName ?? item.location ?? "",
-    unit: item.unitOfMeasure ?? "1 Hour",
-    price_per_unit: item.retailPrice ?? item.unitPrice ?? 0,
-    currency: item.currencyCode ?? "USD",
-    description: item.productName ?? void 0,
-    attributes: {
-      sku_name: item.skuName ?? "",
-      service_name: item.serviceName ?? "",
-      product_name: item.productName ?? "",
-      meter_name: item.meterName ?? "",
-      pricing_source: "azure-retail-api"
-    },
-    effective_date: item.effectiveStartDate ?? (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function normalizeAzureStorage(item) {
-  return {
-    provider: "azure",
-    service: "managed-disks",
-    resource_type: item.skuName ?? item.armSkuName ?? "unknown",
-    region: item.armRegionName ?? item.location ?? "",
-    unit: item.unitOfMeasure ?? "1 GiB/Month",
-    price_per_unit: item.retailPrice ?? item.unitPrice ?? 0,
-    currency: item.currencyCode ?? "USD",
-    description: item.productName ?? void 0,
-    attributes: {
-      sku_name: item.skuName ?? "",
-      service_name: item.serviceName ?? "",
-      product_name: item.productName ?? "",
-      meter_name: item.meterName ?? "",
-      pricing_source: "azure-retail-api"
-    },
-    effective_date: item.effectiveStartDate ?? (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-
-// src/pricing/azure/retail-client.ts
-var VM_BASE_PRICES = {
-  "standard_b1s": 0.0104,
-  "standard_b1ms": 0.0207,
-  "standard_b2s": 0.0416,
-  "standard_b2ms": 0.0832,
-  "standard_b4ms": 0.166,
-  "standard_b8ms": 0.333,
-  "standard_b12ms": 0.499,
-  "standard_b16ms": 0.666,
-  "standard_d2s_v4": 0.096,
-  "standard_d4s_v4": 0.192,
-  "standard_d8s_v4": 0.384,
-  "standard_d2s_v5": 0.096,
-  "standard_d4s_v5": 0.192,
-  "standard_d8s_v5": 0.384,
-  "standard_d16s_v5": 0.768,
-  "standard_d32s_v5": 1.536,
-  "standard_d2ds_v5": 0.113,
-  "standard_d4ds_v5": 0.226,
-  "standard_d8ds_v5": 0.452,
-  "standard_d2ps_v5": 0.077,
-  "standard_d4ps_v5": 0.154,
-  "standard_e2s_v5": 0.126,
-  "standard_e4s_v5": 0.252,
-  "standard_e8s_v5": 0.504,
-  "standard_e16s_v5": 1.008,
-  "standard_e32s_v5": 2.016,
-  "standard_e2ds_v5": 0.144,
-  "standard_e4ds_v5": 0.288,
-  "standard_f2s_v2": 0.085,
-  "standard_f4s_v2": 0.17,
-  "standard_f8s_v2": 0.34,
-  "standard_f16s_v2": 0.68,
-  "standard_f32s_v2": 1.36,
-  "standard_l8s_v3": 0.624,
-  "standard_l16s_v3": 1.248,
-  "standard_nc4as_t4_v3": 0.526,
-  "standard_nc8as_t4_v3": 0.752,
-  "standard_e2ps_v5": 0.101,
-  "standard_e4ps_v5": 0.202,
-  "standard_e8ps_v5": 0.403
-};
-var DISK_BASE_PRICES = {
-  "premium_lrs": 0.132,
-  "standard_lrs": 0.04,
-  "standardssd_lrs": 0.075,
-  "ultrassd_lrs": 0.12,
-  "premium_lrs_p10": 52e-4,
-  "premium_lrs_p20": 0.01,
-  "premium_lrs_p30": 0.0192,
-  "premium_lrs_p40": 0.0373
-};
-var DB_BASE_PRICES = {
-  "burstable_standard_b1ms": 0.044,
-  "burstable_standard_b2s": 0.088,
-  "burstable_standard_b4ms": 0.176,
-  "gp_standard_d2s_v3": 0.124,
-  "gp_standard_d4s_v3": 0.248,
-  "gp_standard_d8s_v3": 0.496,
-  "gp_standard_d16s_v3": 0.992,
-  "gp_standard_d2ds_v4": 0.124,
-  "gp_standard_d4ds_v4": 0.248,
-  "gp_standard_d8ds_v4": 0.496,
-  "gp_standard_d16ds_v4": 0.992,
-  "mo_standard_e2ds_v4": 0.17,
-  "mo_standard_e4ds_v4": 0.341,
-  "mo_standard_e8ds_v4": 0.682
-};
-var ALB_HOURLY2 = 0.025;
-var ALB_RULE_HOURLY = 5e-3;
-var NAT_HOURLY2 = 0.045;
-var NAT_PER_GB2 = 0.045;
-var AKS_HOURLY = 0.1;
-var REGION_MULTIPLIERS2 = {
-  eastus: 1,
-  eastus2: 1,
-  westus: 1.05,
-  westus2: 1,
-  westus3: 1.02,
-  centralus: 1,
-  northeurope: 1.08,
-  westeurope: 1.08,
-  uksouth: 1.08,
-  ukwest: 1.12,
-  southeastasia: 1.12,
-  eastasia: 1.12,
-  japaneast: 1.1,
-  japanwest: 1.12,
-  australiaeast: 1.15,
-  brazilsouth: 1.25,
-  canadacentral: 1.05,
-  southafricanorth: 1.15,
-  germanywestcentral: 1.1,
-  centralindia: 1.08,
-  koreacentral: 1.1,
-  swedencentral: 1.08,
-  italynorth: 1.1,
-  uaenorth: 1.12
-};
-function regionMultiplier2(region) {
-  return REGION_MULTIPLIERS2[region.toLowerCase()] ?? 1;
-}
-var CACHE_TTL2 = 86400;
-var RETAIL_API_BASE = "https://prices.azure.com/api/retail/prices";
-var AzureRetailClient = class {
-  cache;
-  constructor(cache) {
-    this.cache = cache;
-  }
-  // -------------------------------------------------------------------------
-  // Public API
-  // -------------------------------------------------------------------------
-  async getComputePrice(vmSize, region, os = "linux") {
-    const cacheKey = this.buildCacheKey("vm", region, vmSize, os);
-    const cached = this.cache.get(cacheKey);
-    if (cached) return cached;
-    try {
-      const armRegion = region.toLowerCase().replace(/\s+/g, "");
-      const filter = this.buildODataFilter("Virtual Machines", armRegion, vmSize, true);
-      const items = await this.queryPricing(filter);
-      const match = this.pickVmItem(items, vmSize, os);
-      if (match) {
-        const result = normalizeAzureCompute(match);
-        this.cache.set(cacheKey, result, "azure", "vm", region, CACHE_TTL2);
-        return result;
-      }
-    } catch (err) {
-      logger.warn("Azure Retail API VM fetch failed, using fallback", {
-        region,
-        vmSize,
-        err: err instanceof Error ? err.message : String(err)
-      });
-    }
-    return this.fallbackComputePrice(vmSize, region, os, cacheKey);
-  }
-  async getDatabasePrice(tier, region, engine = "PostgreSQL") {
-    const cacheKey = this.buildCacheKey("db", region, tier, engine);
-    const cached = this.cache.get(cacheKey);
-    if (cached) return cached;
-    try {
-      const armRegion = region.toLowerCase().replace(/\s+/g, "");
-      const serviceName = `Azure Database for ${engine}`;
-      const result = await this.queryDatabasePrice(tier, armRegion, serviceName);
-      if (result) {
-        this.cache.set(cacheKey, result, "azure", "db", region, CACHE_TTL2);
-        return result;
-      }
-      logger.warn("Azure Retail API returned no matching DB pricing", {
-        region,
-        tier,
-        engine
-      });
-    } catch (err) {
-      logger.warn("Azure Retail API DB fetch failed, using fallback", {
-        region,
-        tier,
-        err: err instanceof Error ? err.message : String(err)
-      });
-    }
-    return this.fallbackDatabasePrice(tier, region, engine, cacheKey);
-  }
-  /**
-   * Azure DB flexible server tier names follow the pattern:
-   *   GP_Standard_D2s_v3  →  General Purpose, D-series, 2 vCPUs, v3
-   *   MO_Standard_E4ds_v5 →  Memory Optimized, E-series, 4 vCPUs, v5
-   *
-   * The Retail API prices DB compute in two ways:
-   *   1. Per-instance entries with armSkuName like "Standard_D2ds_v5" (total price)
-   *   2. Per-vCore entries for a series (e.g., Dsv3Series_Compute) × vCPU count
-   *
-   * This method tries approach 1 first, then falls back to approach 2.
-   */
-  async queryDatabasePrice(tier, armRegion, serviceName) {
-    const vmName = tier.replace(/^(GP|MO|BC|GEN)_/i, "");
-    const exactFilter = `serviceName eq '${serviceName}' and armRegionName eq '${armRegion}' and priceType eq 'Consumption' and armSkuName eq '${vmName}'`;
-    const exactItems = await this.queryPricing(exactFilter);
-    if (exactItems.length > 0) {
-      exactItems.sort((a, b) => (a.skuId ?? "").localeCompare(b.skuId ?? ""));
-      const match = exactItems.find(
-        (i) => (i.meterName ?? "").toLowerCase().includes("vcore")
-      ) ?? exactItems[0];
-      return normalizeAzureDatabase(match);
-    }
-    const parsed = this.parseVmSeries(vmName);
-    if (!parsed) return null;
-    const tierPrefix = tier.match(/^(GP|MO|BC|GEN)_/i)?.[1]?.toUpperCase();
-    const seriesFamily = tierPrefix === "MO" ? "Memory_Optimized" : "General_Purpose";
-    const seriesFilter = `serviceName eq '${serviceName}' and armRegionName eq '${armRegion}' and priceType eq 'Consumption' and contains(armSkuName, '${seriesFamily}') and contains(armSkuName, '${parsed.series}')`;
-    const seriesItems = await this.queryPricing(seriesFilter);
-    if (seriesItems.length > 0) {
-      seriesItems.sort((a, b) => (a.skuId ?? "").localeCompare(b.skuId ?? ""));
-      const perVcore = seriesItems[0].retailPrice ?? 0;
-      const totalPrice = perVcore * parsed.vcpus;
-      const adjusted = { ...seriesItems[0], retailPrice: totalPrice };
-      return normalizeAzureDatabase(adjusted);
-    }
-    return null;
-  }
-  /**
-   * Parse a VM name like "Standard_D2s_v3" into series info.
-   * Returns { series: "Dsv3", vcpus: 2 } or null if unparseable.
-   */
-  parseVmSeries(vmName) {
-    const match = vmName.match(
-      /Standard_([A-Z])(\d+)([a-z]*)_v(\d+)/i
-    );
-    if (!match) return null;
-    const [, family, vcpuStr, variant, version] = match;
-    const vcpus = parseInt(vcpuStr, 10);
-    if (isNaN(vcpus) || vcpus === 0) return null;
-    const series = `${family}${variant}v${version}`;
-    return { series, vcpus };
-  }
-  async getStoragePrice(diskType, region) {
-    const cacheKey = this.buildCacheKey("disk", region, diskType);
-    const cached = this.cache.get(cacheKey);
-    if (cached) return cached;
-    try {
-      const armRegion = region.toLowerCase().replace(/\s+/g, "");
-      const filter = this.buildODataFilter("Storage", armRegion, diskType);
-      const items = await this.queryPricing(filter);
-      if (items.length > 0) {
-        items.sort((a, b) => (a.skuId ?? "").localeCompare(b.skuId ?? ""));
-        const result = normalizeAzureStorage(items[0]);
-        this.cache.set(cacheKey, result, "azure", "storage", region, CACHE_TTL2);
-        return result;
-      }
-      logger.warn("Azure Retail API returned no matching storage pricing", {
-        region,
-        diskType
-      });
-    } catch (err) {
-      logger.warn("Azure Retail API storage fetch failed, using fallback", {
-        region,
-        diskType,
-        err: err instanceof Error ? err.message : String(err)
-      });
-    }
-    return this.fallbackStoragePrice(diskType, region, cacheKey);
-  }
-  async getLoadBalancerPrice(region) {
-    const multiplier = regionMultiplier2(region);
-    return {
-      provider: "azure",
-      service: "load-balancer",
-      resource_type: "standard",
-      region,
-      unit: "1 Hour",
-      price_per_unit: ALB_HOURLY2 * multiplier,
-      currency: "USD",
-      description: "Azure Load Balancer Standard (hourly + per rule)",
-      attributes: {
-        rule_hourly_price: String(ALB_RULE_HOURLY * multiplier),
-        pricing_model: "fixed_plus_rules"
-      },
-      effective_date: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  async getNatGatewayPrice(region) {
-    const multiplier = regionMultiplier2(region);
-    return {
-      provider: "azure",
-      service: "nat-gateway",
-      resource_type: "nat-gateway",
-      region,
-      unit: "1 Hour",
-      price_per_unit: NAT_HOURLY2 * multiplier,
-      currency: "USD",
-      description: "Azure NAT Gateway (hourly + data processed)",
-      attributes: {
-        per_gb_price: String(NAT_PER_GB2 * multiplier)
-      },
-      effective_date: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  async getKubernetesPrice(region) {
-    const multiplier = regionMultiplier2(region);
-    return {
-      provider: "azure",
-      service: "aks",
-      resource_type: "cluster",
-      region,
-      unit: "1 Hour",
-      price_per_unit: AKS_HOURLY * multiplier,
-      currency: "USD",
-      description: "Azure Kubernetes Service (uptime SLA tier, per cluster/hour)",
-      attributes: {},
-      effective_date: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  // -------------------------------------------------------------------------
-  // Internal helpers – live API
-  // -------------------------------------------------------------------------
-  async queryPricing(filter) {
-    const allItems = [];
-    let url = `${RETAIL_API_BASE}?api-version=2023-01-01-preview&$filter=${encodeURIComponent(filter)}`;
-    logger.debug("Querying Azure Retail Prices API", { filter });
-    let pages = 0;
-    while (url && pages < 10) {
-      const res = await fetch(url, {
-        signal: AbortSignal.timeout(3e4)
-      });
-      if (!res.ok) {
-        throw new Error(`HTTP ${res.status} from Azure Retail API`);
-      }
-      const json = await res.json();
-      allItems.push(...json?.Items ?? []);
-      url = json?.NextPageLink ?? null;
-      pages++;
-    }
-    return allItems;
-  }
-  buildODataFilter(service, armRegion, skuName, exactArmSku) {
-    let filter = `serviceName eq '${service}' and armRegionName eq '${armRegion}' and priceType eq 'Consumption'`;
-    if (skuName) {
-      if (exactArmSku) {
-        filter += ` and armSkuName eq '${skuName}'`;
-      } else {
-        filter += ` and contains(skuName, '${skuName}')`;
-      }
-    }
-    return filter;
-  }
-  buildCacheKey(service, region, ...parts) {
-    return ["azure", service, region, ...parts].map((p) => p.toLowerCase()).join("/");
-  }
-  /**
-   * From the API response items, pick the item that best matches the desired
-   * VM size and OS.  Prefers exact skuName matches and the correct OS suffix
-   * ("Windows" vs everything else being Linux).
-   */
-  pickVmItem(items, vmSize, os) {
-    if (items.length === 0) return null;
-    const sorted = [...items].sort(
-      (a, b) => (a.skuId ?? "").localeCompare(b.skuId ?? "")
-    );
-    const vmLower = vmSize.toLowerCase();
-    const isWindows = os.toLowerCase().includes("windows");
-    for (const item of sorted) {
-      const skuLower = (item.skuName ?? "").toLowerCase();
-      const hasWindows = skuLower.includes("windows");
-      if (skuLower.includes(vmLower) && (isWindows && hasWindows || !isWindows && !hasWindows)) {
-        return item;
-      }
-    }
-    return sorted[0];
-  }
-  // -------------------------------------------------------------------------
-  // Internal helpers – size interpolation
-  // -------------------------------------------------------------------------
-  /**
-   * Azure VM sizes embed vCPU count as a number: Standard_D2s_v5 → 2 vCPUs.
-   * Doubling the number roughly doubles the price. Find the nearest known
-   * size in the same family/suffix and scale proportionally.
-   */
-  interpolateVmPrice(vmSize, table) {
-    const key = vmSize.toLowerCase().replace(/\s+/g, "_");
-    const match = key.match(/^(.+?)(\d+)(.*?)$/);
-    if (!match) return void 0;
-    const [, prefix, numStr, suffix] = match;
-    const targetNum = parseInt(numStr, 10);
-    if (isNaN(targetNum) || targetNum === 0) return void 0;
-    let bestKey;
-    let bestNum = 0;
-    let bestDistance = Infinity;
-    for (const candidate of Object.keys(table)) {
-      const candMatch = candidate.match(/^(.+?)(\d+)(.*?)$/);
-      if (!candMatch) continue;
-      const [, cPrefix, cNumStr, cSuffix] = candMatch;
-      if (cPrefix !== prefix || cSuffix !== suffix) continue;
-      const cNum = parseInt(cNumStr, 10);
-      if (isNaN(cNum) || cNum === 0) continue;
-      const distance = Math.abs(cNum - targetNum);
-      if (distance < bestDistance) {
-        bestDistance = distance;
-        bestNum = cNum;
-        bestKey = candidate;
-      }
-    }
-    if (bestKey === void 0 || bestNum === 0) return void 0;
-    return table[bestKey] * (targetNum / bestNum);
-  }
-  /**
-   * Azure DB tier names embed a vCPU number similarly to VM sizes.
-   * e.g. "gp_standard_d2s_v3" → "gp_standard_d4s_v3" doubles.
-   */
-  interpolateDbPrice(tier, table) {
-    const key = tier.toLowerCase().replace(/\s+/g, "_").replace(/-/g, "_");
-    const match = key.match(/^(.+?)(\d+)(.*?)$/);
-    if (!match) return void 0;
-    const [, prefix, numStr, suffix] = match;
-    const targetNum = parseInt(numStr, 10);
-    if (isNaN(targetNum) || targetNum === 0) return void 0;
-    let bestKey;
-    let bestNum = 0;
-    let bestDistance = Infinity;
-    for (const candidate of Object.keys(table)) {
-      const candMatch = candidate.match(/^(.+?)(\d+)(.*?)$/);
-      if (!candMatch) continue;
-      const [, cPrefix, cNumStr, cSuffix] = candMatch;
-      if (cPrefix !== prefix || cSuffix !== suffix) continue;
-      const cNum = parseInt(cNumStr, 10);
-      if (isNaN(cNum) || cNum === 0) continue;
-      const distance = Math.abs(cNum - targetNum);
-      if (distance < bestDistance) {
-        bestDistance = distance;
-        bestNum = cNum;
-        bestKey = candidate;
-      }
-    }
-    if (bestKey === void 0 || bestNum === 0) return void 0;
-    return table[bestKey] * (targetNum / bestNum);
-  }
-  // -------------------------------------------------------------------------
-  // Internal helpers – fallback hardcoded prices
-  // -------------------------------------------------------------------------
-  fallbackComputePrice(vmSize, region, os, cacheKey) {
-    const key = vmSize.toLowerCase().replace(/\s+/g, "_");
-    let basePrice = VM_BASE_PRICES[key];
-    if (basePrice === void 0) {
-      basePrice = this.interpolateVmPrice(vmSize, VM_BASE_PRICES) ?? void 0;
-    }
-    if (basePrice === void 0) {
-      logger.warn("No fallback price found for Azure VM size", { vmSize });
-      return null;
-    }
-    const multiplier = regionMultiplier2(region);
-    const result = {
-      provider: "azure",
-      service: "virtual-machines",
-      resource_type: vmSize,
-      region,
-      unit: "1 Hour",
-      price_per_unit: basePrice * multiplier,
-      currency: "USD",
-      description: `Azure VM ${vmSize} (${os}) \u2013 fallback pricing`,
-      attributes: {
-        sku_name: vmSize,
-        operating_system: os,
-        pricing_source: "fallback"
-      },
-      effective_date: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.cache.set(cacheKey, result, "azure", "vm", region, CACHE_TTL2);
-    return result;
-  }
-  fallbackDatabasePrice(tier, region, engine, cacheKey) {
-    const key = tier.toLowerCase().replace(/\s+/g, "_").replace(/-/g, "_");
-    let basePrice = DB_BASE_PRICES[key];
-    if (basePrice === void 0) {
-      basePrice = this.interpolateDbPrice(tier, DB_BASE_PRICES) ?? void 0;
-    }
-    if (basePrice === void 0) {
-      logger.warn("No fallback price found for Azure DB tier", { tier });
-      return null;
-    }
-    const multiplier = regionMultiplier2(region);
-    const result = {
-      provider: "azure",
-      service: "azure-database",
-      resource_type: tier,
-      region,
-      unit: "1 Hour",
-      price_per_unit: basePrice * multiplier,
-      currency: "USD",
-      description: `Azure Database for ${engine} ${tier} \u2013 fallback pricing`,
-      attributes: {
-        tier,
-        engine,
-        pricing_source: "fallback"
-      },
-      effective_date: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.cache.set(cacheKey, result, "azure", "db", region, CACHE_TTL2);
-    return result;
-  }
-  fallbackStoragePrice(diskType, region, cacheKey) {
-    const key = diskType.toLowerCase().replace(/\s+/g, "_").replace(/-/g, "_");
-    const basePrice = DISK_BASE_PRICES[key];
-    if (basePrice === void 0) {
-      logger.warn("No fallback price found for Azure disk type", { diskType });
-      return null;
-    }
-    const multiplier = regionMultiplier2(region);
-    const result = {
-      provider: "azure",
-      service: "managed-disks",
-      resource_type: diskType,
-      region,
-      unit: "1 GiB/Month",
-      price_per_unit: basePrice * multiplier,
-      currency: "USD",
-      description: `Azure Managed Disk ${diskType} \u2013 fallback pricing`,
-      attributes: {
-        disk_type: diskType,
-        pricing_source: "fallback"
-      },
-      effective_date: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.cache.set(cacheKey, result, "azure", "storage", region, CACHE_TTL2);
-    return result;
-  }
-};
-
-// src/pricing/gcp/gcp-normalizer.ts
-function normalizeGcpCompute(machineType, hourlyPrice, region) {
-  return {
-    provider: "gcp",
-    service: "compute-engine",
-    resource_type: machineType,
-    region,
-    unit: "h",
-    price_per_unit: hourlyPrice,
-    currency: "USD",
-    description: `GCP Compute Engine ${machineType}`,
-    attributes: {
-      machine_type: machineType,
-      pricing_source: "bundled"
-    },
-    effective_date: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function normalizeGcpDatabase(tier, hourlyPrice, region) {
-  return {
-    provider: "gcp",
-    service: "cloud-sql",
-    resource_type: tier,
-    region,
-    unit: "h",
-    price_per_unit: hourlyPrice,
-    currency: "USD",
-    description: `GCP Cloud SQL ${tier}`,
-    attributes: {
-      tier,
-      pricing_source: "bundled"
-    },
-    effective_date: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function normalizeGcpStorage(storageClass, pricePerGb, region) {
-  return {
-    provider: "gcp",
-    service: "cloud-storage",
-    resource_type: storageClass,
-    region,
-    unit: "GiBy.mo",
-    price_per_unit: pricePerGb,
-    currency: "USD",
-    description: `GCP Cloud Storage ${storageClass}`,
-    attributes: {
-      storage_class: storageClass,
-      pricing_source: "bundled"
-    },
-    effective_date: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function normalizeGcpDisk(diskType, pricePerGb, region) {
-  return {
-    provider: "gcp",
-    service: "persistent-disk",
-    resource_type: diskType,
-    region,
-    unit: "GiBy.mo",
-    price_per_unit: pricePerGb,
-    currency: "USD",
-    description: `GCP Persistent Disk ${diskType}`,
-    attributes: {
-      disk_type: diskType,
-      pricing_source: "bundled"
-    },
-    effective_date: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-
-// src/pricing/gcp/bundled-loader.ts
-var LB_FORWARDING_RULE_HOURLY = 0.025;
-var LB_PER_GB = 8e-3;
-var NAT_HOURLY3 = 0.044;
-var NAT_PER_GB3 = 0.045;
-var GKE_STANDARD_HOURLY = 0.1;
-var GKE_AUTOPILOT_VCPU_HOURLY = 0.0445;
-var GcpBundledLoader = class {
-  // -------------------------------------------------------------------------
-  // Public API
-  // -------------------------------------------------------------------------
-  async getComputePrice(machineType, region) {
-    try {
-      const pricing = getGcpComputePricing();
-      const regionPrices = pricing[region];
-      if (!regionPrices) {
-        logger.debug("GCP compute: region not found in bundled data", {
-          region,
-          machineType
-        });
-        return null;
-      }
-      const price = regionPrices[machineType];
-      if (price === void 0) {
-        logger.debug("GCP compute: machine type not found in bundled data", {
-          region,
-          machineType
-        });
-        return null;
-      }
-      return normalizeGcpCompute(machineType, price, region);
-    } catch (err) {
-      logger.error("GCP compute pricing load error", {
-        machineType,
-        region,
-        err: err instanceof Error ? err.message : String(err)
-      });
-      return null;
-    }
-  }
-  async getDatabasePrice(tier, region) {
-    try {
-      const pricing = getGcpSqlPricing();
-      const regionPrices = pricing[region];
-      if (!regionPrices) {
-        logger.debug("GCP SQL: region not found in bundled data", {
-          region,
-          tier
-        });
-        return null;
-      }
-      const price = regionPrices[tier];
-      if (price === void 0 || tier === "storage_per_gb" || tier === "ha_multiplier") {
-        logger.debug("GCP SQL: tier not found in bundled data", {
-          region,
-          tier
-        });
-        return null;
-      }
-      return normalizeGcpDatabase(tier, price, region);
-    } catch (err) {
-      logger.error("GCP SQL pricing load error", {
-        tier,
-        region,
-        err: err instanceof Error ? err.message : String(err)
-      });
-      return null;
-    }
-  }
-  async getStoragePrice(storageClass, region) {
-    try {
-      const pricing = getGcpStoragePricing();
-      const regionPrices = pricing[region];
-      if (!regionPrices) {
-        logger.debug("GCP Storage: region not found in bundled data", {
-          region,
-          storageClass
-        });
-        return null;
-      }
-      const classKey = storageClass.toUpperCase();
-      const price = regionPrices[classKey];
-      if (price === void 0) {
-        logger.debug("GCP Storage: storage class not found in bundled data", {
-          region,
-          storageClass
-        });
-        return null;
-      }
-      return normalizeGcpStorage(storageClass.toUpperCase(), price, region);
-    } catch (err) {
-      logger.error("GCP Storage pricing load error", {
-        storageClass,
-        region,
-        err: err instanceof Error ? err.message : String(err)
-      });
-      return null;
-    }
-  }
-  async getDiskPrice(diskType, region) {
-    try {
-      const pricing = getGcpDiskPricing();
-      const regionPrices = pricing[region];
-      if (!regionPrices) {
-        logger.debug("GCP Disk: region not found in bundled data", {
-          region,
-          diskType
-        });
-        return null;
-      }
-      const diskKey = diskType;
-      const price = regionPrices[diskKey];
-      if (price === void 0) {
-        logger.debug("GCP Disk: disk type not found in bundled data", {
-          region,
-          diskType
-        });
-        return null;
-      }
-      return normalizeGcpDisk(diskType, price, region);
-    } catch (err) {
-      logger.error("GCP Disk pricing load error", {
-        diskType,
-        region,
-        err: err instanceof Error ? err.message : String(err)
-      });
-      return null;
-    }
-  }
-  async getLoadBalancerPrice(region) {
-    return {
-      provider: "gcp",
-      service: "cloud-load-balancing",
-      resource_type: "forwarding-rule",
-      region,
-      unit: "h",
-      price_per_unit: LB_FORWARDING_RULE_HOURLY,
-      currency: "USD",
-      description: "GCP Cloud Load Balancing forwarding rule (per hour + data processed)",
-      attributes: {
-        per_gb_price: String(LB_PER_GB)
-      },
-      effective_date: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  async getNatGatewayPrice(region) {
-    return {
-      provider: "gcp",
-      service: "cloud-nat",
-      resource_type: "nat-gateway",
-      region,
-      unit: "h",
-      price_per_unit: NAT_HOURLY3,
-      currency: "USD",
-      description: "GCP Cloud NAT (per gateway/hour + data processed)",
-      attributes: {
-        per_gb_price: String(NAT_PER_GB3)
-      },
-      effective_date: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  async getKubernetesPrice(region, mode = "standard") {
-    const hourlyPrice = mode === "autopilot" ? GKE_AUTOPILOT_VCPU_HOURLY : GKE_STANDARD_HOURLY;
-    return {
-      provider: "gcp",
-      service: "gke",
-      resource_type: "cluster",
-      region,
-      unit: "h",
-      price_per_unit: hourlyPrice,
-      currency: "USD",
-      description: mode === "autopilot" ? "GCP GKE Autopilot cluster (estimated per-vCPU/hr; actual billing is per-pod resources)" : "GCP GKE Standard cluster (per cluster/hour)",
-      attributes: {
-        mode,
-        ...mode === "autopilot" && {
-          pricing_model: "per_vcpu_hour",
-          pricing_note: "Autopilot charges per pod vCPU and memory. This price is a per-vCPU/hr approximation for cluster-level cost estimation."
-        }
-      },
-      effective_date: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-};
-
-// src/pricing/pricing-engine.ts
-var AwsProvider = class {
-  loader;
-  constructor(cache) {
-    this.loader = new AwsBulkLoader(cache);
-  }
-  getComputePrice(instanceType, region, os) {
-    return this.loader.getComputePrice(instanceType, region, os);
-  }
-  getDatabasePrice(instanceType, region, engine) {
-    return this.loader.getDatabasePrice(instanceType, region, engine);
-  }
-  getStoragePrice(storageType, region, _sizeGb) {
-    return this.loader.getStoragePrice(storageType, region);
-  }
-  getLoadBalancerPrice(_type, region) {
-    return this.loader.getLoadBalancerPrice(region);
-  }
-  getNatGatewayPrice(region) {
-    return this.loader.getNatGatewayPrice(region);
-  }
-  getKubernetesPrice(region) {
-    return this.loader.getKubernetesPrice(region);
-  }
-};
-var AzureProvider = class {
-  client;
-  constructor(cache) {
-    this.client = new AzureRetailClient(cache);
-  }
-  getComputePrice(instanceType, region, os) {
-    return this.client.getComputePrice(instanceType, region, os);
-  }
-  getDatabasePrice(instanceType, region, engine) {
-    return this.client.getDatabasePrice(instanceType, region, engine);
-  }
-  getStoragePrice(storageType, region, _sizeGb) {
-    return this.client.getStoragePrice(storageType, region);
-  }
-  getLoadBalancerPrice(_type, region) {
-    return this.client.getLoadBalancerPrice(region);
-  }
-  getNatGatewayPrice(region) {
-    return this.client.getNatGatewayPrice(region);
-  }
-  getKubernetesPrice(region) {
-    return this.client.getKubernetesPrice(region);
-  }
-};
-var GcpProvider = class {
-  loader;
-  constructor() {
-    this.loader = new GcpBundledLoader();
-  }
-  getComputePrice(instanceType, region, _os) {
-    return this.loader.getComputePrice(instanceType, region);
-  }
-  getDatabasePrice(instanceType, region, _engine) {
-    return this.loader.getDatabasePrice(instanceType, region);
-  }
-  getStoragePrice(storageType, region, _sizeGb) {
-    if (storageType.startsWith("pd-")) {
-      return this.loader.getDiskPrice(storageType, region);
-    }
-    return this.loader.getStoragePrice(storageType, region);
-  }
-  getLoadBalancerPrice(_type, region) {
-    return this.loader.getLoadBalancerPrice(region);
-  }
-  getNatGatewayPrice(region) {
-    return this.loader.getNatGatewayPrice(region);
-  }
-  getKubernetesPrice(region) {
-    return this.loader.getKubernetesPrice(region);
-  }
-};
-var PricingEngine = class {
-  providers = /* @__PURE__ */ new Map();
-  constructor(cache, _config) {
-    this.providers.set("aws", new AwsProvider(cache));
-    this.providers.set("azure", new AzureProvider(cache));
-    this.providers.set("gcp", new GcpProvider());
-  }
-  /**
-   * Return the PricingProvider for a specific cloud provider.
-   * Throws if the provider is not registered (should never happen for the
-   * three known providers).
-   */
-  getProvider(provider) {
-    const p = this.providers.get(provider);
-    if (!p) {
-      throw new Error(`Unknown cloud provider: ${provider}`);
-    }
-    return p;
-  }
-  /**
-   * Generic price lookup that maps service/resourceType strings to the
-   * appropriate method on the underlying PricingProvider.
-   *
-   * Supported service values (case-insensitive):
-   *   compute, ec2, vm, instance        → getComputePrice
-   *   database, rds, sql, db            → getDatabasePrice
-   *   storage, ebs, disk, gcs           → getStoragePrice
-   *   lb, load-balancer, alb, nlb       → getLoadBalancerPrice
-   *   nat, nat-gateway                  → getNatGatewayPrice
-   *   k8s, kubernetes, eks, aks, gke    → getKubernetesPrice
-   */
-  async getPrice(provider, service, resourceType, region, attributes = {}) {
-    const p = this.getProvider(provider);
-    const svc = service.toLowerCase();
-    logger.debug("PricingEngine.getPrice", {
-      provider,
-      service,
-      resourceType,
-      region
-    });
-    if (svc === "compute" || svc === "ec2" || svc === "vm" || svc === "instance" || svc === "virtual-machines") {
-      return p.getComputePrice(resourceType, region, attributes.os);
-    }
-    if (svc === "database" || svc === "rds" || svc === "sql" || svc === "db" || svc === "cloud-sql" || svc === "azure-database") {
-      return p.getDatabasePrice(resourceType, region, attributes.engine);
-    }
-    if (svc === "storage" || svc === "ebs" || svc === "disk" || svc === "gcs" || svc === "managed-disks" || svc === "persistent-disk" || svc === "cloud-storage") {
-      const sizeGb = attributes.size_gb ? parseFloat(attributes.size_gb) : void 0;
-      return p.getStoragePrice(resourceType, region, sizeGb);
-    }
-    if (svc === "lb" || svc === "load-balancer" || svc === "alb" || svc === "nlb" || svc === "elb" || svc === "cloud-load-balancing") {
-      return p.getLoadBalancerPrice(resourceType, region);
-    }
-    if (svc === "nat" || svc === "nat-gateway" || svc === "cloud-nat") {
-      return p.getNatGatewayPrice(region);
-    }
-    if (svc === "k8s" || svc === "kubernetes" || svc === "eks" || svc === "aks" || svc === "gke") {
-      return p.getKubernetesPrice(region);
-    }
-    logger.warn("PricingEngine: unrecognised service", { service, provider });
-    return null;
-  }
-};
-
-// src/tools/analyze-terraform.ts
-import { z } from "zod";
-
-// src/parsers/hcl-parser.ts
-import { parse } from "@cdktf/hcl2json";
-async function parseHclToJson(hclContent, filename = "main.tf") {
-  if (!hclContent.trim()) {
-    logger.debug("Received empty HCL content, returning empty object", {
-      filename
-    });
-    return {};
-  }
-  try {
-    const result = await parse(filename, hclContent);
-    logger.debug("Parsed HCL successfully", { filename });
-    return result;
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    logger.error("Failed to parse HCL", { filename, error: message });
-    throw new Error(
-      `HCL parse error in "${filename}": ${message}`
-    );
-  }
-}
-
-// src/parsers/variable-resolver.ts
-function resolveVariables(hclJson, tfvarsContent) {
-  const defaults = extractVariableDefaults(hclJson);
-  const overrides = tfvarsContent ? parseTfvars(tfvarsContent) : {};
-  const resolved = { ...defaults, ...overrides };
-  logger.debug("Resolved variables", {
-    defaultCount: Object.keys(defaults).length,
-    overrideCount: Object.keys(overrides).length
-  });
-  return resolved;
-}
-function extractVariableDefaults(hclJson) {
-  const defaults = {};
-  const variableBlock = hclJson["variable"];
-  if (!variableBlock || typeof variableBlock !== "object") {
-    return defaults;
-  }
-  for (const [varName, declarations] of Object.entries(
-    variableBlock
-  )) {
-    if (!Array.isArray(declarations) || declarations.length === 0) continue;
-    const declaration = declarations[0];
-    if ("default" in declaration) {
-      defaults[varName] = declaration["default"];
-    }
-  }
-  return defaults;
-}
-function parseTfvars(content) {
-  const result = {};
-  for (const rawLine of content.split("\n")) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("#")) continue;
-    const eqIndex = line.indexOf("=");
-    if (eqIndex === -1) continue;
-    const key = line.slice(0, eqIndex).trim();
-    const rawValue = line.slice(eqIndex + 1).trim();
-    if (!key) continue;
-    result[key] = parseTfvarsValue(rawValue);
-  }
-  return result;
-}
-function parseTfvarsValue(raw) {
-  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
-    return raw.slice(1, -1);
-  }
-  if (raw === "true") return true;
-  if (raw === "false") return false;
-  if (raw === "null") return null;
-  if (/^-?\d+$/.test(raw)) return parseInt(raw, 10);
-  if (/^-?\d+\.\d+$/.test(raw)) return parseFloat(raw);
-  return raw;
-}
-function substituteVariables(value, variables) {
-  if (typeof value === "string") {
-    return substituteInString(value, variables);
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => substituteVariables(item, variables));
-  }
-  if (value !== null && typeof value === "object") {
-    const result = {};
-    for (const [k, v] of Object.entries(value)) {
-      result[k] = substituteVariables(v, variables);
-    }
-    return result;
-  }
-  return value;
-}
-var VAR_ONLY_RE = /^\$\{var\.([^}]+)\}$/;
-var VAR_INLINE_RE = /\$\{var\.([^}]+)\}/g;
-function substituteInString(str2, variables) {
-  const wholeMatch = VAR_ONLY_RE.exec(str2);
-  if (wholeMatch) {
-    const varName = wholeMatch[1];
-    return varName in variables ? variables[varName] : str2;
-  }
-  return str2.replace(VAR_INLINE_RE, (_match, varName) => {
-    if (varName in variables) {
-      const v = variables[varName];
-      return v === null ? "" : String(v);
-    }
-    return _match;
-  });
-}
-
-// src/parsers/provider-detector.ts
-var PROVIDER_PREFIXES = [
-  ["aws_", "aws"],
-  ["azurerm_", "azure"],
-  ["google_", "gcp"]
-];
-function detectProvider(resourceType) {
-  for (const [prefix, provider] of PROVIDER_PREFIXES) {
-    if (resourceType.startsWith(prefix)) {
-      return provider;
-    }
-  }
-  throw new Error(
-    `Cannot determine cloud provider for resource type "${resourceType}". Supported prefixes: aws_, azurerm_, google_`
-  );
-}
-
-// src/parsers/resource-extractor.ts
-function detectRegionFromProviders(hclJson, provider, variables) {
-  const defaults = {
-    aws: "us-east-1",
-    azure: "eastus",
-    gcp: "us-central1"
-  };
-  const providerBlock = hclJson["provider"];
-  if (!providerBlock || typeof providerBlock !== "object") {
-    return defaults[provider];
-  }
-  const providerKeyMap = {
-    aws: "aws",
-    azure: "azurerm",
-    gcp: "google"
-  };
-  const key = providerKeyMap[provider];
-  const declarations = providerBlock[key];
-  if (!Array.isArray(declarations) || declarations.length === 0) {
-    return defaults[provider];
-  }
-  const declaration = declarations[0];
-  const regionAttr = provider === "azure" ? "location" : "region";
-  const rawRegion = declaration[regionAttr];
-  if (!rawRegion) return defaults[provider];
-  const resolved = substituteVariables(rawRegion, variables);
-  if (typeof resolved === "string" && resolved && !resolved.startsWith("${")) {
-    return resolved;
-  }
-  return defaults[provider];
-}
-function firstBlock(block, key) {
-  const nested = block[key];
-  if (Array.isArray(nested) && nested.length > 0) {
-    return nested[0];
-  }
-  return {};
-}
-function str(v) {
-  return typeof v === "string" && v ? v : void 0;
-}
-function num(v) {
-  if (typeof v === "number") return v;
-  if (typeof v === "string") {
-    const n = Number(v);
-    return isNaN(n) ? void 0 : n;
-  }
-  return void 0;
-}
-function bool(v) {
-  if (typeof v === "boolean") return v;
-  if (v === "true") return true;
-  if (v === "false") return false;
-  return void 0;
-}
-var extractors = {
-  aws_instance(block) {
-    const root = firstBlock(block, "root_block_device");
-    const attrs = {};
-    if (str(block["instance_type"])) attrs.instance_type = str(block["instance_type"]);
-    if (str(block["ami"])) attrs.ami = str(block["ami"]);
-    if (str(block["availability_zone"])) attrs.availability_zone = str(block["availability_zone"]);
-    if (root["volume_type"]) attrs.storage_type = str(root["volume_type"]);
-    if (root["volume_size"] !== void 0) attrs.storage_size_gb = num(root["volume_size"]);
-    if (root["iops"] !== void 0) attrs.iops = num(root["iops"]);
-    if (root["throughput"] !== void 0) attrs.throughput_mbps = num(root["throughput"]);
-    return attrs;
-  },
-  aws_db_instance(block) {
-    const attrs = {};
-    if (str(block["instance_class"])) attrs.instance_type = str(block["instance_class"]);
-    if (str(block["engine"])) attrs.engine = str(block["engine"]);
-    if (str(block["engine_version"])) attrs.engine_version = str(block["engine_version"]);
-    if (str(block["storage_type"])) attrs.storage_type = str(block["storage_type"]);
-    if (block["allocated_storage"] !== void 0) attrs.storage_size_gb = num(block["allocated_storage"]);
-    if (block["iops"] !== void 0) attrs.iops = num(block["iops"]);
-    if (block["multi_az"] !== void 0) attrs.multi_az = bool(block["multi_az"]);
-    if (block["replicas"] !== void 0) attrs.replicas = num(block["replicas"]);
-    return attrs;
-  },
-  aws_rds_cluster(block) {
-    const attrs = {};
-    if (str(block["engine"])) attrs.engine = str(block["engine"]);
-    if (str(block["engine_version"])) attrs.engine_version = str(block["engine_version"]);
-    if (str(block["db_cluster_instance_class"])) attrs.instance_type = str(block["db_cluster_instance_class"]);
-    if (block["master_username"]) attrs.master_username = str(block["master_username"]);
-    return attrs;
-  },
-  aws_s3_bucket(block) {
-    const attrs = {};
-    const lifecycle = firstBlock(block, "lifecycle_rule");
-    const transition = firstBlock(lifecycle, "transition");
-    if (str(transition["storage_class"])) attrs.storage_type = str(transition["storage_class"]);
-    if (str(block["bucket"])) attrs.bucket = str(block["bucket"]);
-    return attrs;
-  },
-  aws_lb(block) {
-    const attrs = {};
-    if (str(block["load_balancer_type"])) attrs.load_balancer_type = str(block["load_balancer_type"]);
-    if (block["internal"] !== void 0) attrs.internal = bool(block["internal"]);
-    return attrs;
-  },
-  aws_alb(block) {
-    return extractors["aws_lb"](block);
-  },
-  aws_nat_gateway(block) {
-    const attrs = {};
-    if (str(block["allocation_id"])) attrs.allocation_id = str(block["allocation_id"]);
-    return attrs;
-  },
-  aws_eks_cluster(block) {
-    const attrs = {};
-    if (str(block["name"])) attrs.cluster_name = str(block["name"]);
-    return attrs;
-  },
-  aws_eks_node_group(block) {
-    const scaling = firstBlock(block, "scaling_config");
-    const attrs = {};
-    const instanceTypes = block["instance_types"];
-    if (Array.isArray(instanceTypes) && instanceTypes.length > 0) {
-      attrs.instance_type = str(instanceTypes[0]);
-    }
-    if (scaling["desired_size"] !== void 0) attrs.node_count = num(scaling["desired_size"]);
-    if (scaling["min_size"] !== void 0) attrs.min_node_count = num(scaling["min_size"]);
-    if (scaling["max_size"] !== void 0) attrs.max_node_count = num(scaling["max_size"]);
-    return attrs;
-  },
-  aws_elasticache_cluster(block) {
-    const attrs = {};
-    if (str(block["node_type"])) attrs.instance_type = str(block["node_type"]);
-    if (str(block["engine"])) attrs.engine = str(block["engine"]);
-    if (block["num_cache_nodes"] !== void 0) attrs.node_count = num(block["num_cache_nodes"]);
-    return attrs;
-  },
-  aws_elasticache_replication_group(block) {
-    const attrs = {};
-    if (str(block["node_type"])) attrs.instance_type = str(block["node_type"]);
-    if (block["num_cache_clusters"] !== void 0) attrs.node_count = num(block["num_cache_clusters"]);
-    return attrs;
-  },
-  aws_ebs_volume(block) {
-    const attrs = {};
-    if (str(block["type"])) attrs.storage_type = str(block["type"]);
-    if (block["size"] !== void 0) attrs.storage_size_gb = num(block["size"]);
-    if (block["iops"] !== void 0) attrs.iops = num(block["iops"]);
-    if (block["throughput"] !== void 0) attrs.throughput_mbps = num(block["throughput"]);
-    return attrs;
-  },
-  aws_lambda_function(block) {
-    const attrs = {};
-    if (block["memory_size"] !== void 0) attrs.memory_size = num(block["memory_size"]);
-    if (block["timeout"] !== void 0) attrs.timeout = num(block["timeout"]);
-    if (str(block["architecture"])) {
-      attrs.architecture = str(block["architecture"]);
-    } else {
-      const arch = block["architectures"];
-      if (Array.isArray(arch) && arch.length > 0) {
-        attrs.architecture = str(arch[0]);
-      }
-    }
-    if (str(block["runtime"])) attrs.runtime = str(block["runtime"]);
-    return attrs;
-  },
-  aws_dynamodb_table(block) {
-    const attrs = {};
-    if (str(block["billing_mode"])) attrs.billing_mode = str(block["billing_mode"]);
-    if (block["read_capacity"] !== void 0) attrs.read_capacity = num(block["read_capacity"]);
-    if (block["write_capacity"] !== void 0) attrs.write_capacity = num(block["write_capacity"]);
-    return attrs;
-  },
-  aws_efs_file_system(block) {
-    const attrs = {};
-    if (str(block["performance_mode"])) attrs.performance_mode = str(block["performance_mode"]);
-    if (str(block["throughput_mode"])) attrs.throughput_mode = str(block["throughput_mode"]);
-    return attrs;
-  },
-  aws_cloudfront_distribution(block) {
-    const attrs = {};
-    if (str(block["price_class"])) attrs.price_class = str(block["price_class"]);
-    return attrs;
-  },
-  aws_sqs_queue(block) {
-    const attrs = {};
-    if (block["fifo_queue"] !== void 0) attrs.fifo_queue = bool(block["fifo_queue"]);
-    return attrs;
-  },
-  // ---------------------------------------------------------------------------
-  // Azure
-  // ---------------------------------------------------------------------------
-  azurerm_virtual_machine(block) {
-    const attrs = {};
-    if (str(block["vm_size"])) attrs.vm_size = str(block["vm_size"]);
-    if (str(block["location"])) attrs.location = str(block["location"]);
-    return attrs;
-  },
-  azurerm_linux_virtual_machine(block) {
-    const attrs = {};
-    if (str(block["size"])) attrs.vm_size = str(block["size"]);
-    if (str(block["location"])) attrs.location = str(block["location"]);
-    return attrs;
-  },
-  azurerm_windows_virtual_machine(block) {
-    const attrs = {};
-    if (str(block["size"])) attrs.vm_size = str(block["size"]);
-    if (str(block["location"])) attrs.location = str(block["location"]);
-    attrs.os = "Windows";
-    return attrs;
-  },
-  azurerm_managed_disk(block) {
-    const attrs = {};
-    if (str(block["storage_account_type"])) attrs.storage_type = str(block["storage_account_type"]);
-    if (block["disk_size_gb"] !== void 0) attrs.storage_size_gb = num(block["disk_size_gb"]);
-    if (block["disk_iops_read_write"] !== void 0) attrs.iops = num(block["disk_iops_read_write"]);
-    if (str(block["location"])) attrs.location = str(block["location"]);
-    return attrs;
-  },
-  azurerm_sql_server(block) {
-    const attrs = {};
-    if (str(block["version"])) attrs.engine_version = str(block["version"]);
-    if (str(block["location"])) attrs.location = str(block["location"]);
-    return attrs;
-  },
-  azurerm_mssql_database(block) {
-    const attrs = {};
-    if (str(block["sku_name"])) attrs.sku = str(block["sku_name"]);
-    if (block["max_size_gb"] !== void 0) attrs.storage_size_gb = num(block["max_size_gb"]);
-    return attrs;
-  },
-  azurerm_kubernetes_cluster(block) {
-    const defaultPool = firstBlock(block, "default_node_pool");
-    const attrs = {};
-    if (str(defaultPool["vm_size"])) attrs.vm_size = str(defaultPool["vm_size"]);
-    if (defaultPool["node_count"] !== void 0) attrs.node_count = num(defaultPool["node_count"]);
-    if (defaultPool["min_count"] !== void 0) attrs.min_node_count = num(defaultPool["min_count"]);
-    if (defaultPool["max_count"] !== void 0) attrs.max_node_count = num(defaultPool["max_count"]);
-    if (str(block["location"])) attrs.location = str(block["location"]);
-    return attrs;
-  },
-  azurerm_cosmosdb_account(block) {
-    const attrs = {};
-    if (str(block["offer_type"])) attrs.offer_type = str(block["offer_type"]);
-    if (str(block["kind"])) attrs.kind = str(block["kind"]);
-    const capabilities = block["capabilities"];
-    if (Array.isArray(capabilities)) {
-      const capNames = capabilities.map((c) => typeof c === "object" && c !== null ? str(c["name"]) : void 0).filter((n) => n !== void 0);
-      if (capNames.length > 0) attrs.capabilities = capNames;
-    }
-    return attrs;
-  },
-  azurerm_app_service_plan(block) {
-    const attrs = {};
-    const skuBlock = firstBlock(block, "sku");
-    if (str(skuBlock["tier"])) attrs.sku_tier = str(skuBlock["tier"]);
-    if (str(skuBlock["size"])) attrs.sku_size = str(skuBlock["size"]);
-    if (str(block["sku_name"])) attrs.sku = str(block["sku_name"]);
-    return attrs;
-  },
-  azurerm_function_app(block) {
-    const attrs = {};
-    if (str(block["app_service_plan_id"])) attrs.app_service_plan_id = str(block["app_service_plan_id"]);
-    return attrs;
-  },
-  azurerm_redis_cache(block) {
-    const attrs = {};
-    if (block["capacity"] !== void 0) attrs.capacity = num(block["capacity"]);
-    if (str(block["family"])) attrs.family = str(block["family"]);
-    if (str(block["sku_name"])) attrs.sku = str(block["sku_name"]);
-    return attrs;
-  },
-  azurerm_cosmosdb_sql_database(block) {
-    const attrs = {};
-    if (block["throughput"] !== void 0) attrs.throughput = num(block["throughput"]);
-    return attrs;
-  },
-  azurerm_storage_account(block) {
-    const attrs = {};
-    if (str(block["account_tier"])) attrs.account_tier = str(block["account_tier"]);
-    if (str(block["account_replication_type"])) attrs.account_replication_type = str(block["account_replication_type"]);
-    return attrs;
-  },
-  // ---------------------------------------------------------------------------
-  // GCP
-  // ---------------------------------------------------------------------------
-  google_compute_instance(block) {
-    const attrs = {};
-    if (str(block["machine_type"])) attrs.machine_type = str(block["machine_type"]);
-    if (str(block["zone"])) attrs.zone = str(block["zone"]);
-    const boot = firstBlock(block, "boot_disk");
-    const initParams = firstBlock(boot, "initialize_params");
-    if (str(initParams["type"])) attrs.storage_type = str(initParams["type"]);
-    if (initParams["size"] !== void 0) attrs.storage_size_gb = num(initParams["size"]);
-    return attrs;
-  },
-  google_compute_disk(block) {
-    const attrs = {};
-    if (str(block["type"])) attrs.storage_type = str(block["type"]);
-    if (block["size"] !== void 0) attrs.storage_size_gb = num(block["size"]);
-    if (str(block["zone"])) attrs.zone = str(block["zone"]);
-    return attrs;
-  },
-  google_sql_database_instance(block) {
-    const settings = firstBlock(block, "settings");
-    const attrs = {};
-    if (str(settings["tier"])) attrs.tier = str(settings["tier"]);
-    if (str(block["database_version"])) attrs.engine = str(block["database_version"]);
-    if (str(block["region"])) attrs.region_attr = str(block["region"]);
-    const dataCacheConfig = firstBlock(settings, "data_cache_config");
-    if (dataCacheConfig["data_cache_enabled"] !== void 0) {
-      attrs.data_cache_enabled = bool(dataCacheConfig["data_cache_enabled"]);
-    }
-    return attrs;
-  },
-  google_container_cluster(block) {
-    const nodeConfig = firstBlock(block, "node_config");
-    const attrs = {};
-    if (str(nodeConfig["machine_type"])) attrs.machine_type = str(nodeConfig["machine_type"]);
-    if (block["initial_node_count"] !== void 0) attrs.node_count = num(block["initial_node_count"]);
-    if (str(block["location"])) attrs.zone = str(block["location"]);
-    return attrs;
-  },
-  google_container_node_pool(block) {
-    const nodeConfig = firstBlock(block, "node_config");
-    const autoscaling = firstBlock(block, "autoscaling");
-    const attrs = {};
-    if (str(nodeConfig["machine_type"])) attrs.machine_type = str(nodeConfig["machine_type"]);
-    if (block["node_count"] !== void 0) attrs.node_count = num(block["node_count"]);
-    if (autoscaling["min_node_count"] !== void 0) attrs.min_node_count = num(autoscaling["min_node_count"]);
-    if (autoscaling["max_node_count"] !== void 0) attrs.max_node_count = num(autoscaling["max_node_count"]);
-    return attrs;
-  },
-  google_cloud_run_service(block) {
-    const attrs = {};
-    const template = firstBlock(block, "template");
-    const spec = firstBlock(template, "spec");
-    const container = firstBlock(spec, "containers");
-    const resources = firstBlock(container, "resources");
-    const limits = firstBlock(resources, "limits");
-    if (str(limits["cpu"])) attrs.cpu = str(limits["cpu"]);
-    if (str(limits["memory"])) attrs.memory = str(limits["memory"]);
-    return attrs;
-  },
-  google_cloudfunctions_function(block) {
-    const attrs = {};
-    if (str(block["runtime"])) attrs.runtime = str(block["runtime"]);
-    if (block["available_memory_mb"] !== void 0) attrs.memory_size = num(block["available_memory_mb"]);
-    return attrs;
-  },
-  google_bigquery_dataset(block) {
-    const attrs = {};
-    if (str(block["location"])) attrs.location = str(block["location"]);
-    return attrs;
-  },
-  google_redis_instance(block) {
-    const attrs = {};
-    if (str(block["tier"])) attrs.tier = str(block["tier"]);
-    if (block["memory_size_gb"] !== void 0) attrs.memory_size = num(block["memory_size_gb"]);
-    return attrs;
-  },
-  google_artifact_registry_repository(block) {
-    const attrs = {};
-    if (str(block["format"])) attrs.format = str(block["format"]);
-    return attrs;
-  }
-};
-function regionFromResourceBlock(resourceType, block, provider) {
-  switch (provider) {
-    case "azure": {
-      const loc = str(block["location"]);
-      return loc && !loc.startsWith("${") ? loc : void 0;
-    }
-    case "gcp": {
-      const zone = str(block["zone"]);
-      if (zone && !zone.startsWith("${")) {
-        const parts = zone.split("-");
-        return parts.length > 2 ? parts.slice(0, -1).join("-") : zone;
-      }
-      return str(block["region"]);
-    }
-    case "aws": {
-      const az = str(block["availability_zone"]);
-      if (az && !az.startsWith("${")) {
-        const parts = az.split("-");
-        return parts.length > 2 ? parts.slice(0, -1).join("-") : az;
-      }
-      return void 0;
-    }
-  }
-}
-function extractTags(block) {
-  const tags = block["tags"];
-  if (!tags || typeof tags !== "object" || Array.isArray(tags)) return {};
-  const result = {};
-  for (const [k, v] of Object.entries(tags)) {
-    if (typeof v === "string") result[k] = v;
-    else if (v !== null && v !== void 0) result[k] = String(v);
-  }
-  return result;
-}
-function resolveCount(rawCount, resourceId, warnings) {
-  const n = num(rawCount);
-  if (n !== void 0 && Number.isInteger(n) && n >= 0) return n;
-  warnings.push(
-    `Resource "${resourceId}" has a count that could not be resolved to a number. Defaulting to 1.`
-  );
-  return 1;
-}
-function resolveForEachKeys(rawForEach, resourceId, warnings) {
-  if (rawForEach && typeof rawForEach === "object" && !Array.isArray(rawForEach)) {
-    const keys = Object.keys(rawForEach);
-    if (keys.length > 0) return keys;
-  }
-  if (Array.isArray(rawForEach) && rawForEach.length > 0) {
-    return rawForEach.map(
-      (v, i) => typeof v === "string" ? v : typeof v === "number" ? String(v) : String(i)
-    );
-  }
-  warnings.push(
-    `Resource "${resourceId}" has a for_each that could not be resolved. Defaulting to 1 instance.`
-  );
-  return ["0"];
-}
-function extractResources(hclJson, variables, sourceFile, defaultRegions = {}, warnings = []) {
-  const resources = [];
-  const moduleBlock = hclJson["module"];
-  if (moduleBlock && typeof moduleBlock === "object" && !Array.isArray(moduleBlock)) {
-    for (const moduleName of Object.keys(moduleBlock)) {
-      warnings.push(
-        `Module "${moduleName}" detected but not expanded. Resources inside modules are not included in the estimate.`
-      );
-      logger.debug("Module detected, skipping expansion", { moduleName });
-    }
-  }
-  const resourceBlock = hclJson["resource"];
-  if (!resourceBlock || typeof resourceBlock !== "object") {
-    return resources;
-  }
-  for (const [resourceType, instances] of Object.entries(
-    resourceBlock
-  )) {
-    let provider;
-    try {
-      provider = detectProvider(resourceType);
-    } catch {
-      logger.warn("Skipping resource with unknown provider prefix", {
-        resourceType
-      });
-      continue;
-    }
-    if (!instances || typeof instances !== "object" || Array.isArray(instances)) {
-      continue;
-    }
-    for (const [resourceName, blockList] of Object.entries(
-      instances
-    )) {
-      if (!Array.isArray(blockList) || blockList.length === 0) continue;
-      const rawBlock = blockList[0];
-      const block = substituteVariables(rawBlock, variables);
-      const resourceRegion = regionFromResourceBlock(resourceType, block, provider);
-      const region = resourceRegion ?? defaultRegions[provider] ?? (provider === "aws" ? "us-east-1" : provider === "azure" ? "eastus" : "us-central1");
-      const extractor = extractors[resourceType];
-      const attributes = extractor ? extractor(block) : {};
-      const tags = extractTags(block);
-      const baseId = `${resourceType}.${resourceName}`;
-      const rawCount = block["count"];
-      const rawForEach = block["for_each"];
-      if (rawCount !== void 0) {
-        const count = resolveCount(rawCount, baseId, warnings);
-        for (let i = 0; i < count; i++) {
-          resources.push({
-            id: `${baseId}[${i}]`,
-            type: resourceType,
-            name: resourceName,
-            provider,
-            region,
-            attributes,
-            tags,
-            source_file: sourceFile
-          });
-        }
-      } else if (rawForEach !== void 0) {
-        const keys = resolveForEachKeys(rawForEach, baseId, warnings);
-        for (const key of keys) {
-          resources.push({
-            id: `${baseId}["${key}"]`,
-            type: resourceType,
-            name: resourceName,
-            provider,
-            region,
-            attributes,
-            tags,
-            source_file: sourceFile
-          });
-        }
-      } else {
-        resources.push({
-          id: baseId,
-          type: resourceType,
-          name: resourceName,
-          provider,
-          region,
-          attributes,
-          tags,
-          source_file: sourceFile
-        });
-      }
-      logger.debug("Extracted resource", {
-        id: baseId,
-        region,
-        provider
-      });
-    }
-  }
-  return resources;
-}
-
-// src/parsers/index.ts
-var PROVIDER_DEFAULTS = {
-  aws: "us-east-1",
-  azure: "eastus",
-  gcp: "us-central1"
-};
-function inferDominantProvider(resources) {
-  if (resources.length === 0) return "aws";
-  const counts = {};
-  for (const r of resources) {
-    counts[r.provider] = (counts[r.provider] ?? 0) + 1;
-  }
-  let dominant = "aws";
-  let max = 0;
-  for (const [p, c] of Object.entries(counts)) {
-    if (c > max) {
-      max = c;
-      dominant = p;
-    }
-  }
-  return dominant;
-}
-async function parseTerraform(files, tfvarsContent) {
-  const warnings = [];
-  const parsedJsons = [];
-  for (const file of files) {
-    try {
-      const json = await parseHclToJson(file.content, file.path);
-      parsedJsons.push({ path: file.path, json });
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      warnings.push(`Parse error in ${file.path}: ${msg}`);
-      logger.warn("Skipping file due to parse error", {
-        path: file.path,
-        error: msg
-      });
-    }
-  }
-  if (parsedJsons.length === 0) {
-    logger.warn("No files were successfully parsed");
-    return {
-      provider: "aws",
-      region: PROVIDER_DEFAULTS["aws"],
-      resources: [],
-      total_count: 0,
-      by_type: {},
-      parse_warnings: warnings
-    };
-  }
-  const combined = mergeHclJsons(parsedJsons.map((p) => p.json));
-  const variables = resolveVariables(combined, tfvarsContent);
-  const providers = ["aws", "azure", "gcp"];
-  const defaultRegions = {};
-  for (const p of providers) {
-    defaultRegions[p] = detectRegionFromProviders(combined, p, variables);
-  }
-  const allResources = [];
-  for (const { path, json } of parsedJsons) {
-    try {
-      const resources = extractResources(json, variables, path, defaultRegions, warnings);
-      allResources.push(...resources);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      warnings.push(`Extraction error in ${path}: ${msg}`);
-      logger.warn("Resource extraction failed", { path, error: msg });
-    }
-  }
-  const dominantProvider = inferDominantProvider(allResources);
-  const dominantRegion = defaultRegions[dominantProvider] ?? PROVIDER_DEFAULTS[dominantProvider];
-  const byType = {};
-  for (const r of allResources) {
-    byType[r.type] = (byType[r.type] ?? 0) + 1;
-  }
-  const inventory = {
-    provider: dominantProvider,
-    region: dominantRegion,
-    resources: allResources,
-    total_count: allResources.length,
-    by_type: byType,
-    parse_warnings: warnings
-  };
-  logger.info("Terraform parse complete", {
-    fileCount: files.length,
-    resourceCount: allResources.length,
-    provider: dominantProvider,
-    region: dominantRegion,
-    warningCount: warnings.length
-  });
-  return inventory;
-}
-function mergeHclJsons(jsons) {
-  const merged = {};
-  for (const json of jsons) {
-    for (const [key, value] of Object.entries(json)) {
-      if (!(key in merged)) {
-        merged[key] = deepClone(value);
-        continue;
-      }
-      const existing = merged[key];
-      if (value !== null && typeof value === "object" && !Array.isArray(value) && existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
-        merged[key] = mergeObjects(
-          existing,
-          value
-        );
-      } else if (Array.isArray(existing) && Array.isArray(value)) {
-        merged[key] = [...existing, ...value];
-      } else {
-        merged[key] = deepClone(value);
-      }
-    }
-  }
-  return merged;
-}
-function mergeObjects(a, b) {
-  const result = { ...a };
-  for (const [key, bVal] of Object.entries(b)) {
-    const aVal = result[key];
-    if (aVal !== null && typeof aVal === "object" && !Array.isArray(aVal) && bVal !== null && typeof bVal === "object" && !Array.isArray(bVal)) {
-      result[key] = mergeObjects(
-        aVal,
-        bVal
-      );
-    } else if (Array.isArray(aVal) && Array.isArray(bVal)) {
-      result[key] = [...aVal, ...bVal];
-    } else {
-      result[key] = deepClone(bVal);
-    }
-  }
-  return result;
-}
-function deepClone(value) {
-  if (value === null || typeof value !== "object") return value;
-  return JSON.parse(JSON.stringify(value));
-}
-
-// src/tools/analyze-terraform.ts
-var analyzeTerraformSchema = z.object({
-  files: z.array(
-    z.object({
-      path: z.string().describe("File path"),
-      content: z.string().describe("File content (HCL)")
-    })
-  ).describe("Terraform files to analyze"),
-  tfvars: z.string().optional().describe("Contents of terraform.tfvars file")
-});
-async function analyzeTerraform(params) {
-  const inventory = await parseTerraform(params.files, params.tfvars);
-  const { parse_warnings, ...rest } = inventory;
-  return {
-    parse_warnings,
-    has_warnings: parse_warnings.length > 0,
-    ...rest
-  };
-}
-
-// src/tools/estimate-cost.ts
-import { z as z2 } from "zod";
-
-// src/mapping/region-mapper.ts
-var DEFAULT_REGIONS = {
-  aws: "us-east-1",
-  azure: "eastus",
-  gcp: "us-central1"
-};
-function mapRegion(region, sourceProvider, targetProvider) {
-  if (sourceProvider === targetProvider) return region;
-  const mappings = getRegionMappings();
-  const row = mappings.find(
-    (entry) => entry[sourceProvider] === region
-  );
-  if (!row) {
-    const fallback = DEFAULT_REGIONS[targetProvider];
-    logger.debug("region-mapper: no mapping found, using default", {
-      region,
-      sourceProvider,
-      targetProvider,
-      fallback
-    });
-    return fallback;
-  }
-  const mapped = row[targetProvider];
-  if (!mapped) {
-    return DEFAULT_REGIONS[targetProvider];
-  }
-  return mapped;
-}
-
-// src/mapping/instance-mapper.ts
-function directionKey(source, target) {
-  if (source === target) return null;
-  return `${source}_to_${target}`;
-}
-function getSpecsForProvider(provider) {
-  switch (provider) {
-    case "aws":
-      return getAwsInstances();
-    case "azure":
-      return getAzureVmSizes();
-    case "gcp":
-      return getGcpMachineTypes();
-  }
-}
-var SCORE_EXACT_VCPU = 40;
-var SCORE_APPROX_VCPU = 20;
-var SCORE_EXACT_MEMORY = 40;
-var SCORE_APPROX_MEMORY = 20;
-var SCORE_CATEGORY = 20;
-function mapInstance(instanceType, sourceProvider, targetProvider) {
-  if (sourceProvider === targetProvider) return instanceType;
-  const key = directionKey(sourceProvider, targetProvider);
-  if (!key) return instanceType;
-  const instanceMap = getInstanceMap();
-  const directionalMap = instanceMap[key];
-  if (directionalMap) {
-    const exact = directionalMap[instanceType];
-    if (exact) {
-      logger.debug("instance-mapper: exact match", {
-        instanceType,
-        sourceProvider,
-        targetProvider,
-        result: exact
-      });
-      return exact;
-    }
-  }
-  const sourceSpecs = getSpecsForProvider(sourceProvider);
-  const sourceSpec = sourceSpecs.find(
-    (s) => s.instance_type === instanceType
-  );
-  if (!sourceSpec) {
-    logger.debug("instance-mapper: source spec not found, cannot map", {
-      instanceType,
-      sourceProvider
-    });
-    return null;
-  }
-  return findNearestInstance(
-    {
-      vcpus: sourceSpec.vcpus,
-      memory_gb: sourceSpec.memory_gb,
-      category: sourceSpec.category
-    },
-    targetProvider
-  );
-}
-function findNearestInstance(spec, targetProvider) {
-  const candidates = getSpecsForProvider(targetProvider);
-  if (candidates.length === 0) return null;
-  let bestScore = -1;
-  let bestType = null;
-  for (const candidate of candidates) {
-    let score = 0;
-    if (candidate.vcpus === spec.vcpus) {
-      score += SCORE_EXACT_VCPU;
-    } else {
-      const larger = Math.max(candidate.vcpus, spec.vcpus);
-      const smaller = Math.min(candidate.vcpus, spec.vcpus);
-      if (smaller > 0) {
-        score += SCORE_APPROX_VCPU * (smaller / larger);
-      }
-    }
-    if (candidate.memory_gb === spec.memory_gb) {
-      score += SCORE_EXACT_MEMORY;
-    } else {
-      const larger = Math.max(candidate.memory_gb, spec.memory_gb);
-      const smaller = Math.min(candidate.memory_gb, spec.memory_gb);
-      if (smaller > 0) {
-        score += SCORE_APPROX_MEMORY * (smaller / larger);
-      }
-    }
-    if (candidate.category === spec.category) {
-      score += SCORE_CATEGORY;
-    }
-    if (score > bestScore || score === bestScore && bestType !== null && candidate.instance_type < bestType) {
-      bestScore = score;
-      bestType = candidate.instance_type;
-    }
-  }
-  if (bestType) {
-    logger.debug("instance-mapper: nearest match found", {
-      spec,
-      targetProvider,
-      result: bestType,
-      score: bestScore
-    });
-  }
-  return bestType;
-}
-
-// src/mapping/storage-mapper.ts
-function mapStorageType(storageType, sourceProvider, targetProvider) {
-  if (sourceProvider === targetProvider) return storageType;
-  const { block_storage, object_storage } = getStorageMap();
-  const allEntries = [...block_storage, ...object_storage];
-  const row = allEntries.find(
-    (entry) => entry[sourceProvider] === storageType
-  );
-  if (!row) {
-    logger.debug("storage-mapper: no mapping found", {
-      storageType,
-      sourceProvider,
-      targetProvider
-    });
-    return null;
-  }
-  const mapped = row[targetProvider];
-  if (!mapped) {
-    logger.debug("storage-mapper: target column missing in row", {
-      storageType,
-      sourceProvider,
-      targetProvider
-    });
-    return null;
-  }
-  return mapped;
-}
-
-// src/calculator/compute.ts
-async function calculateComputeCost(resource, targetProvider, targetRegion, pricingEngine, monthlyHours = 730) {
-  const notes = [];
-  const breakdown = [];
-  const sourceInstanceType = resource.attributes.instance_type ?? resource.attributes.vm_size ?? resource.attributes.machine_type ?? "";
-  const mappedInstance = sourceInstanceType ? mapInstance(sourceInstanceType, resource.provider, targetProvider) : null;
-  let confidence = "low";
-  let specBasedMapping = false;
-  if (!mappedInstance) {
-    notes.push(
-      `No instance mapping found for ${sourceInstanceType} (${resource.provider} -> ${targetProvider})`
-    );
-  } else {
-    const { getInstanceMap: getInstanceMap2 } = await import("./loader-WIX54B7L.js");
-    const im = getInstanceMap2();
-    const dirKey = `${resource.provider}_to_${targetProvider}`;
-    const directMap = im[dirKey];
-    const isExact = directMap?.[sourceInstanceType] === mappedInstance;
-    confidence = isExact ? "high" : "medium";
-    if (!isExact) {
-      specBasedMapping = true;
-      notes.push(
-        `Instance mapping for ${sourceInstanceType} -> ${mappedInstance} is an approximate spec-based match`
-      );
-    }
-  }
-  const effectiveInstance = mappedInstance ?? sourceInstanceType;
-  const computePrice = effectiveInstance ? await pricingEngine.getProvider(targetProvider).getComputePrice(effectiveInstance, targetRegion, resource.attributes.os) : null;
-  let computeMonthlyCost = 0;
-  let pricingSource = "fallback";
-  if (computePrice) {
-    const rawSource = computePrice.attributes?.pricing_source;
-    if (rawSource === "bundled") {
-      pricingSource = "bundled";
-    } else if (rawSource === "fallback") {
-      pricingSource = "fallback";
-      notes.push(`Pricing for ${effectiveInstance} uses bundled fallback data (live API unavailable)`);
-    } else {
-      pricingSource = "live";
-    }
-    if (specBasedMapping) {
-      notes.push(`Spec-based instance mapping used: ${sourceInstanceType} -> ${mappedInstance}`);
-    }
-    const hourlyPrice = computePrice.price_per_unit;
-    computeMonthlyCost = hourlyPrice * monthlyHours;
-    breakdown.push({
-      description: `${effectiveInstance} compute (${monthlyHours}h/month)`,
-      unit: "Hrs",
-      quantity: monthlyHours,
-      unit_price: hourlyPrice,
-      monthly_cost: computeMonthlyCost
-    });
-  } else {
-    notes.push(`No pricing data found for ${resource.type} in ${targetRegion}`);
-    confidence = "low";
-    pricingSource = "fallback";
-  }
-  let storageMonthlyCost = 0;
-  const rootDisk = resource.attributes.root_block_device;
-  const storageType = rootDisk?.volume_type ?? resource.attributes.storage_type;
-  const storageSizeGb = rootDisk?.volume_size ?? resource.attributes.storage_size_gb;
-  if (storageType && storageSizeGb && storageSizeGb > 0) {
-    const mappedStorageType = mapStorageType(
-      storageType,
-      resource.provider,
-      targetProvider
-    ) ?? storageType;
-    const storagePrice = await pricingEngine.getProvider(targetProvider).getStoragePrice(mappedStorageType, targetRegion, storageSizeGb);
-    if (storagePrice) {
-      storageMonthlyCost = storagePrice.price_per_unit * storageSizeGb;
-      breakdown.push({
-        description: `Root disk ${mappedStorageType} (${storageSizeGb} GB)`,
-        unit: "GB-Mo",
-        quantity: storageSizeGb,
-        unit_price: storagePrice.price_per_unit,
-        monthly_cost: storageMonthlyCost
-      });
-    } else {
-      logger.debug("calculateComputeCost: no storage price found", {
-        mappedStorageType,
-        targetRegion
-      });
-    }
-  }
-  const totalMonthly = computeMonthlyCost + storageMonthlyCost;
-  return {
-    resource_id: resource.id,
-    resource_type: resource.type,
-    resource_name: resource.name,
-    provider: targetProvider,
-    region: targetRegion,
-    monthly_cost: totalMonthly,
-    yearly_cost: totalMonthly * 12,
-    currency: "USD",
-    breakdown,
-    confidence,
-    notes,
-    pricing_source: pricingSource
-  };
-}
-
-// src/calculator/database.ts
-function normalizeDbInstanceClass(instanceClass) {
-  return instanceClass.startsWith("db.") ? instanceClass.slice(3) : instanceClass;
-}
-async function calculateDatabaseCost(resource, targetProvider, targetRegion, pricingEngine, monthlyHours = 730) {
-  const notes = [];
-  const breakdown = [];
-  const sourceInstanceClass = resource.attributes.instance_class ?? resource.attributes.instance_type ?? resource.attributes.vm_size ?? resource.attributes.tier ?? "";
-  const isMultiAz = Boolean(resource.attributes.multi_az);
-  const allocatedStorageGb = resource.attributes.allocated_storage ?? resource.attributes.storage_size_gb ?? 0;
-  const engine = resource.attributes.engine ?? "MySQL";
-  const normalised = normalizeDbInstanceClass(sourceInstanceClass);
-  let mappedInstance = null;
-  if (targetProvider === "gcp") {
-    mappedInstance = mapInstance(sourceInstanceClass, resource.provider, "gcp");
-    if (!mappedInstance) {
-      mappedInstance = mapInstance(normalised, resource.provider, "gcp");
-    }
-    if (mappedInstance && !mappedInstance.startsWith("db-")) {
-      const dbMapped = mapInstance(sourceInstanceClass, resource.provider, "gcp");
-      if (dbMapped) mappedInstance = dbMapped;
-    }
-  } else if (targetProvider === "aws") {
-    mappedInstance = mapInstance(sourceInstanceClass, resource.provider, "aws");
-    if (!mappedInstance && normalised !== sourceInstanceClass) {
-      mappedInstance = mapInstance(normalised, resource.provider, "aws");
-    }
-    if (mappedInstance && !mappedInstance.startsWith("db.")) {
-      mappedInstance = `db.${mappedInstance}`;
-    }
-  } else {
-    mappedInstance = mapInstance(sourceInstanceClass, resource.provider, targetProvider);
-    if (!mappedInstance) {
-      mappedInstance = mapInstance(normalised, resource.provider, targetProvider);
-    }
-  }
-  const effectiveInstance = mappedInstance ?? sourceInstanceClass;
-  if (!mappedInstance) {
-    notes.push(
-      `No DB instance mapping found for ${sourceInstanceClass} (${resource.provider} -> ${targetProvider}); using source class`
-    );
-  }
-  const dbPrice = await pricingEngine.getProvider(targetProvider).getDatabasePrice(effectiveInstance, targetRegion, engine);
-  let instanceMonthlyCost = 0;
-  let pricingSource = "fallback";
-  if (dbPrice) {
-    const rawSource = dbPrice.attributes?.pricing_source;
-    if (rawSource === "bundled") {
-      pricingSource = "bundled";
-    } else if (rawSource === "fallback") {
-      pricingSource = "fallback";
-      notes.push(`Pricing for ${effectiveInstance} uses bundled fallback data (live API unavailable)`);
-    } else {
-      pricingSource = "live";
-    }
-    instanceMonthlyCost = dbPrice.price_per_unit * monthlyHours;
-    let haMultiplier = 1;
-    if (isMultiAz) {
-      if (targetProvider === "gcp") {
-        const gcpMult = parseFloat(
-          dbPrice.attributes?.ha_multiplier ?? "2"
-        );
-        haMultiplier = isNaN(gcpMult) ? 2 : gcpMult;
-      } else {
-        haMultiplier = 2;
-      }
-      notes.push(`Multi-AZ enabled: instance cost multiplied by ${haMultiplier}`);
-    }
-    const adjustedCost = instanceMonthlyCost * haMultiplier;
-    breakdown.push({
-      description: `${effectiveInstance} DB instance (${monthlyHours}h/month)${isMultiAz ? " x" + haMultiplier + " (Multi-AZ)" : ""}`,
-      unit: "Hrs",
-      quantity: monthlyHours * haMultiplier,
-      unit_price: dbPrice.price_per_unit,
-      monthly_cost: adjustedCost
-    });
-    instanceMonthlyCost = adjustedCost;
-  } else {
-    notes.push(`No pricing data found for ${resource.type} in ${targetRegion}`);
-    logger.debug("calculateDatabaseCost: no price", {
-      effectiveInstance,
-      targetRegion
-    });
-  }
-  let storageMonthlyCost = 0;
-  if (allocatedStorageGb > 0) {
-    const storageType = resource.attributes.storage_type ?? "gp3";
-    const storagePrice = await pricingEngine.getProvider(targetProvider).getStoragePrice(storageType, targetRegion, allocatedStorageGb);
-    if (storagePrice) {
-      storageMonthlyCost = storagePrice.price_per_unit * allocatedStorageGb;
-      breakdown.push({
-        description: `DB storage ${storageType} (${allocatedStorageGb} GB)`,
-        unit: "GB-Mo",
-        quantity: allocatedStorageGb,
-        unit_price: storagePrice.price_per_unit,
-        monthly_cost: storageMonthlyCost
-      });
-    }
-  }
-  const totalMonthly = instanceMonthlyCost + storageMonthlyCost;
-  return {
-    resource_id: resource.id,
-    resource_type: resource.type,
-    resource_name: resource.name,
-    provider: targetProvider,
-    region: targetRegion,
-    monthly_cost: totalMonthly,
-    yearly_cost: totalMonthly * 12,
-    currency: "USD",
-    breakdown,
-    confidence: mappedInstance ? "high" : "low",
-    notes,
-    pricing_source: pricingSource
-  };
-}
-
-// src/calculator/storage.ts
-var DEFAULT_OBJECT_STORAGE_GB = 100;
-var BLOCK_STORAGE_RESOURCE_TYPES = /* @__PURE__ */ new Set([
-  "aws_ebs_volume",
-  "azurerm_managed_disk",
-  "google_compute_disk"
-]);
-var BLOCK_STORAGE_FALLBACK = {
-  aws: "gp3",
-  azure: "Premium_LRS",
-  gcp: "pd-ssd"
-};
-function isBlockStorage(resource) {
-  return BLOCK_STORAGE_RESOURCE_TYPES.has(resource.type);
-}
-async function calculateStorageCost(resource, targetProvider, targetRegion, pricingEngine) {
-  const notes = [];
-  const breakdown = [];
-  const block = isBlockStorage(resource);
-  const sourceStorageType = resource.attributes.storage_type ?? resource.attributes.type ?? resource.attributes.storage_class ?? (block ? "gp3" : "STANDARD");
-  const mappedStorageType = mapStorageType(sourceStorageType, resource.provider, targetProvider) ?? sourceStorageType;
-  let sizeGb = resource.attributes.storage_size_gb ?? resource.attributes.disk_size_gb ?? resource.attributes.size;
-  if (!sizeGb || sizeGb <= 0) {
-    if (block) {
-      sizeGb = 8;
-      notes.push("No storage size specified; defaulting to 8 GB for block volume");
-    } else {
-      sizeGb = DEFAULT_OBJECT_STORAGE_GB;
-      notes.push(
-        `No storage size specified; assuming ${DEFAULT_OBJECT_STORAGE_GB} GB for object storage cost estimate`
-      );
-    }
-  }
-  let resolvedStorageType = mappedStorageType;
-  let storagePrice = await pricingEngine.getProvider(targetProvider).getStoragePrice(resolvedStorageType, targetRegion, sizeGb);
-  if (!storagePrice && !block) {
-    const fallbackType = BLOCK_STORAGE_FALLBACK[targetProvider];
-    if (fallbackType) {
-      storagePrice = await pricingEngine.getProvider(targetProvider).getStoragePrice(fallbackType, targetRegion, sizeGb);
-      if (storagePrice) {
-        resolvedStorageType = fallbackType;
-        notes.push(
-          `Object storage class "${mappedStorageType}" not directly priced; using ${fallbackType} rate as an approximation`
-        );
-      }
-    }
-  }
-  let totalMonthly = 0;
-  let pricingSource = "fallback";
-  if (storagePrice) {
-    const rawSource = storagePrice.attributes?.pricing_source;
-    if (rawSource === "bundled") {
-      pricingSource = "bundled";
-    } else if (rawSource === "fallback") {
-      pricingSource = "fallback";
-      notes.push(`Pricing for ${resolvedStorageType} uses bundled fallback data (live API unavailable)`);
-    } else {
-      pricingSource = "live";
-    }
-    totalMonthly = storagePrice.price_per_unit * sizeGb;
-    breakdown.push({
-      description: `${block ? "Block" : "Object"} storage ${resolvedStorageType} (${sizeGb} GB)`,
-      unit: "GB-Mo",
-      quantity: sizeGb,
-      unit_price: storagePrice.price_per_unit,
-      monthly_cost: totalMonthly
-    });
-  } else {
-    notes.push(
-      `No pricing data found for ${resource.type} in ${targetRegion}`
-    );
-    logger.debug("calculateStorageCost: no price", {
-      mappedStorageType,
-      targetRegion
-    });
-  }
-  return {
-    resource_id: resource.id,
-    resource_type: resource.type,
-    resource_name: resource.name,
-    provider: targetProvider,
-    region: targetRegion,
-    monthly_cost: totalMonthly,
-    yearly_cost: totalMonthly * 12,
-    currency: "USD",
-    breakdown,
-    confidence: storagePrice ? "high" : "low",
-    notes,
-    pricing_source: pricingSource
-  };
-}
-
-// src/calculator/network.ts
-var DEFAULT_NAT_DATA_GB = 100;
-async function calculateNatGatewayCost(resource, targetProvider, targetRegion, pricingEngine, monthlyHours = 730) {
-  const notes = [];
-  const breakdown = [];
-  const natPrice = await pricingEngine.getProvider(targetProvider).getNatGatewayPrice(targetRegion);
-  let totalMonthly = 0;
-  let natPricingSource = "fallback";
-  if (natPrice) {
-    const rawSource = natPrice.attributes?.pricing_source;
-    if (rawSource === "bundled") {
-      natPricingSource = "bundled";
-    } else if (rawSource === "fallback") {
-      natPricingSource = "fallback";
-    } else {
-      natPricingSource = "live";
-    }
-    const hourlyCharge = natPrice.price_per_unit * monthlyHours;
-    breakdown.push({
-      description: `NAT Gateway hourly charge (${monthlyHours}h/month)`,
-      unit: "Hrs",
-      quantity: monthlyHours,
-      unit_price: natPrice.price_per_unit,
-      monthly_cost: hourlyCharge
-    });
-    totalMonthly += hourlyCharge;
-    const perGbPrice = parseFloat(
-      natPrice.attributes?.per_gb_price ?? "0"
-    );
-    if (perGbPrice > 0) {
-      const dataGb = resource.attributes.data_processed_gb ?? DEFAULT_NAT_DATA_GB;
-      if (!resource.attributes.data_processed_gb || resource.attributes.data_processed_gb <= 0) {
-        notes.push(
-          `Data processing cost estimated at ${dataGb} GB/month; provide data_processed_gb attribute for accuracy`
-        );
-      }
-      const dataCharge = perGbPrice * dataGb;
-      breakdown.push({
-        description: `NAT Gateway data processing (${dataGb} GB/month)`,
-        unit: "GB",
-        quantity: dataGb,
-        unit_price: perGbPrice,
-        monthly_cost: dataCharge
-      });
-      totalMonthly += dataCharge;
-    }
-  } else {
-    notes.push(`No pricing data found for ${resource.type} in ${targetRegion}`);
-  }
-  return {
-    resource_id: resource.id,
-    resource_type: resource.type,
-    resource_name: resource.name,
-    provider: targetProvider,
-    region: targetRegion,
-    monthly_cost: totalMonthly,
-    yearly_cost: totalMonthly * 12,
-    currency: "USD",
-    breakdown,
-    confidence: natPrice ? "medium" : "low",
-    notes,
-    pricing_source: natPricingSource
-  };
-}
-async function calculateLoadBalancerCost(resource, targetProvider, targetRegion, pricingEngine, monthlyHours = 730) {
-  const notes = [];
-  const breakdown = [];
-  const lbType = resource.attributes.load_balancer_type ?? "application";
-  const lbPrice = await pricingEngine.getProvider(targetProvider).getLoadBalancerPrice(lbType, targetRegion);
-  let totalMonthly = 0;
-  let lbPricingSource = "fallback";
-  if (lbPrice) {
-    const rawSource = lbPrice.attributes?.pricing_source;
-    if (rawSource === "bundled") {
-      lbPricingSource = "bundled";
-    } else if (rawSource === "fallback") {
-      lbPricingSource = "fallback";
-    } else {
-      lbPricingSource = "live";
-    }
-    totalMonthly = lbPrice.price_per_unit * monthlyHours;
-    breakdown.push({
-      description: `Load Balancer hourly charge (${monthlyHours}h/month)`,
-      unit: "Hrs",
-      quantity: monthlyHours,
-      unit_price: lbPrice.price_per_unit,
-      monthly_cost: totalMonthly
-    });
-    notes.push(
-      "Traffic-based charges (LCU/data processing) are excluded; this is the fixed hourly component only"
-    );
-  } else {
-    notes.push(`No pricing data found for ${resource.type} in ${targetRegion}`);
-  }
-  return {
-    resource_id: resource.id,
-    resource_type: resource.type,
-    resource_name: resource.name,
-    provider: targetProvider,
-    region: targetRegion,
-    monthly_cost: totalMonthly,
-    yearly_cost: totalMonthly * 12,
-    currency: "USD",
-    breakdown,
-    confidence: lbPrice ? "medium" : "low",
-    notes,
-    pricing_source: lbPricingSource
-  };
-}
-
-// src/calculator/kubernetes.ts
-async function calculateKubernetesCost(resource, targetProvider, targetRegion, pricingEngine, monthlyHours = 730) {
-  const notes = [];
-  const breakdown = [];
-  const k8sPrice = await pricingEngine.getProvider(targetProvider).getKubernetesPrice(targetRegion);
-  let totalMonthly = 0;
-  let pricingSource = "fallback";
-  if (k8sPrice) {
-    const rawSource = k8sPrice.attributes?.pricing_source;
-    if (rawSource === "bundled") {
-      pricingSource = "bundled";
-    } else if (rawSource === "fallback") {
-      pricingSource = "fallback";
-    } else {
-      pricingSource = "live";
-    }
-    const controlPlaneCost = k8sPrice.price_per_unit * monthlyHours;
-    breakdown.push({
-      description: `Kubernetes control plane (${monthlyHours}h/month)`,
-      unit: "Hrs",
-      quantity: monthlyHours,
-      unit_price: k8sPrice.price_per_unit,
-      monthly_cost: controlPlaneCost
-    });
-    totalMonthly += controlPlaneCost;
-  } else {
-    notes.push(`No pricing data found for ${resource.type} in ${targetRegion}`);
-  }
-  const nodeCount = resource.attributes.node_count ?? resource.attributes.min_node_count;
-  if (nodeCount && nodeCount > 0) {
-    const nodeInstanceType = resource.attributes.instance_type ?? resource.attributes.vm_size ?? resource.attributes.machine_type;
-    if (nodeInstanceType) {
-      const nodeResource = {
-        ...resource,
-        id: `${resource.id}/node`,
-        type: "compute_node",
-        name: `${resource.name}-node`,
-        attributes: {
-          instance_type: nodeInstanceType,
-          vm_size: nodeInstanceType,
-          machine_type: nodeInstanceType
-        }
-      };
-      const nodeCostEstimate = await calculateComputeCost(
-        nodeResource,
-        targetProvider,
-        targetRegion,
-        pricingEngine,
-        monthlyHours
-      );
-      if (nodeCostEstimate.monthly_cost > 0) {
-        const nodeGroupCost = nodeCostEstimate.monthly_cost * nodeCount;
-        breakdown.push({
-          description: `${nodeCount}x node (${nodeInstanceType}) compute`,
-          unit: "nodes",
-          quantity: nodeCount,
-          unit_price: nodeCostEstimate.monthly_cost,
-          monthly_cost: nodeGroupCost
-        });
-        totalMonthly += nodeGroupCost;
-        notes.push(
-          `Node cost estimated for ${nodeCount} nodes of type ${nodeInstanceType}`
-        );
-      }
-    } else {
-      notes.push(
-        `node_count=${nodeCount} specified but no instance_type found; node compute cost excluded`
-      );
-    }
-  }
-  return {
-    resource_id: resource.id,
-    resource_type: resource.type,
-    resource_name: resource.name,
-    provider: targetProvider,
-    region: targetRegion,
-    monthly_cost: totalMonthly,
-    yearly_cost: totalMonthly * 12,
-    currency: "USD",
-    breakdown,
-    confidence: k8sPrice ? "medium" : "low",
-    notes,
-    pricing_source: pricingSource
-  };
-}
-
-// src/calculator/cost-engine.ts
-var COMPUTE_TYPES = /* @__PURE__ */ new Set([
-  "aws_instance",
-  "azurerm_linux_virtual_machine",
-  "azurerm_windows_virtual_machine",
-  "google_compute_instance",
-  // Node groups – cost their compute like VMs.
-  "aws_eks_node_group",
-  "azurerm_kubernetes_cluster_node_pool",
-  "google_container_node_pool",
-  "compute_node"
-]);
-var DATABASE_TYPES = /* @__PURE__ */ new Set([
-  "aws_db_instance",
-  "azurerm_postgresql_flexible_server",
-  "azurerm_mysql_flexible_server",
-  "azurerm_mssql_server",
-  "google_sql_database_instance"
-]);
-var BLOCK_STORAGE_TYPES = /* @__PURE__ */ new Set([
-  "aws_ebs_volume",
-  "azurerm_managed_disk",
-  "google_compute_disk"
-]);
-var OBJECT_STORAGE_TYPES = /* @__PURE__ */ new Set([
-  "aws_s3_bucket",
-  "azurerm_storage_account",
-  "google_storage_bucket"
-]);
-var NAT_GATEWAY_TYPES = /* @__PURE__ */ new Set([
-  "aws_nat_gateway",
-  "azurerm_nat_gateway",
-  "google_compute_router_nat"
-]);
-var LOAD_BALANCER_TYPES = /* @__PURE__ */ new Set([
-  "aws_lb",
-  "aws_alb",
-  "azurerm_lb",
-  "azurerm_application_gateway",
-  "google_compute_forwarding_rule"
-]);
-var KUBERNETES_TYPES = /* @__PURE__ */ new Set([
-  "aws_eks_cluster",
-  "azurerm_kubernetes_cluster",
-  "google_container_cluster"
-]);
-function serviceLabel(resourceType) {
-  if (COMPUTE_TYPES.has(resourceType)) return "compute";
-  if (DATABASE_TYPES.has(resourceType)) return "database";
-  if (BLOCK_STORAGE_TYPES.has(resourceType)) return "block_storage";
-  if (OBJECT_STORAGE_TYPES.has(resourceType)) return "object_storage";
-  if (NAT_GATEWAY_TYPES.has(resourceType)) return "network";
-  if (LOAD_BALANCER_TYPES.has(resourceType)) return "network";
-  if (KUBERNETES_TYPES.has(resourceType)) return "kubernetes";
-  return "other";
-}
-var CostEngine = class {
-  pricingEngine;
-  monthlyHours;
-  constructor(pricingEngine, config) {
-    this.pricingEngine = pricingEngine;
-    this.monthlyHours = config.pricing.monthly_hours;
-  }
-  /**
-   * Calculates the cost of a single resource on a target provider.
-   */
-  async calculateCost(resource, targetProvider, targetRegion) {
-    const type = resource.type;
-    logger.debug("CostEngine.calculateCost", {
-      resourceId: resource.id,
-      type,
-      targetProvider,
-      targetRegion
-    });
-    if (COMPUTE_TYPES.has(type)) {
-      return calculateComputeCost(
-        resource,
-        targetProvider,
-        targetRegion,
-        this.pricingEngine,
-        this.monthlyHours
-      );
-    }
-    if (DATABASE_TYPES.has(type)) {
-      return calculateDatabaseCost(
-        resource,
-        targetProvider,
-        targetRegion,
-        this.pricingEngine,
-        this.monthlyHours
-      );
-    }
-    if (BLOCK_STORAGE_TYPES.has(type) || OBJECT_STORAGE_TYPES.has(type)) {
-      return calculateStorageCost(
-        resource,
-        targetProvider,
-        targetRegion,
-        this.pricingEngine
-      );
-    }
-    if (NAT_GATEWAY_TYPES.has(type)) {
-      return calculateNatGatewayCost(
-        resource,
-        targetProvider,
-        targetRegion,
-        this.pricingEngine,
-        this.monthlyHours
-      );
-    }
-    if (LOAD_BALANCER_TYPES.has(type)) {
-      return calculateLoadBalancerCost(
-        resource,
-        targetProvider,
-        targetRegion,
-        this.pricingEngine,
-        this.monthlyHours
-      );
-    }
-    if (KUBERNETES_TYPES.has(type)) {
-      return calculateKubernetesCost(
-        resource,
-        targetProvider,
-        targetRegion,
-        this.pricingEngine,
-        this.monthlyHours
-      );
-    }
-    logger.warn("CostEngine: unsupported resource type", { type, targetProvider });
-    return {
-      resource_id: resource.id,
-      resource_type: type,
-      resource_name: resource.name,
-      provider: targetProvider,
-      region: targetRegion,
-      monthly_cost: 0,
-      yearly_cost: 0,
-      currency: "USD",
-      breakdown: [],
-      confidence: "low",
-      notes: [`Resource type "${type}" is not yet supported by the cost engine`],
-      pricing_source: "fallback"
-    };
-  }
-  /**
-   * Calculates costs for all resources and aggregates them into a CostBreakdown.
-   *
-   * Resources that fail to produce a cost estimate are logged and skipped rather
-   * than letting a single failure abort the entire calculation.
-   */
-  async calculateBreakdown(resources, targetProvider, targetRegion) {
-    const estimates = [];
-    const byService = {};
-    const warnings = [];
-    for (const resource of resources) {
-      try {
-        const estimate = await this.calculateCost(
-          resource,
-          targetProvider,
-          targetRegion
-        );
-        estimates.push(estimate);
-        const svc = serviceLabel(resource.type);
-        byService[svc] = (byService[svc] ?? 0) + estimate.monthly_cost;
-        if (estimate.pricing_source === "fallback") {
-          warnings.push(
-            `${estimate.resource_name} (${estimate.resource_type}): using fallback/bundled pricing data`
-          );
-        }
-        if (estimate.monthly_cost === 0 && estimate.confidence === "low") {
-          warnings.push(
-            `No pricing data found for ${estimate.resource_type} in ${targetRegion} \u2014 cost reported as $0`
-          );
-        }
-      } catch (err) {
-        logger.error("CostEngine: failed to calculate cost for resource", {
-          resourceId: resource.id,
-          type: resource.type,
-          error: err instanceof Error ? err.message : String(err)
-        });
-      }
-    }
-    const totalMonthly = estimates.reduce((sum, e) => sum + e.monthly_cost, 0);
-    return {
-      provider: targetProvider,
-      region: targetRegion,
-      total_monthly: Math.round(totalMonthly * 100) / 100,
-      total_yearly: Math.round(totalMonthly * 12 * 100) / 100,
-      currency: "USD",
-      by_service: Object.fromEntries(
-        Object.entries(byService).map(([k, v]) => [k, Math.round(v * 100) / 100])
-      ),
-      by_resource: estimates,
-      generated_at: (/* @__PURE__ */ new Date()).toISOString(),
-      warnings
-    };
-  }
-};
-
-// src/tools/estimate-cost.ts
-var estimateCostSchema = z2.object({
-  files: z2.array(
-    z2.object({
-      path: z2.string().describe("File path"),
-      content: z2.string().describe("File content (HCL)")
-    })
-  ),
-  tfvars: z2.string().optional().describe("Contents of terraform.tfvars file"),
-  provider: z2.enum(["aws", "azure", "gcp"]).describe("Target cloud provider to estimate costs for"),
-  region: z2.string().optional().describe(
-    "Target region for pricing lookup. Defaults to the source region mapped to the target provider."
-  )
-});
-async function estimateCost(params, pricingEngine, config) {
-  const inventory = await parseTerraform(params.files, params.tfvars);
-  const targetProvider = params.provider;
-  const targetRegion = params.region ?? mapRegion(inventory.region, inventory.provider, targetProvider);
-  const costEngine = new CostEngine(pricingEngine, config);
-  const breakdown = await costEngine.calculateBreakdown(
-    inventory.resources,
-    targetProvider,
-    targetRegion
-  );
-  const parseWarnings = inventory.parse_warnings ?? [];
-  const allWarnings = [.../* @__PURE__ */ new Set([...parseWarnings, ...breakdown.warnings ?? []])];
-  return {
-    ...breakdown,
-    parse_warnings: parseWarnings,
-    warnings: allWarnings
-  };
-}
-
-// src/tools/compare-providers.ts
-import { z as z3 } from "zod";
-
-// src/calculator/reserved.ts
-var DISCOUNT_RATES = {
-  aws: [
-    { term: "1yr", payment: "no_upfront", rate: 0.36 },
-    { term: "1yr", payment: "partial_upfront", rate: 0.4 },
-    { term: "1yr", payment: "all_upfront", rate: 0.42 },
-    { term: "3yr", payment: "no_upfront", rate: 0.52 },
-    { term: "3yr", payment: "partial_upfront", rate: 0.57 },
-    { term: "3yr", payment: "all_upfront", rate: 0.6 }
-  ],
-  azure: [
-    { term: "1yr", payment: "all_upfront", rate: 0.35 },
-    { term: "3yr", payment: "all_upfront", rate: 0.55 },
-    // Azure does not offer no-upfront RI in the same way; partial_upfront maps
-    // to hybrid benefit combined, approximated here.
-    { term: "1yr", payment: "partial_upfront", rate: 0.3 },
-    { term: "3yr", payment: "partial_upfront", rate: 0.5 }
-  ],
-  gcp: [
-    // GCP Committed Use Discounts (CUDs) – resource-based.
-    { term: "1yr", payment: "all_upfront", rate: 0.28 },
-    { term: "3yr", payment: "all_upfront", rate: 0.55 },
-    { term: "1yr", payment: "partial_upfront", rate: 0.2 },
-    { term: "3yr", payment: "partial_upfront", rate: 0.45 }
-  ]
-};
-function calculateReservedPricing(onDemandMonthly, provider) {
-  const rates = DISCOUNT_RATES[provider];
-  const options = rates.map(({ term, payment, rate }) => {
-    const monthly_cost = onDemandMonthly * (1 - rate);
-    const monthly_savings = onDemandMonthly - monthly_cost;
-    return {
-      term,
-      payment,
-      monthly_cost: Math.round(monthly_cost * 100) / 100,
-      monthly_savings: Math.round(monthly_savings * 100) / 100,
-      percentage_savings: Math.round(rate * 1e3) / 10
-      // e.g. 36.0
-    };
-  });
-  const best_option = options.reduce(
-    (best, opt) => opt.monthly_savings > best.monthly_savings ? opt : best,
-    options[0]
-  );
-  return {
-    on_demand_monthly: Math.round(onDemandMonthly * 100) / 100,
-    options,
-    best_option
-  };
-}
-
-// src/calculator/optimizer.ts
-var LARGE_INSTANCE_SUFFIXES = [
-  ".xlarge",
-  ".2xlarge",
-  ".4xlarge",
-  ".8xlarge",
-  ".16xlarge",
-  "Standard_B4ms",
-  "Standard_B8ms",
-  "Standard_D4",
-  "Standard_D8",
-  "Standard_D16",
-  "Standard_E4",
-  "Standard_E8",
-  "n2-standard-4",
-  "n2-standard-8",
-  "n2-standard-16",
-  "e2-standard-4",
-  "e2-standard-8"
-];
-var HIGH_UTILISATION_INDICATORS = [
-  "high-cpu",
-  "high-memory",
-  "production",
-  "prod",
-  "perf",
-  "performance"
-];
-function isLikelyOversized(resource) {
-  const instanceType = resource.attributes.instance_type ?? resource.attributes.vm_size ?? resource.attributes.machine_type ?? "";
-  const isLarge = LARGE_INSTANCE_SUFFIXES.some(
-    (suffix) => instanceType.toLowerCase().includes(suffix.toLowerCase())
-  );
-  if (!isLarge) return false;
-  const tagValues = Object.values(resource.tags).map((v) => v.toLowerCase());
-  const tagKeys = Object.keys(resource.tags).map((k) => k.toLowerCase());
-  const allTagText = [...tagKeys, ...tagValues].join(" ");
-  const hasHighUtilisationSignal = HIGH_UTILISATION_INDICATORS.some(
-    (signal) => allTagText.includes(signal)
-  );
-  return !hasHighUtilisationSignal;
-}
-var COMPUTE_RESOURCE_TYPES = /* @__PURE__ */ new Set([
-  "aws_instance",
-  "azurerm_linux_virtual_machine",
-  "azurerm_windows_virtual_machine",
-  "google_compute_instance",
-  "aws_eks_cluster",
-  "aws_eks_node_group",
-  "azurerm_kubernetes_cluster",
-  "google_container_cluster",
-  "google_container_node_pool"
-]);
-var DATABASE_RESOURCE_TYPES = /* @__PURE__ */ new Set([
-  "aws_db_instance",
-  "azurerm_postgresql_flexible_server",
-  "azurerm_mysql_flexible_server",
-  "google_sql_database_instance"
-]);
-var OBJECT_STORAGE_RESOURCE_TYPES = /* @__PURE__ */ new Set([
-  "aws_s3_bucket",
-  "azurerm_storage_account",
-  "google_storage_bucket"
-]);
-function generateOptimizations(estimates, resources) {
-  const recommendations = [];
-  const resourceById = new Map(
-    resources.map((r) => [r.id, r])
-  );
-  const estimatesByResourceId = /* @__PURE__ */ new Map();
-  for (const estimate of estimates) {
-    const existing = estimatesByResourceId.get(estimate.resource_id) ?? [];
-    existing.push(estimate);
-    estimatesByResourceId.set(estimate.resource_id, existing);
-  }
-  for (const [resourceId, resourceEstimates] of estimatesByResourceId) {
-    const resource = resourceById.get(resourceId);
-    if (!resourceEstimates.length) continue;
-    const current = resourceEstimates[0];
-    if (resource && COMPUTE_RESOURCE_TYPES.has(resource.type)) {
-      if (isLikelyOversized(resource) && current.monthly_cost > 0) {
-        const estimatedSavings = current.monthly_cost * 0.3;
-        recommendations.push({
-          resource_id: resourceId,
-          resource_name: current.resource_name,
-          type: "right_size",
-          description: `${resource.attributes.instance_type ?? resource.attributes.vm_size ?? "Instance"} appears over-provisioned. Consider downsizing to the next smaller instance type.`,
-          current_monthly_cost: current.monthly_cost,
-          estimated_monthly_cost: current.monthly_cost - estimatedSavings,
-          monthly_savings: estimatedSavings,
-          percentage_savings: 30,
-          confidence: "medium",
-          provider: current.provider
-        });
-      }
-    }
-    if (resource && (COMPUTE_RESOURCE_TYPES.has(resource.type) || DATABASE_RESOURCE_TYPES.has(resource.type)) && current.monthly_cost > 0) {
-      const reserved = calculateReservedPricing(
-        current.monthly_cost,
-        current.provider
-      );
-      const best = reserved.best_option;
-      if (best.percentage_savings >= 20) {
-        recommendations.push({
-          resource_id: resourceId,
-          resource_name: current.resource_name,
-          type: "reserved",
-          description: `Switching to a ${best.term} ${best.payment.replace(/_/g, " ")} commitment could save approximately ${best.percentage_savings}% per month.`,
-          current_monthly_cost: current.monthly_cost,
-          estimated_monthly_cost: best.monthly_cost,
-          monthly_savings: best.monthly_savings,
-          percentage_savings: best.percentage_savings,
-          confidence: "high",
-          provider: current.provider
-        });
-      }
-    }
-    if (resourceEstimates.length > 1 && current.monthly_cost > 0) {
-      const cheapest = resourceEstimates.reduce(
-        (min, e) => e.monthly_cost < min.monthly_cost ? e : min,
-        current
-      );
-      if (cheapest.provider !== current.provider) {
-        const savings = current.monthly_cost - cheapest.monthly_cost;
-        const pct = savings / current.monthly_cost * 100;
-        if (pct >= 20) {
-          recommendations.push({
-            resource_id: resourceId,
-            resource_name: current.resource_name,
-            type: "switch_provider",
-            description: `${cheapest.provider.toUpperCase()} offers this resource at $${cheapest.monthly_cost.toFixed(2)}/month vs $${current.monthly_cost.toFixed(2)}/month on ${current.provider.toUpperCase()}, saving approximately ${pct.toFixed(0)}%.`,
-            current_monthly_cost: current.monthly_cost,
-            estimated_monthly_cost: cheapest.monthly_cost,
-            monthly_savings: savings,
-            percentage_savings: Math.round(pct * 10) / 10,
-            confidence: "medium",
-            provider: cheapest.provider
-          });
-        }
-      }
-    }
-    if (resource && OBJECT_STORAGE_RESOURCE_TYPES.has(resource.type)) {
-      const storageClass = resource.attributes.storage_class ?? "";
-      const isHotTier = storageClass === "" || storageClass.toLowerCase() === "standard" || storageClass.toLowerCase() === "hot";
-      if (isHotTier && current.monthly_cost > 0) {
-        const estimatedSavings = current.monthly_cost * 0.4;
-        recommendations.push({
-          resource_id: resourceId,
-          resource_name: current.resource_name,
-          type: "storage_tier",
-          description: "Consider using an infrequent-access or cool storage tier if data is not accessed daily. This can reduce storage costs by ~40\u201360%.",
-          current_monthly_cost: current.monthly_cost,
-          estimated_monthly_cost: current.monthly_cost - estimatedSavings,
-          monthly_savings: estimatedSavings,
-          percentage_savings: 40,
-          confidence: "low",
-          provider: current.provider
-        });
-      }
-    }
-  }
-  return recommendations;
-}
-
-// src/reporting/markdown-report.ts
-function formatUsd(amount) {
-  return `$${amount.toFixed(2)}`;
-}
-function providerLabel(provider) {
-  switch (provider) {
-    case "aws":
-      return "AWS";
-    case "azure":
-      return "Azure";
-    case "gcp":
-      return "GCP";
-  }
-}
-function generateMarkdownReport(comparison, resources, options = {}, parseWarnings = []) {
-  const includeBreakdown = options.include_breakdown !== false;
-  const includeRecommendations = options.include_recommendations !== false;
-  const monthlyHours = options.monthly_hours ?? 730;
-  const lines = [];
-  const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  lines.push(
-    `# Cloud Cost Comparison Report`,
-    ``,
-    `**Generated:** ${now}  `,
-    `**Source provider:** ${providerLabel(comparison.source_provider)}  `,
-    `**Resources analysed:** ${resources.length}`,
-    ``
-  );
-  lines.push(`## Summary`, ``);
-  const sourceBreakdown = comparison.comparisons.find(
-    (b) => b.provider === comparison.source_provider
-  );
-  const sourceMonthly = sourceBreakdown?.total_monthly ?? 0;
-  lines.push(
-    `| Provider | Monthly Cost | Yearly Cost | vs Source |`,
-    `|----------|-------------|------------|-----------|`
-  );
-  for (const breakdown of comparison.comparisons) {
-    const diff = breakdown.total_monthly - sourceMonthly;
-    const diffLabel = breakdown.provider === comparison.source_provider ? "\u2014" : diff < 0 ? `${formatUsd(Math.abs(diff))} cheaper` : diff > 0 ? `${formatUsd(diff)} more expensive` : "same cost";
-    lines.push(
-      `| ${providerLabel(breakdown.provider)} | ${formatUsd(breakdown.total_monthly)} | ${formatUsd(breakdown.total_yearly)} | ${diffLabel} |`
-    );
-  }
-  lines.push(``);
-  if (comparison.savings_summary.length > 0) {
-    lines.push(`## Savings Potential`, ``);
-    lines.push(
-      `| Provider | Monthly Cost | Savings from Source | Savings % |`,
-      `|----------|-------------|--------------------|-----------| `
-    );
-    for (const s of comparison.savings_summary) {
-      const savings = s.difference_from_source;
-      const savingsLabel = savings < 0 ? formatUsd(Math.abs(savings)) : `-${formatUsd(savings)}`;
-      const pct = s.percentage_difference < 0 ? `${Math.abs(s.percentage_difference).toFixed(1)}% cheaper` : `${s.percentage_difference.toFixed(1)}% more`;
-      lines.push(
-        `| ${providerLabel(s.provider)} | ${formatUsd(s.total_monthly)} | ${savingsLabel} | ${pct} |`
-      );
-    }
-    lines.push(``);
-  }
-  if (includeBreakdown && resources.length > 0) {
-    lines.push(`## Resource Breakdown`, ``);
-    const costMatrix = /* @__PURE__ */ new Map();
-    for (const breakdown of comparison.comparisons) {
-      for (const estimate of breakdown.by_resource) {
-        const row = costMatrix.get(estimate.resource_id) ?? {};
-        row[breakdown.provider] = estimate.monthly_cost;
-        costMatrix.set(estimate.resource_id, row);
-      }
-    }
-    const presentProviders = comparison.comparisons.map((b) => b.provider);
-    const headerCols = presentProviders.map((p) => providerLabel(p)).join(" | ");
-    lines.push(
-      `| Resource | Type | ${headerCols} |`,
-      `|----------|------|${presentProviders.map(() => "------").join("|")}|`
-    );
-    for (const resource of resources) {
-      const costs = costMatrix.get(resource.id) ?? {};
-      const costCols = presentProviders.map((p) => formatUsd(costs[p] ?? 0)).join(" | ");
-      lines.push(
-        `| ${resource.name} | ${resource.type} | ${costCols} |`
-      );
-    }
-    lines.push(``);
-  }
-  if (includeRecommendations) {
-    const allEstimates = comparison.comparisons.flatMap((b) => b.by_resource);
-    const recommendations = generateOptimizations(allEstimates, resources);
-    if (recommendations.length > 0) {
-      lines.push(`## Savings Recommendations`, ``);
-      for (const rec of recommendations) {
-        const savingsLabel = `${formatUsd(rec.monthly_savings)}/month (${rec.percentage_savings}%)`;
-        lines.push(
-          `### ${rec.resource_name} \u2013 ${rec.type.replace(/_/g, " ")}`,
-          ``,
-          `${rec.description}`,
-          ``,
-          `- **Current cost:** ${formatUsd(rec.current_monthly_cost)}/month`,
-          `- **Estimated after:** ${formatUsd(rec.estimated_monthly_cost)}/month`,
-          `- **Potential savings:** ${savingsLabel}`,
-          `- **Confidence:** ${rec.confidence}`,
-          ``
-        );
-      }
-    } else {
-      lines.push(`## Savings Recommendations`, ``, `No recommendations at this time.`, ``);
-    }
-  }
-  lines.push(`## Assumptions`, ``);
-  lines.push(
-    `| Parameter | Value |`,
-    `|-----------|-------|`,
-    `| Pricing model | On-demand (no reserved or spot instances) |`,
-    `| Operating system | Linux (unless specified in resource attributes) |`,
-    `| Monthly hours | ${monthlyHours} |`,
-    `| Currency | USD |`,
-    `| Pricing source | Mix of live API and fallback/bundled data |`,
-    `| Data transfer costs | Not included |`,
-    `| Tax | Not included |`,
-    ``
-  );
-  const allDataWarnings = comparison.comparisons.flatMap((b) => b.warnings ?? []);
-  const allWarnings = [.../* @__PURE__ */ new Set([...parseWarnings, ...allDataWarnings])];
-  if (allWarnings.length > 0) {
-    lines.push(`## Limitations`, ``);
-    lines.push(
-      `> The following issues were detected during analysis that may affect estimate accuracy:`,
-      ``
-    );
-    for (const w of allWarnings) {
-      lines.push(`- ${w}`);
-    }
-    lines.push(``);
-  }
-  return lines.join("\n");
-}
-
-// src/reporting/json-report.ts
-function generateJsonReport(comparison, resources, monthlyHours = 730, parseWarnings = []) {
-  const sourcesSet = /* @__PURE__ */ new Set();
-  for (const breakdown of comparison.comparisons) {
-    for (const estimate of breakdown.by_resource) {
-      const src = estimate.pricing_source;
-      if (src) {
-        sourcesSet.add(`${breakdown.provider}_${src}`);
-      }
-    }
-  }
-  const allDataWarnings = comparison.comparisons.flatMap((b) => b.warnings ?? []);
-  const allWarnings = [.../* @__PURE__ */ new Set([...parseWarnings, ...allDataWarnings])];
-  const output = {
-    metadata: {
-      generated_at: (/* @__PURE__ */ new Date()).toISOString(),
-      pricing_sources_used: Array.from(sourcesSet).sort(),
-      assumptions: {
-        pricing_model: "on-demand",
-        operating_system: "Linux (unless specified)",
-        monthly_hours: monthlyHours,
-        currency: "USD",
-        data_transfer_costs: "not included",
-        tax: "not included"
-      },
-      warnings: allWarnings
-    },
-    ...comparison,
-    resource_summary: {
-      total: resources.length,
-      by_type: resources.reduce((acc, r) => {
-        acc[r.type] = (acc[r.type] ?? 0) + 1;
-        return acc;
-      }, {})
-    }
-  };
-  return JSON.stringify(output, null, 2);
-}
-
-// src/reporting/csv-report.ts
-var PROVIDERS = ["aws", "azure", "gcp"];
-function csvEscape(value) {
-  const str2 = String(value);
-  if (str2.includes(",") || str2.includes("\n") || str2.includes('"')) {
-    return `"${str2.replace(/"/g, '""')}"`;
-  }
-  return str2;
-}
-function generateCsvReport(comparison, resources) {
-  const lines = [];
-  lines.push("# Prices are estimates based on on-demand pricing. See assumptions in JSON/Markdown reports.");
-  lines.push("Resource,Type,AWS Monthly,Azure Monthly,GCP Monthly,Cheapest");
-  const costByProviderAndResource = /* @__PURE__ */ new Map();
-  for (const breakdown of comparison.comparisons) {
-    const byResource = /* @__PURE__ */ new Map();
-    for (const estimate of breakdown.by_resource) {
-      byResource.set(estimate.resource_id, estimate.monthly_cost);
-    }
-    costByProviderAndResource.set(breakdown.provider, byResource);
-  }
-  for (const resource of resources) {
-    const costs = {};
-    for (const provider of PROVIDERS) {
-      const providerMap = costByProviderAndResource.get(provider);
-      if (providerMap) {
-        costs[provider] = providerMap.get(resource.id) ?? 0;
-      }
-    }
-    let cheapest = "N/A";
-    let lowestCost = Infinity;
-    for (const provider of PROVIDERS) {
-      const cost = costs[provider] ?? 0;
-      if (cost > 0 && cost < lowestCost) {
-        lowestCost = cost;
-        cheapest = provider.toUpperCase();
-      }
-    }
-    const row = [
-      csvEscape(resource.name),
-      csvEscape(resource.type),
-      csvEscape((costs.aws ?? 0).toFixed(2)),
-      csvEscape((costs.azure ?? 0).toFixed(2)),
-      csvEscape((costs.gcp ?? 0).toFixed(2)),
-      csvEscape(cheapest)
-    ];
-    lines.push(row.join(","));
-  }
-  return lines.join("\n");
-}
+  PricingCache,
+  PricingEngine,
+  analyzeTerraform,
+  analyzeTerraformSchema,
+  compareProviders,
+  compareProvidersSchema,
+  estimateCost,
+  estimateCostSchema,
+  loadConfig,
+  logger,
+  mapInstance,
+  optimizeCost,
+  optimizeCostSchema,
+  setLogLevel,
+  whatIf,
+  whatIfSchema
+} from "./chunk-EI63JCAA.js";
+import {
+  getResourceEquivalents
+} from "./chunk-XDBTEI42.js";
 
-// src/tools/compare-providers.ts
-var compareProvidersSchema = z3.object({
-  files: z3.array(
-    z3.object({
-      path: z3.string().describe("File path"),
-      content: z3.string().describe("File content (HCL)")
-    })
-  ),
-  tfvars: z3.string().optional().describe("Contents of terraform.tfvars file"),
-  format: z3.enum(["markdown", "json", "csv"]).default("markdown").describe("Output report format"),
-  providers: z3.array(z3.enum(["aws", "azure", "gcp"])).default(["aws", "azure", "gcp"]).describe("Cloud providers to include in the comparison")
-});
-async function compareProviders(params, pricingEngine, config) {
-  const inventory = await parseTerraform(params.files, params.tfvars);
-  const sourceProvider = inventory.provider;
-  const costEngine = new CostEngine(pricingEngine, config);
-  const comparisons = [];
-  for (const provider of params.providers) {
-    const targetRegion = mapRegion(inventory.region, sourceProvider, provider);
-    const breakdown = await costEngine.calculateBreakdown(
-      inventory.resources,
-      provider,
-      targetRegion
-    );
-    comparisons.push(breakdown);
-  }
-  const sourceBreakdown = comparisons.find((b) => b.provider === sourceProvider) ?? comparisons[0];
-  const sourceMonthly = sourceBreakdown?.total_monthly ?? 0;
-  const savingsSummary = comparisons.map((b) => {
-    const diff = b.total_monthly - sourceMonthly;
-    const pct = sourceMonthly !== 0 ? diff / sourceMonthly * 100 : 0;
-    return {
-      provider: b.provider,
-      total_monthly: b.total_monthly,
-      difference_from_source: Math.round(diff * 100) / 100,
-      percentage_difference: Math.round(pct * 10) / 10
-    };
-  });
-  const comparison = {
-    source_provider: sourceProvider,
-    comparisons,
-    savings_summary: savingsSummary,
-    generated_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const allWarnings = comparisons.flatMap((b) => b.warnings ?? []);
-  const parseWarnings = inventory.parse_warnings ?? [];
-  const monthlyHours = config.pricing.monthly_hours;
-  let report;
-  switch (params.format) {
-    case "json":
-      report = generateJsonReport(comparison, inventory.resources, monthlyHours, parseWarnings);
-      break;
-    case "csv":
-      report = generateCsvReport(comparison, inventory.resources);
-      break;
-    case "markdown":
-    default:
-      report = generateMarkdownReport(
-        comparison,
-        inventory.resources,
-        {},
-        parseWarnings
-      );
-      break;
-  }
-  return {
-    report,
-    format: params.format,
-    comparison,
-    warnings: [.../* @__PURE__ */ new Set([...parseWarnings, ...allWarnings])]
-  };
-}
+// src/server.ts
+import { createRequire } from "module";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/tools/get-equivalents.ts
-import { z as z4 } from "zod";
+import { z } from "zod";
 
 // src/mapping/resource-mapper.ts
 function findEquivalent(resourceType, sourceProvider, targetProvider) {
@@ -4320,15 +59,15 @@ function findAllEquivalents(resourceType, sourceProvider) {
 }
 
 // src/tools/get-equivalents.ts
-var getEquivalentsSchema = z4.object({
-  resource_type: z4.string().describe(
+var getEquivalentsSchema = z.object({
+  resource_type: z.string().describe(
     "Terraform resource type to look up (e.g. aws_instance, google_compute_instance)"
   ),
-  source_provider: z4.enum(["aws", "azure", "gcp"]).describe("Cloud provider the resource type belongs to"),
-  target_provider: z4.enum(["aws", "azure", "gcp"]).optional().describe(
+  source_provider: z.enum(["aws", "azure", "gcp"]).describe("Cloud provider the resource type belongs to"),
+  target_provider: z.enum(["aws", "azure", "gcp"]).optional().describe(
     "Specific target provider. When omitted, equivalents for all providers are returned."
   ),
-  instance_type: z4.string().optional().describe(
+  instance_type: z.string().optional().describe(
     "Instance type / VM size to also map across providers (e.g. t3.large, Standard_D4s_v3)"
   )
 });
@@ -4371,14 +110,14 @@ async function getEquivalents(params) {
 }
 
 // src/tools/get-pricing.ts
-import { z as z5 } from "zod";
-var getPricingSchema = z5.object({
-  provider: z5.enum(["aws", "azure", "gcp"]).describe("Cloud provider to look up pricing for"),
-  service: z5.enum(["compute", "database", "storage", "network", "kubernetes"]).describe("Service category"),
-  resource_type: z5.string().describe(
+import { z as z2 } from "zod";
+var getPricingSchema = z2.object({
+  provider: z2.enum(["aws", "azure", "gcp"]).describe("Cloud provider to look up pricing for"),
+  service: z2.enum(["compute", "database", "storage", "network", "load_balancer", "nat_gateway", "kubernetes"]).describe("Service category (network defaults to nat_gateway for backward compatibility)"),
+  resource_type: z2.string().describe(
     "Instance type, storage type, or resource identifier (e.g. t3.large, gp3, Standard_D4s_v3)"
   ),
-  region: z5.string().describe("Cloud region (e.g. us-east-1, eastus, us-central1)")
+  region: z2.string().describe("Cloud region (e.g. us-east-1, eastus, us-central1)")
 });
 async function getPricing(params, pricingEngine) {
   const provider = params.provider;
@@ -4387,6 +126,8 @@ async function getPricing(params, pricingEngine) {
     database: "database",
     storage: "storage",
     network: "nat-gateway",
+    load_balancer: "load-balancer",
+    nat_gateway: "nat-gateway",
     kubernetes: "kubernetes"
   };
   const service = serviceMap[params.service] ?? params.service;
@@ -4405,53 +146,6 @@ async function getPricing(params, pricingEngine) {
   };
 }
 
-// src/tools/optimize-cost.ts
-import { z as z6 } from "zod";
-var optimizeCostSchema = z6.object({
-  files: z6.array(
-    z6.object({
-      path: z6.string().describe("File path"),
-      content: z6.string().describe("File content (HCL)")
-    })
-  ),
-  tfvars: z6.string().optional().describe("Contents of terraform.tfvars file"),
-  providers: z6.array(z6.enum(["aws", "azure", "gcp"])).default(["aws", "azure", "gcp"]).describe("Providers to calculate costs against for cross-provider recommendations")
-});
-async function optimizeCost(params, pricingEngine, config) {
-  const inventory = await parseTerraform(params.files, params.tfvars);
-  const sourceProvider = inventory.provider;
-  const costEngine = new CostEngine(pricingEngine, config);
-  const allEstimates = [];
-  for (const provider of params.providers) {
-    const targetRegion = mapRegion(inventory.region, sourceProvider, provider);
-    const breakdown = await costEngine.calculateBreakdown(
-      inventory.resources,
-      provider,
-      targetRegion
-    );
-    allEstimates.push(...breakdown.by_resource);
-  }
-  const recommendations = generateOptimizations(allEstimates, inventory.resources);
-  const sourceEstimates = allEstimates.filter(
-    (e) => e.provider === sourceProvider && e.monthly_cost > 0
-  );
-  const reservedPricing = sourceEstimates.map((estimate) => ({
-    resource_id: estimate.resource_id,
-    resource_name: estimate.resource_name,
-    resource_type: estimate.resource_type,
-    provider: estimate.provider,
-    ...calculateReservedPricing(estimate.monthly_cost, estimate.provider)
-  }));
-  const totalPotentialSavings = recommendations.reduce((sum, r) => sum + r.monthly_savings, 0);
-  return {
-    recommendations,
-    reserved_pricing: reservedPricing,
-    total_potential_savings: Math.round(totalPotentialSavings * 100) / 100,
-    recommendation_count: recommendations.length,
-    resource_count: inventory.resources.length
-  };
-}
-
 // src/tools/index.ts
 function registerTools(server, config) {
   const cache = new PricingCache(config.cache.db_path);
@@ -4522,15 +216,28 @@ function registerTools(server, config) {
       };
     }
   );
+  server.tool(
+    "what_if",
+    "Estimate cost impact of infrastructure changes without modifying Terraform files. Applies attribute overrides to a cloned resource set and returns a per-resource and aggregate cost diff.",
+    whatIfSchema.shape,
+    async (params) => {
+      const result = await whatIf(params, pricingEngine, config);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
 }
 
 // src/server.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
 async function startServer() {
   const config = loadConfig();
   setLogLevel(config.logging.level);
   const server = new McpServer({
     name: "cloudcost-mcp",
-    version: "0.1.0"
+    version
   });
   registerTools(server, config);
   const transport = new StdioServerTransport();