proschi 0.5.0 → 0.7.0

package/dist/cli.cjs

@@ -15201,125 +15201,237 @@ var componentCatalog = [
   { type: "shape", techStack: "Diamond", category: "Generic Shapes", searchTerms: "diamond rhombus shape decision" },
   { type: "shape", techStack: "Cylinder", category: "Generic Shapes", searchTerms: "cylinder shape storage" },
   { type: "shape", techStack: "Cloud", category: "Generic Shapes", searchTerms: "cloud shape" },
-  { type: "shape", techStack: "Actor", category: "Generic Shapes", searchTerms: "actor user person human shape" },
-  { type: "shape", techStack: "Note", category: "Generic Shapes", searchTerms: "note document comment annotation" },
+  { type: "shape", techStack: "Actor", category: "Generic Shapes", searchTerms: "actor user person human shape", aliases: ["User", "Client", "Customer", "Person"] },
+  { type: "shape", techStack: "Browser", category: "Generic Shapes", searchTerms: "browser web client user", aliases: ["Web Browser", "Web Client"] },
+  { type: "shape", techStack: "Mobile App", category: "Generic Shapes", searchTerms: "mobile app ios android client user", aliases: ["Mobile", "Mobile Client", "iOS", "iOS App", "Android", "Android App"] },
+  { type: "shape", techStack: "Note", category: "Generic Shapes", searchTerms: "note document comment annotation", kind: "other" },
+  // Generic components: one per kind, for a node whose product does not matter or is not listed.
+  { type: "service", techStack: "Service", category: "Generic Components", searchTerms: "service microservice backend server application", aliases: ["Microservice", "Backend", "Backend Service", "App Server", "Application Server", "Server", "API Server"] },
+  { type: "service", techStack: "Worker", category: "Generic Components", searchTerms: "worker background job consumer processor", aliases: ["Background Worker", "Job Worker", "Consumer", "Job Runner"] },
+  { type: "database", techStack: "Database", category: "Generic Components", searchTerms: "database relational sql db", aliases: ["DB", "RDBMS", "SQL Database", "Relational Database", "SQL"] },
+  { type: "database", techStack: "NoSQL Database", category: "Generic Components", searchTerms: "nosql key value document wide column database", profile: "nosql", aliases: ["NoSQL", "NoSQL DB", "Key-Value Store", "KV Store", "Document Store", "Document Database", "Wide-Column Store"] },
+  { type: "cache", techStack: "Cache", category: "Generic Components", searchTerms: "cache in-memory key value", aliases: ["In-Memory Cache", "Distributed Cache"] },
+  { type: "queue", techStack: "Message Queue", category: "Generic Components", searchTerms: "queue message broker topic stream event bus", aliases: ["Queue", "Message Broker", "Broker", "Event Bus", "Topic", "Event Stream", "Stream"] },
+  { type: "storage", techStack: "Object Storage", category: "Generic Components", searchTerms: "object storage blob bucket files", aliases: ["Object Store", "Blob Store", "Blob Storage", "Bucket", "Storage", "File Storage"] },
+  { type: "cdn", techStack: "CDN", category: "Generic Components", searchTerms: "cdn content delivery network edge cache", kind: "cdn", aliases: ["Content Delivery Network", "Edge Cache"] },
+  { type: "cdn", techStack: "Load Balancer", category: "Generic Components", searchTerms: "load balancer lb reverse proxy", kind: "loadbalancer", aliases: ["LB", "Reverse Proxy", "L7 Load Balancer", "L4 Load Balancer"] },
+  { type: "cdn", techStack: "API Gateway", category: "Generic Components", searchTerms: "api gateway", kind: "gateway", aliases: ["Gateway", "Edge Gateway"] },
+  { type: "cdn", techStack: "DNS", category: "Generic Components", searchTerms: "dns domain name system", kind: "dns", aliases: ["Domain Name System", "DNS Server"] },
+  { type: "cdn", techStack: "WAF", category: "Generic Components", searchTerms: "waf web application firewall edge", kind: "edge", aliases: ["Web Application Firewall", "Firewall"] },
+  { type: "serverless", techStack: "Function", category: "Generic Components", searchTerms: "function serverless faas", aliases: ["Serverless Function", "Serverless", "FaaS", "Cloud Function"] },
+  { type: "database", techStack: "Search Engine", category: "Generic Components", searchTerms: "search engine index full text", kind: "search", aliases: ["Search", "Search Index", "Full-Text Search", "Search Service"] },
+  { type: "database", techStack: "Data Warehouse", category: "Generic Components", searchTerms: "data warehouse lake olap analytics", kind: "analytics", aliases: ["Warehouse", "Data Lake", "OLAP", "Analytics DB", "Analytics Database", "Time Series DB", "Time Series Database", "TSDB"] },
   // Services
-  { type: "service", techStack: "REST API", category: "Services", searchTerms: "rest api http service endpoint" },
-  { type: "service", techStack: "GraphQL", category: "Services", searchTerms: "graphql api service query" },
-  { type: "service", techStack: "gRPC", category: "Services", searchTerms: "grpc rpc service" },
-  { type: "service", techStack: "WebSocket", category: "Services", searchTerms: "websocket ws realtime service" },
-  { type: "service", techStack: "SOAP API", category: "Services", searchTerms: "soap api xml service" },
+  { type: "service", techStack: "REST API", category: "Services", searchTerms: "rest api http service endpoint", aliases: ["REST", "API", "HTTP API", "Web API", "REST Service"] },
+  { type: "service", techStack: "GraphQL", category: "Services", searchTerms: "graphql api service query", aliases: ["GraphQL API", "Apollo"] },
+  { type: "service", techStack: "gRPC", category: "Services", searchTerms: "grpc rpc service", aliases: ["gRPC Service", "RPC"] },
+  { type: "service", techStack: "WebSocket", category: "Services", searchTerms: "websocket ws realtime service", aliases: ["WebSockets", "WS", "Socket.IO", "WebSocket Server"] },
+  { type: "service", techStack: "SOAP API", category: "Services", searchTerms: "soap api xml service", aliases: ["SOAP"] },
+  // Languages and frameworks: a service written in it.
+  { type: "service", techStack: "Spring Boot", category: "Languages & Frameworks", searchTerms: "spring boot java kotlin service", aliases: ["Spring", "Spring Framework", "Spring WebFlux"] },
+  { type: "service", techStack: "Kotlin", category: "Languages & Frameworks", searchTerms: "kotlin ktor jvm service", aliases: ["Ktor"] },
+  { type: "service", techStack: "Java", category: "Languages & Frameworks", searchTerms: "java jvm service", aliases: ["JVM", "Quarkus", "Micronaut"] },
+  { type: "service", techStack: "Go", category: "Languages & Frameworks", searchTerms: "go golang service", aliases: ["Golang"] },
+  { type: "service", techStack: "Node.js", category: "Languages & Frameworks", searchTerms: "node nodejs javascript typescript express nestjs service", aliases: ["Node", "Express", "Express.js", "NestJS", "TypeScript", "JavaScript"] },
+  { type: "service", techStack: "Python", category: "Languages & Frameworks", searchTerms: "python service" },
+  { type: "service", techStack: "Django", category: "Languages & Frameworks", searchTerms: "django python service" },
+  { type: "service", techStack: "FastAPI", category: "Languages & Frameworks", searchTerms: "fastapi python service" },
+  { type: "service", techStack: "Flask", category: "Languages & Frameworks", searchTerms: "flask python service" },
+  { type: "service", techStack: "Ruby on Rails", category: "Languages & Frameworks", searchTerms: "ruby on rails service", aliases: ["Rails", "Ruby"] },
+  { type: "service", techStack: ".NET", category: "Languages & Frameworks", searchTerms: "dotnet .net asp.net c# service", aliases: ["ASP.NET", "ASP.NET Core", "dotnet", "C#"] },
+  { type: "service", techStack: "PHP", category: "Languages & Frameworks", searchTerms: "php laravel symfony service", aliases: ["Laravel", "Symfony"] },
+  { type: "service", techStack: "Rust", category: "Languages & Frameworks", searchTerms: "rust axum actix service", aliases: ["Axum", "Actix"] },
+  { type: "service", techStack: "Elixir", category: "Languages & Frameworks", searchTerms: "elixir phoenix erlang service", aliases: ["Phoenix", "Erlang"] },
+  // Containers and platforms
+  { type: "container", techStack: "Kubernetes", category: "Containers & Platforms", searchTerms: "kubernetes k8s container pod", aliases: ["K8s", "Kubernetes Pod", "Pod"] },
+  { type: "container", techStack: "Docker", category: "Containers & Platforms", searchTerms: "docker container", aliases: ["Container", "Docker Container"] },
+  { type: "compute", techStack: "VM", category: "Containers & Platforms", searchTerms: "vm virtual machine server instance", aliases: ["Virtual Machine", "Instance", "Bare Metal"] },
+  { type: "serverless", techStack: "Cloudflare Workers", category: "Containers & Platforms", searchTerms: "cloudflare workers edge functions serverless", aliases: ["Workers"] },
   // AWS Serverless
-  { type: "serverless", techStack: "AWS Lambda", category: "AWS Services", searchTerms: "aws lambda serverless function" },
-  { type: "serverless", techStack: "AWS API Gateway", category: "AWS Services", searchTerms: "aws api gateway rest" },
+  { type: "serverless", techStack: "AWS Lambda", category: "AWS Services", searchTerms: "aws lambda serverless function", aliases: ["Lambda", "Amazon Lambda"] },
+  { type: "serverless", techStack: "AWS API Gateway", category: "AWS Services", searchTerms: "aws api gateway rest", kind: "gateway", aliases: ["Amazon API Gateway"] },
   // AWS Compute
-  { type: "compute", techStack: "AWS EC2", category: "AWS Services", searchTerms: "aws ec2 compute instance vm" },
-  { type: "container", techStack: "AWS ECS", category: "AWS Services", searchTerms: "aws ecs container docker" },
-  { type: "container", techStack: "AWS EKS", category: "AWS Services", searchTerms: "aws eks kubernetes k8s" },
-  { type: "container", techStack: "AWS Fargate", category: "AWS Services", searchTerms: "aws fargate serverless container" },
+  { type: "compute", techStack: "AWS EC2", category: "AWS Services", searchTerms: "aws ec2 compute instance vm", aliases: ["EC2", "Amazon EC2"] },
+  { type: "container", techStack: "AWS ECS", category: "AWS Services", searchTerms: "aws ecs container docker", aliases: ["ECS", "Amazon ECS"] },
+  { type: "container", techStack: "AWS EKS", category: "AWS Services", searchTerms: "aws eks kubernetes k8s", aliases: ["EKS", "Amazon EKS"] },
+  { type: "container", techStack: "AWS Fargate", category: "AWS Services", searchTerms: "aws fargate serverless container", aliases: ["Fargate"] },
   // AWS Storage
-  { type: "storage", techStack: "AWS S3", category: "AWS Services", searchTerms: "aws s3 storage bucket object" },
-  { type: "storage", techStack: "AWS EBS", category: "AWS Services", searchTerms: "aws ebs storage volume disk" },
-  { type: "storage", techStack: "AWS EFS", category: "AWS Services", searchTerms: "aws efs storage file system" },
+  { type: "storage", techStack: "AWS S3", category: "AWS Services", searchTerms: "aws s3 storage bucket object", aliases: ["S3", "Amazon S3", "S3 Bucket"] },
+  { type: "storage", techStack: "AWS EBS", category: "AWS Services", searchTerms: "aws ebs storage volume disk", aliases: ["EBS", "Amazon EBS"] },
+  { type: "storage", techStack: "AWS EFS", category: "AWS Services", searchTerms: "aws efs storage file system", aliases: ["EFS", "Amazon EFS"] },
   // AWS Database
-  { type: "database", techStack: "AWS RDS", category: "AWS Services", searchTerms: "aws rds database relational sql" },
-  { type: "database", techStack: "AWS DynamoDB", category: "AWS Services", searchTerms: "aws dynamodb database nosql" },
-  { type: "cache", techStack: "AWS ElastiCache", category: "AWS Services", searchTerms: "aws elasticache redis memcached cache" },
-  { type: "database", techStack: "AWS Aurora", category: "AWS Services", searchTerms: "aws aurora database mysql postgresql" },
+  { type: "database", techStack: "AWS RDS", category: "AWS Services", searchTerms: "aws rds database relational sql", aliases: ["RDS", "Amazon RDS"] },
+  { type: "database", techStack: "AWS DynamoDB", category: "AWS Services", searchTerms: "aws dynamodb database nosql", profile: "nosql", aliases: ["Amazon DynamoDB", "Dynamo"] },
+  { type: "cache", techStack: "AWS ElastiCache", category: "AWS Services", searchTerms: "aws elasticache redis memcached cache", aliases: ["ElastiCache", "Amazon ElastiCache"] },
+  { type: "database", techStack: "AWS Aurora", category: "AWS Services", searchTerms: "aws aurora database mysql postgresql", aliases: ["Aurora", "Amazon Aurora", "Aurora PostgreSQL", "Aurora MySQL", "Aurora Serverless"] },
+  { type: "database", techStack: "AWS DocumentDB", category: "AWS Services", searchTerms: "aws documentdb mongodb document database", aliases: ["DocumentDB", "Amazon DocumentDB"] },
+  { type: "database", techStack: "AWS Keyspaces", category: "AWS Services", searchTerms: "aws keyspaces cassandra nosql", profile: "nosql", aliases: ["Keyspaces", "Amazon Keyspaces"] },
+  { type: "database", techStack: "AWS Neptune", category: "AWS Services", searchTerms: "aws neptune graph database", aliases: ["Neptune", "Amazon Neptune"] },
+  { type: "database", techStack: "AWS Redshift", category: "AWS Services", searchTerms: "aws redshift data warehouse analytics", kind: "analytics", aliases: ["Redshift", "Amazon Redshift"] },
+  { type: "database", techStack: "AWS Athena", category: "AWS Services", searchTerms: "aws athena query s3 analytics", kind: "analytics", aliases: ["Athena", "Amazon Athena"] },
+  { type: "database", techStack: "AWS OpenSearch", category: "AWS Services", searchTerms: "aws opensearch elasticsearch search", kind: "search", aliases: ["Amazon OpenSearch", "OpenSearch Service", "AWS Elasticsearch"] },
   // AWS Messaging
-  { type: "queue", techStack: "AWS SQS", category: "AWS Services", searchTerms: "aws sqs queue message" },
-  { type: "queue", techStack: "AWS SNS", category: "AWS Services", searchTerms: "aws sns notification topic pubsub" },
-  { type: "queue", techStack: "AWS EventBridge", category: "AWS Services", searchTerms: "aws eventbridge event bus" },
-  { type: "queue", techStack: "AWS Kinesis", category: "AWS Services", searchTerms: "aws kinesis stream data" },
+  { type: "queue", techStack: "AWS SQS", category: "AWS Services", searchTerms: "aws sqs queue message", aliases: ["Amazon SQS", "Simple Queue Service"] },
+  { type: "queue", techStack: "AWS SNS", category: "AWS Services", searchTerms: "aws sns notification topic pubsub", aliases: ["SNS", "Amazon SNS", "Simple Notification Service"] },
+  { type: "queue", techStack: "AWS EventBridge", category: "AWS Services", searchTerms: "aws eventbridge event bus", aliases: ["EventBridge", "Amazon EventBridge"] },
+  { type: "queue", techStack: "AWS Kinesis", category: "AWS Services", searchTerms: "aws kinesis stream data", aliases: ["Kinesis", "Amazon Kinesis", "Kinesis Data Streams"] },
+  { type: "queue", techStack: "AWS MSK", category: "AWS Services", searchTerms: "aws msk managed kafka stream", aliases: ["MSK", "Amazon MSK", "Managed Streaming for Kafka"] },
   // AWS CDN/Network
-  { type: "cdn", techStack: "AWS CloudFront", category: "AWS Services", searchTerms: "aws cloudfront cdn edge" },
-  { type: "cdn", techStack: "AWS Route53", category: "AWS Services", searchTerms: "aws route53 dns domain" },
-  { type: "cdn", techStack: "AWS Load Balancer", category: "AWS Services", searchTerms: "aws alb elb load balancer" },
+  { type: "cdn", techStack: "AWS CloudFront", category: "AWS Services", searchTerms: "aws cloudfront cdn edge", kind: "cdn", aliases: ["CloudFront", "Amazon CloudFront"] },
+  { type: "cdn", techStack: "AWS Route53", category: "AWS Services", searchTerms: "aws route53 dns domain", kind: "dns", aliases: ["Route53", "Amazon Route 53"] },
+  { type: "cdn", techStack: "AWS Load Balancer", category: "AWS Services", searchTerms: "aws alb elb nlb load balancer", kind: "loadbalancer", aliases: ["ALB", "NLB", "ELB", "AWS ALB", "AWS NLB", "AWS ELB", "Application Load Balancer", "Network Load Balancer", "Elastic Load Balancer", "Elastic Load Balancing"] },
+  { type: "cdn", techStack: "AWS WAF", category: "AWS Services", searchTerms: "aws waf web application firewall", kind: "edge", aliases: ["Amazon WAF"] },
+  { type: "cdn", techStack: "AWS Global Accelerator", category: "AWS Services", searchTerms: "aws global accelerator anycast edge", kind: "edge", aliases: ["Global Accelerator"] },
+  // AWS third-party style services
+  { type: "external", techStack: "AWS SES", category: "AWS Services", searchTerms: "aws ses email simple email service", aliases: ["SES", "Amazon SES", "Simple Email Service"] },
+  { type: "external", techStack: "AWS Cognito", category: "AWS Services", searchTerms: "aws cognito auth identity users", aliases: ["Cognito", "Amazon Cognito"] },
   // GCP Serverless
-  { type: "serverless", techStack: "GCP Cloud Functions", category: "GCP Services", searchTerms: "gcp google cloud functions serverless" },
-  { type: "serverless", techStack: "GCP Cloud Run", category: "GCP Services", searchTerms: "gcp google cloud run serverless container" },
-  { type: "serverless", techStack: "GCP App Engine", category: "GCP Services", searchTerms: "gcp google app engine paas" },
+  { type: "serverless", techStack: "GCP Cloud Functions", category: "GCP Services", searchTerms: "gcp google cloud functions serverless", aliases: ["Cloud Functions", "Google Cloud Functions"] },
+  { type: "serverless", techStack: "GCP Cloud Run", category: "GCP Services", searchTerms: "gcp google cloud run serverless container", aliases: ["Cloud Run", "Google Cloud Run"] },
+  { type: "serverless", techStack: "GCP App Engine", category: "GCP Services", searchTerms: "gcp google app engine paas", aliases: ["App Engine", "Google App Engine"] },
   // GCP Compute
-  { type: "compute", techStack: "GCP Compute Engine", category: "GCP Services", searchTerms: "gcp google compute engine vm instance" },
-  { type: "container", techStack: "GCP GKE", category: "GCP Services", searchTerms: "gcp google gke kubernetes k8s" },
+  { type: "compute", techStack: "GCP Compute Engine", category: "GCP Services", searchTerms: "gcp google compute engine vm instance", aliases: ["Compute Engine", "GCE", "Google Compute Engine"] },
+  { type: "container", techStack: "GCP GKE", category: "GCP Services", searchTerms: "gcp google gke kubernetes k8s", aliases: ["GKE", "Google Kubernetes Engine"] },
   // GCP Storage
-  { type: "storage", techStack: "GCP Cloud Storage", category: "GCP Services", searchTerms: "gcp google cloud storage bucket object" },
-  { type: "storage", techStack: "GCP Persistent Disk", category: "GCP Services", searchTerms: "gcp google persistent disk storage" },
+  { type: "storage", techStack: "GCP Cloud Storage", category: "GCP Services", searchTerms: "gcp google cloud storage bucket object", aliases: ["GCS", "Cloud Storage", "Google Cloud Storage"] },
+  { type: "storage", techStack: "GCP Persistent Disk", category: "GCP Services", searchTerms: "gcp google persistent disk storage", aliases: ["Persistent Disk"] },
   // GCP Database
-  { type: "database", techStack: "GCP Cloud SQL", category: "GCP Services", searchTerms: "gcp google cloud sql database" },
-  { type: "database", techStack: "GCP Firestore", category: "GCP Services", searchTerms: "gcp google firestore database nosql" },
-  { type: "database", techStack: "GCP Bigtable", category: "GCP Services", searchTerms: "gcp google bigtable database nosql" },
-  { type: "database", techStack: "GCP Spanner", category: "GCP Services", searchTerms: "gcp google spanner database sql" },
-  { type: "database", techStack: "GCP BigQuery", category: "GCP Services", searchTerms: "gcp google bigquery data warehouse analytics" },
+  { type: "database", techStack: "GCP Cloud SQL", category: "GCP Services", searchTerms: "gcp google cloud sql database", aliases: ["Cloud SQL", "Google Cloud SQL"] },
+  { type: "database", techStack: "GCP Firestore", category: "GCP Services", searchTerms: "gcp google firestore database nosql", profile: "nosqlStrong", aliases: ["Firestore", "Cloud Firestore", "Datastore"] },
+  { type: "database", techStack: "GCP Bigtable", category: "GCP Services", searchTerms: "gcp google bigtable database nosql", profile: "nosqlStrong", aliases: ["Bigtable", "Cloud Bigtable"] },
+  { type: "database", techStack: "GCP Spanner", category: "GCP Services", searchTerms: "gcp google spanner database sql", profile: "nosqlStrong", aliases: ["Spanner", "Cloud Spanner", "Google Spanner"] },
+  { type: "database", techStack: "GCP BigQuery", category: "GCP Services", searchTerms: "gcp google bigquery data warehouse analytics", kind: "analytics", aliases: ["BigQuery", "Google BigQuery"] },
+  { type: "cache", techStack: "GCP Memorystore", category: "GCP Services", searchTerms: "gcp google memorystore redis memcached cache", aliases: ["Memorystore"] },
   // GCP Messaging
-  { type: "queue", techStack: "GCP Pub/Sub", category: "GCP Services", searchTerms: "gcp google pubsub pub/sub message queue" },
+  { type: "queue", techStack: "GCP Pub/Sub", category: "GCP Services", searchTerms: "gcp google pubsub pub/sub message queue", aliases: ["Pub/Sub", "Google Pub/Sub", "Cloud Pub/Sub"] },
   // GCP CDN/Network
-  { type: "cdn", techStack: "GCP Cloud CDN", category: "GCP Services", searchTerms: "gcp google cloud cdn edge" },
-  { type: "cdn", techStack: "GCP Cloud DNS", category: "GCP Services", searchTerms: "gcp google cloud dns domain" },
-  { type: "cdn", techStack: "GCP Load Balancing", category: "GCP Services", searchTerms: "gcp google load balancing" },
+  { type: "cdn", techStack: "GCP Cloud CDN", category: "GCP Services", searchTerms: "gcp google cloud cdn edge", kind: "cdn", aliases: ["Cloud CDN", "Google Cloud CDN"] },
+  { type: "cdn", techStack: "GCP Cloud DNS", category: "GCP Services", searchTerms: "gcp google cloud dns domain", kind: "dns", aliases: ["Cloud DNS", "Google Cloud DNS"] },
+  { type: "cdn", techStack: "GCP Load Balancing", category: "GCP Services", searchTerms: "gcp google load balancing", kind: "loadbalancer", aliases: ["Cloud Load Balancing", "GCP Load Balancer", "Google Cloud Load Balancing"] },
+  { type: "cdn", techStack: "GCP Apigee", category: "GCP Services", searchTerms: "gcp google apigee api gateway management", kind: "gateway", aliases: ["Apigee"] },
   // Azure Serverless
-  { type: "serverless", techStack: "Azure Functions", category: "Azure Services", searchTerms: "azure functions serverless" },
-  { type: "serverless", techStack: "Azure Logic Apps", category: "Azure Services", searchTerms: "azure logic apps workflow" },
-  { type: "serverless", techStack: "Azure API Management", category: "Azure Services", searchTerms: "azure api management gateway" },
+  { type: "serverless", techStack: "Azure Functions", category: "Azure Services", searchTerms: "azure functions serverless", aliases: ["Azure Function"] },
+  { type: "serverless", techStack: "Azure Logic Apps", category: "Azure Services", searchTerms: "azure logic apps workflow", aliases: ["Logic Apps"] },
+  { type: "serverless", techStack: "Azure API Management", category: "Azure Services", searchTerms: "azure api management gateway", kind: "gateway", aliases: ["APIM", "Azure APIM"] },
   // Azure Compute
-  { type: "compute", techStack: "Azure VM", category: "Azure Services", searchTerms: "azure vm virtual machine compute" },
-  { type: "container", techStack: "Azure AKS", category: "Azure Services", searchTerms: "azure aks kubernetes k8s" },
-  { type: "container", techStack: "Azure Container Instances", category: "Azure Services", searchTerms: "azure container instances aci" },
+  { type: "compute", techStack: "Azure VM", category: "Azure Services", searchTerms: "azure vm virtual machine compute", aliases: ["Azure Virtual Machine", "Azure Virtual Machines"] },
+  { type: "container", techStack: "Azure AKS", category: "Azure Services", searchTerms: "azure aks kubernetes k8s", aliases: ["AKS", "Azure Kubernetes Service"] },
+  { type: "container", techStack: "Azure Container Instances", category: "Azure Services", searchTerms: "azure container instances aci", aliases: ["ACI"] },
+  { type: "service", techStack: "Azure App Service", category: "Azure Services", searchTerms: "azure app service web apps paas", aliases: ["App Service", "Azure Web Apps"] },
   // Azure Storage
-  { type: "storage", techStack: "Azure Blob Storage", category: "Azure Services", searchTerms: "azure blob storage object" },
+  { type: "storage", techStack: "Azure Blob Storage", category: "Azure Services", searchTerms: "azure blob storage object", aliases: ["Azure Blob", "Azure Storage"] },
   { type: "storage", techStack: "Azure Files", category: "Azure Services", searchTerms: "azure files storage file system" },
-  { type: "storage", techStack: "Azure Disk Storage", category: "Azure Services", searchTerms: "azure disk storage volume" },
+  { type: "storage", techStack: "Azure Disk Storage", category: "Azure Services", searchTerms: "azure disk storage volume", aliases: ["Azure Managed Disks"] },
   // Azure Database
-  { type: "database", techStack: "Azure SQL", category: "Azure Services", searchTerms: "azure sql database" },
-  { type: "database", techStack: "Azure Cosmos DB", category: "Azure Services", searchTerms: "azure cosmos db database nosql" },
-  { type: "database", techStack: "Azure Database for PostgreSQL", category: "Azure Services", searchTerms: "azure postgresql database" },
-  { type: "database", techStack: "Azure Database for MySQL", category: "Azure Services", searchTerms: "azure mysql database" },
-  { type: "cache", techStack: "Azure Cache for Redis", category: "Azure Services", searchTerms: "azure redis cache" },
+  { type: "database", techStack: "Azure SQL", category: "Azure Services", searchTerms: "azure sql database", aliases: ["Azure SQL Database"] },
+  { type: "database", techStack: "Azure Cosmos DB", category: "Azure Services", searchTerms: "azure cosmos db database nosql", profile: "nosql", aliases: ["Cosmos DB", "Cosmos"] },
+  { type: "database", techStack: "Azure Database for PostgreSQL", category: "Azure Services", searchTerms: "azure postgresql database", aliases: ["Azure PostgreSQL", "Azure Postgres"] },
+  { type: "database", techStack: "Azure Database for MySQL", category: "Azure Services", searchTerms: "azure mysql database", aliases: ["Azure MySQL"] },
+  { type: "cache", techStack: "Azure Cache for Redis", category: "Azure Services", searchTerms: "azure redis cache", aliases: ["Azure Redis"] },
+  { type: "database", techStack: "Azure AI Search", category: "Azure Services", searchTerms: "azure ai cognitive search", kind: "search", aliases: ["Azure Cognitive Search", "Azure Search"] },
   // Azure Messaging
-  { type: "queue", techStack: "Azure Service Bus", category: "Azure Services", searchTerms: "azure service bus queue message" },
-  { type: "queue", techStack: "Azure Event Hubs", category: "Azure Services", searchTerms: "azure event hubs stream" },
-  { type: "queue", techStack: "Azure Event Grid", category: "Azure Services", searchTerms: "azure event grid" },
-  { type: "queue", techStack: "Azure Queue Storage", category: "Azure Services", searchTerms: "azure queue storage message" },
+  { type: "queue", techStack: "Azure Service Bus", category: "Azure Services", searchTerms: "azure service bus queue message", aliases: ["Service Bus"] },
+  { type: "queue", techStack: "Azure Event Hubs", category: "Azure Services", searchTerms: "azure event hubs stream", aliases: ["Event Hubs", "Event Hub"] },
+  { type: "queue", techStack: "Azure Event Grid", category: "Azure Services", searchTerms: "azure event grid", aliases: ["Event Grid"] },
+  { type: "queue", techStack: "Azure Queue Storage", category: "Azure Services", searchTerms: "azure queue storage message", aliases: ["Azure Queue", "Azure Queues"] },
   // Azure CDN/Network
-  { type: "cdn", techStack: "Azure CDN", category: "Azure Services", searchTerms: "azure cdn edge" },
-  { type: "cdn", techStack: "Azure DNS", category: "Azure Services", searchTerms: "azure dns domain" },
-  { type: "cdn", techStack: "Azure Front Door", category: "Azure Services", searchTerms: "azure front door cdn" },
+  { type: "cdn", techStack: "Azure CDN", category: "Azure Services", searchTerms: "azure cdn edge", kind: "cdn" },
+  { type: "cdn", techStack: "Azure DNS", category: "Azure Services", searchTerms: "azure dns domain", kind: "dns" },
+  { type: "cdn", techStack: "Azure Front Door", category: "Azure Services", searchTerms: "azure front door cdn", kind: "cdn", aliases: ["Front Door"] },
+  { type: "cdn", techStack: "Azure Load Balancer", category: "Azure Services", searchTerms: "azure load balancer", kind: "loadbalancer" },
+  { type: "cdn", techStack: "Azure Application Gateway", category: "Azure Services", searchTerms: "azure application gateway l7 load balancer", kind: "loadbalancer", aliases: ["Application Gateway", "Azure App Gateway"] },
   // Traditional Databases
-  { type: "database", techStack: "PostgreSQL", category: "Databases", searchTerms: "postgresql postgres sql database" },
-  { type: "database", techStack: "MySQL", category: "Databases", searchTerms: "mysql sql database" },
-  { type: "database", techStack: "MongoDB", category: "Databases", searchTerms: "mongodb mongo nosql database" },
-  { type: "database", techStack: "Redis", category: "Databases", searchTerms: "redis cache database key-value" },
-  { type: "database", techStack: "DynamoDB", category: "Databases", searchTerms: "dynamodb nosql database aws" },
-  { type: "database", techStack: "Cassandra", category: "Databases", searchTerms: "cassandra nosql database" },
-  { type: "database", techStack: "CouchDB", category: "Databases", searchTerms: "couchdb nosql database" },
-  { type: "database", techStack: "Elasticsearch", category: "Databases", searchTerms: "elasticsearch search database" },
-  { type: "database", techStack: "Neo4j", category: "Databases", searchTerms: "neo4j graph database" },
-  { type: "database", techStack: "InfluxDB", category: "Databases", searchTerms: "influxdb timeseries database" },
-  { type: "database", techStack: "TimescaleDB", category: "Databases", searchTerms: "timescaledb timeseries postgresql database" },
-  { type: "database", techStack: "MariaDB", category: "Databases", searchTerms: "mariadb mysql sql database" },
+  { type: "database", techStack: "PostgreSQL", category: "Databases", searchTerms: "postgresql postgres sql database", aliases: ["Postgres", "PG", "PostGIS", "pgvector"] },
+  { type: "database", techStack: "MySQL", category: "Databases", searchTerms: "mysql sql database", aliases: ["Percona"] },
+  { type: "database", techStack: "MongoDB", category: "Databases", searchTerms: "mongodb mongo nosql database", profile: "nosqlStrong", aliases: ["Mongo", "MongoDB Atlas"] },
+  { type: "database", techStack: "Redis", category: "Databases", searchTerms: "redis cache database key-value", kind: "cache", aliases: ["Redis Cluster", "Redis Cache"] },
+  { type: "database", techStack: "DynamoDB", category: "Databases", searchTerms: "dynamodb nosql database aws", profile: "nosql" },
+  { type: "database", techStack: "Cassandra", category: "Databases", searchTerms: "cassandra nosql database", profile: "nosql", aliases: ["Apache Cassandra", "DataStax"] },
+  { type: "database", techStack: "CouchDB", category: "Databases", searchTerms: "couchdb nosql database", profile: "nosql", aliases: ["Apache CouchDB"] },
+  { type: "database", techStack: "Elasticsearch", category: "Databases", searchTerms: "elasticsearch search database", kind: "search", aliases: ["Elastic", "Elastic Search", "ES"] },
+  { type: "database", techStack: "Neo4j", category: "Databases", searchTerms: "neo4j graph database", aliases: ["Graph Database", "Graph DB"] },
+  { type: "database", techStack: "InfluxDB", category: "Databases", searchTerms: "influxdb timeseries database", kind: "analytics", aliases: ["Influx"] },
+  { type: "database", techStack: "TimescaleDB", category: "Databases", searchTerms: "timescaledb timeseries postgresql database", kind: "analytics", aliases: ["Timescale"] },
+  { type: "database", techStack: "MariaDB", category: "Databases", searchTerms: "mariadb mysql sql database", aliases: ["Maria"] },
   { type: "database", techStack: "SQLite", category: "Databases", searchTerms: "sqlite sql database" },
-  { type: "database", techStack: "Oracle", category: "Databases", searchTerms: "oracle sql database" },
-  { type: "database", techStack: "SQL Server", category: "Databases", searchTerms: "sql server mssql database microsoft" },
+  { type: "database", techStack: "Oracle", category: "Databases", searchTerms: "oracle sql database", aliases: ["Oracle DB", "Oracle Database"] },
+  { type: "database", techStack: "SQL Server", category: "Databases", searchTerms: "sql server mssql database microsoft", aliases: ["MSSQL", "MS SQL", "Microsoft SQL Server"] },
+  { type: "database", techStack: "CockroachDB", category: "Databases", searchTerms: "cockroachdb distributed sql database", profile: "nosqlStrong", aliases: ["Cockroach"] },
+  { type: "database", techStack: "YugabyteDB", category: "Databases", searchTerms: "yugabytedb distributed sql database", profile: "nosqlStrong", aliases: ["Yugabyte"] },
+  { type: "database", techStack: "TiDB", category: "Databases", searchTerms: "tidb distributed sql mysql database", profile: "nosqlStrong" },
+  { type: "database", techStack: "Vitess", category: "Databases", searchTerms: "vitess sharded mysql planetscale database", profile: "nosqlStrong", aliases: ["PlanetScale"] },
+  { type: "database", techStack: "ScyllaDB", category: "Databases", searchTerms: "scylladb cassandra nosql database", profile: "nosql", aliases: ["Scylla"] },
+  { type: "database", techStack: "Couchbase", category: "Databases", searchTerms: "couchbase nosql document database", profile: "nosql" },
+  { type: "database", techStack: "HBase", category: "Databases", searchTerms: "hbase hadoop wide column nosql database", profile: "nosqlStrong", aliases: ["Apache HBase"] },
+  { type: "database", techStack: "etcd", category: "Databases", searchTerms: "etcd key value consensus configuration" },
+  { type: "database", techStack: "ZooKeeper", category: "Databases", searchTerms: "zookeeper coordination consensus configuration", aliases: ["Apache ZooKeeper"] },
   // Cache & In-Memory
-  { type: "cache", techStack: "Memcached", category: "Cache & In-Memory", searchTerms: "memcached cache memory" },
+  { type: "cache", techStack: "Memcached", category: "Cache & In-Memory", searchTerms: "memcached cache memory", aliases: ["Memcache"] },
   { type: "cache", techStack: "Hazelcast", category: "Cache & In-Memory", searchTerms: "hazelcast cache memory" },
   { type: "cache", techStack: "Aerospike", category: "Cache & In-Memory", searchTerms: "aerospike cache database" },
+  { type: "cache", techStack: "Valkey", category: "Cache & In-Memory", searchTerms: "valkey redis cache memory" },
+  { type: "cache", techStack: "KeyDB", category: "Cache & In-Memory", searchTerms: "keydb redis cache memory" },
+  { type: "cache", techStack: "Dragonfly", category: "Cache & In-Memory", searchTerms: "dragonfly dragonflydb redis cache memory", aliases: ["DragonflyDB"] },
   // Message Queues
-  { type: "queue", techStack: "Kafka", category: "Message Queues", searchTerms: "kafka message queue stream" },
-  { type: "queue", techStack: "RabbitMQ", category: "Message Queues", searchTerms: "rabbitmq message queue amqp" },
+  { type: "queue", techStack: "Kafka", category: "Message Queues", searchTerms: "kafka message queue stream", aliases: ["Apache Kafka", "Confluent", "Confluent Kafka", "Kafka Topic"] },
+  { type: "queue", techStack: "RabbitMQ", category: "Message Queues", searchTerms: "rabbitmq message queue amqp", aliases: ["Rabbit", "AMQP"] },
   { type: "queue", techStack: "SQS", category: "Message Queues", searchTerms: "sqs queue aws message" },
-  { type: "queue", techStack: "Redis Queue", category: "Message Queues", searchTerms: "redis queue message" },
-  { type: "queue", techStack: "NATS", category: "Message Queues", searchTerms: "nats message queue" },
-  { type: "queue", techStack: "Apache Pulsar", category: "Message Queues", searchTerms: "pulsar message queue stream" },
-  { type: "queue", techStack: "ActiveMQ", category: "Message Queues", searchTerms: "activemq message queue" },
-  { type: "queue", techStack: "ZeroMQ", category: "Message Queues", searchTerms: "zeromq zmq message queue" },
+  { type: "queue", techStack: "Redis Queue", category: "Message Queues", searchTerms: "redis queue message", aliases: ["Redis Streams", "Redis Pub/Sub"] },
+  { type: "queue", techStack: "NATS", category: "Message Queues", searchTerms: "nats message queue", aliases: ["NATS JetStream", "JetStream"] },
+  { type: "queue", techStack: "Apache Pulsar", category: "Message Queues", searchTerms: "pulsar message queue stream", aliases: ["Pulsar"] },
+  { type: "queue", techStack: "ActiveMQ", category: "Message Queues", searchTerms: "activemq message queue", aliases: ["Apache ActiveMQ", "Amazon MQ"] },
+  { type: "queue", techStack: "ZeroMQ", category: "Message Queues", searchTerms: "zeromq zmq message queue", aliases: ["ZMQ", "0MQ"] },
+  { type: "queue", techStack: "Redpanda", category: "Message Queues", searchTerms: "redpanda kafka stream queue" },
+  // Search
+  { type: "database", techStack: "OpenSearch", category: "Search", searchTerms: "opensearch elasticsearch search", kind: "search" },
+  { type: "database", techStack: "Solr", category: "Search", searchTerms: "solr lucene search", kind: "search", aliases: ["Apache Solr"] },
+  { type: "database", techStack: "Meilisearch", category: "Search", searchTerms: "meilisearch search", kind: "search" },
+  { type: "database", techStack: "Typesense", category: "Search", searchTerms: "typesense search", kind: "search" },
+  { type: "database", techStack: "Algolia", category: "Search", searchTerms: "algolia hosted search", kind: "search" },
+  // Analytics
+  { type: "database", techStack: "Snowflake", category: "Analytics", searchTerms: "snowflake data warehouse analytics", kind: "analytics" },
+  { type: "database", techStack: "ClickHouse", category: "Analytics", searchTerms: "clickhouse olap analytics columnar", kind: "analytics" },
+  { type: "database", techStack: "Apache Druid", category: "Analytics", searchTerms: "druid olap analytics", kind: "analytics", aliases: ["Druid"] },
+  { type: "database", techStack: "Apache Pinot", category: "Analytics", searchTerms: "pinot olap analytics", kind: "analytics", aliases: ["Pinot"] },
+  { type: "database", techStack: "Databricks", category: "Analytics", searchTerms: "databricks lakehouse spark analytics", kind: "analytics" },
+  { type: "database", techStack: "Prometheus", category: "Analytics", searchTerms: "prometheus metrics time series monitoring", kind: "analytics" },
+  // Storage
+  { type: "storage", techStack: "MinIO", category: "Storage", searchTerms: "minio s3 object storage" },
+  { type: "storage", techStack: "Cloudflare R2", category: "Storage", searchTerms: "cloudflare r2 object storage", aliases: ["R2"] },
+  { type: "storage", techStack: "Ceph", category: "Storage", searchTerms: "ceph object block storage" },
+  { type: "storage", techStack: "HDFS", category: "Storage", searchTerms: "hdfs hadoop file system storage", aliases: ["Hadoop", "Hadoop HDFS"] },
+  // CDN, proxies and gateways
+  { type: "cdn", techStack: "Cloudflare", category: "CDN & Edge", searchTerms: "cloudflare cdn edge", kind: "cdn", aliases: ["Cloudflare CDN"] },
+  { type: "cdn", techStack: "Fastly", category: "CDN & Edge", searchTerms: "fastly cdn edge", kind: "cdn" },
+  { type: "cdn", techStack: "Akamai", category: "CDN & Edge", searchTerms: "akamai cdn edge", kind: "cdn" },
+  { type: "cdn", techStack: "nginx", category: "CDN & Edge", searchTerms: "nginx reverse proxy load balancer web server", kind: "loadbalancer", aliases: ["NGINX Plus", "OpenResty"] },
+  { type: "cdn", techStack: "Envoy", category: "CDN & Edge", searchTerms: "envoy proxy load balancer service mesh", kind: "loadbalancer", aliases: ["Envoy Proxy"] },
+  { type: "cdn", techStack: "HAProxy", category: "CDN & Edge", searchTerms: "haproxy load balancer proxy", kind: "loadbalancer" },
+  { type: "cdn", techStack: "Traefik", category: "CDN & Edge", searchTerms: "traefik reverse proxy load balancer", kind: "loadbalancer" },
+  { type: "cdn", techStack: "Kubernetes Ingress", category: "CDN & Edge", searchTerms: "kubernetes ingress controller load balancer", kind: "loadbalancer", aliases: ["Ingress", "Ingress Controller", "K8s Ingress"] },
+  { type: "cdn", techStack: "Kong", category: "CDN & Edge", searchTerms: "kong api gateway", kind: "gateway", aliases: ["Kong Gateway"] },
+  { type: "cdn", techStack: "Spring Cloud Gateway", category: "CDN & Edge", searchTerms: "spring cloud gateway api gateway", kind: "gateway" },
   // External Systems
-  { type: "external", techStack: "Third Party API", category: "External Systems", searchTerms: "third party api external" },
-  { type: "external", techStack: "Payment Gateway", category: "External Systems", searchTerms: "payment gateway stripe paypal" },
-  { type: "external", techStack: "Auth Service", category: "External Systems", searchTerms: "auth authentication authorization" },
-  { type: "external", techStack: "Email Service", category: "External Systems", searchTerms: "email service sendgrid mailgun" },
-  { type: "external", techStack: "SMS Service", category: "External Systems", searchTerms: "sms service twilio" },
-  { type: "external", techStack: "Analytics Service", category: "External Systems", searchTerms: "analytics service google analytics" },
+  { type: "external", techStack: "Third Party API", category: "External Systems", searchTerms: "third party api external", aliases: ["External API", "External Service", "Third-Party API", "3rd Party API", "Partner API", "SaaS", "Webhook"] },
+  { type: "external", techStack: "Payment Gateway", category: "External Systems", searchTerms: "payment gateway stripe paypal", aliases: ["Payment Provider", "Payments API", "Payment Processor", "PSP"] },
+  { type: "external", techStack: "Auth Service", category: "External Systems", searchTerms: "auth authentication authorization", aliases: ["Identity Provider", "IdP", "OAuth Provider", "SSO"] },
+  { type: "external", techStack: "Email Service", category: "External Systems", searchTerms: "email service sendgrid mailgun", aliases: ["Email", "Email Provider", "SMTP"] },
+  { type: "external", techStack: "SMS Service", category: "External Systems", searchTerms: "sms service twilio", aliases: ["SMS", "SMS Gateway", "SMS Provider"] },
+  { type: "external", techStack: "Push Service", category: "External Systems", searchTerms: "push notification service mobile", aliases: ["Push Notifications", "Push Notification Service", "Push Provider"] },
+  { type: "external", techStack: "Analytics Service", category: "External Systems", searchTerms: "analytics service google analytics", aliases: ["Google Analytics", "Segment", "Mixpanel", "Amplitude"] },
+  { type: "external", techStack: "Stripe", category: "External Systems", searchTerms: "stripe payments" },
+  { type: "external", techStack: "PayPal", category: "External Systems", searchTerms: "paypal payments" },
+  { type: "external", techStack: "Adyen", category: "External Systems", searchTerms: "adyen payments" },
+  { type: "external", techStack: "Braintree", category: "External Systems", searchTerms: "braintree payments" },
+  { type: "external", techStack: "Twilio", category: "External Systems", searchTerms: "twilio sms voice" },
+  { type: "external", techStack: "SendGrid", category: "External Systems", searchTerms: "sendgrid email" },
+  { type: "external", techStack: "Mailgun", category: "External Systems", searchTerms: "mailgun email" },
+  { type: "external", techStack: "Auth0", category: "External Systems", searchTerms: "auth0 identity login" },
+  { type: "external", techStack: "Okta", category: "External Systems", searchTerms: "okta identity sso" },
+  { type: "external", techStack: "Google Maps", category: "External Systems", searchTerms: "google maps geocoding routing", aliases: ["Google Maps API", "Maps API"] },
+  { type: "external", techStack: "APNs", category: "External Systems", searchTerms: "apns apple push notification", aliases: ["Apple Push Notification Service", "Apple Push"] },
+  { type: "external", techStack: "FCM", category: "External Systems", searchTerms: "fcm firebase cloud messaging push", aliases: ["Firebase Cloud Messaging", "Firebase Messaging"] },
+  { type: "external", techStack: "OpenAI", category: "External Systems", searchTerms: "openai llm ai api", aliases: ["OpenAI API", "LLM API", "LLM"] },
   // Text & Annotations
   { type: "text", techStack: "Text Note", category: "Annotations", searchTerms: "text note annotation comment label" },
   { type: "text", techStack: "Sticky Note", category: "Annotations", searchTerms: "sticky note annotation comment" },
@@ -15330,6 +15442,54 @@ var componentCatalog = [
   { type: "group", techStack: "Security Zone", category: "Grouping", searchTerms: "group security zone boundary" },
   { type: "group", techStack: "Service Group", category: "Grouping", searchTerms: "group service container boundary" }
 ];
+var techKey = (name) => name.toLowerCase().replace(/[^a-z0-9#+]/g, "");
+var entries = componentCatalog;
+var byKey = /* @__PURE__ */ new Map();
+for (const c of entries) {
+  for (const name of [c.techStack, ...c.aliases ?? []]) {
+    const key = techKey(name);
+    if (!byKey.has(key)) byKey.set(key, c);
+  }
+}
+var VERSION = /[\s-]*v?\d+(\.(\d+|x))*\s*$/i;
+function findTech(name) {
+  const exact = byKey.get(techKey(name));
+  if (exact) return exact;
+  const unversioned = name.replace(VERSION, "");
+  return unversioned !== name && unversioned.trim() ? byKey.get(techKey(unversioned)) : void 0;
+}
+function editDistance(a, b) {
+  const d = Array.from({ length: a.length + 1 }, (_, i) => Array.from({ length: b.length + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0));
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost2 = a[i - 1] === b[j - 1] ? 0 : 1;
+      d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost2);
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+    }
+  }
+  return d[a.length][b.length];
+}
+function suggestTech(name, accept = (c) => c.type !== "group" && c.type !== "text" && c.techStack !== "Note") {
+  const key = techKey(name);
+  if (!key) return void 0;
+  let best;
+  for (const c of entries) {
+    if (!accept(c)) continue;
+    for (const candidate of [c.techStack, ...c.aliases ?? []]) {
+      const d = editDistance(key, techKey(candidate));
+      if (!best || d < best.d) best = { tech: c.techStack, d };
+    }
+  }
+  if (best && best.d <= Math.max(1, Math.floor(key.length / 4))) return best.tech;
+  const words = name.toLowerCase().split(/[^a-z0-9.#+]+/).filter(Boolean);
+  for (let n = Math.min(3, words.length); n >= 1; n--) {
+    for (let i = 0; i + n <= words.length; i++) {
+      const found = byKey.get(techKey(words.slice(i, i + n).join(" ")));
+      if (found && accept(found) && techKey(words.slice(i, i + n).join("")).length >= 3) return found.techStack;
+    }
+  }
+  return void 0;
+}
 
 // ../frontend/src/dsl/lexer.ts
 var IDENT_START = /[A-Za-z_]/;
@@ -15479,22 +15639,30 @@ function stripTrailingComment(text) {
   }
   return text;
 }
-function bracketDepth(text) {
-  let depth = 0;
-  let inString = false;
-  for (let i = 0; i < text.length; i++) {
-    const ch = text[i];
-    if (inString) {
-      if (ch === "\\") i++;
-      else if (ch === '"') inString = false;
-      continue;
+var BracketCounter = class {
+  depth = 0;
+  inString = false;
+  escaped = false;
+  /** Adds `text` and returns the depth so far. */
+  feed(text) {
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i];
+      if (this.escaped) {
+        this.escaped = false;
+        continue;
+      }
+      if (this.inString) {
+        if (ch === "\\") this.escaped = true;
+        else if (ch === '"') this.inString = false;
+        continue;
+      }
+      if (ch === '"') this.inString = true;
+      else if (ch === "{" || ch === "[") this.depth++;
+      else if (ch === "}" || ch === "]") this.depth--;
     }
-    if (ch === '"') inString = true;
-    else if (ch === "{" || ch === "[") depth++;
-    else if (ch === "}" || ch === "]") depth--;
+    return this.depth;
   }
-  return depth;
-}
+};
 
 // ../frontend/src/dsl/paths.ts
 var PARAM2 = /^\{[^{}/]+\}$/;
@@ -15532,26 +15700,7 @@ function endpointGroupKey(endpoint, all) {
 var KINDS = ["client", "edge", "cdn", "loadbalancer", "gateway", "dns", "service", "function", "cache", "database", "search", "analytics", "queue", "storage", "external", "other"];
 var DATA_STORE_KINDS = ["cache", "database", "search", "analytics", "queue", "storage"];
 var EDGE_KINDS = ["edge", "cdn", "loadbalancer", "gateway", "dns"];
-var BY_TECH = {
-  "AWS CloudFront": "cdn",
-  "Azure CDN": "cdn",
-  "GCP Cloud CDN": "cdn",
-  "Azure Front Door": "cdn",
-  "AWS Load Balancer": "loadbalancer",
-  "GCP Load Balancing": "loadbalancer",
-  "AWS API Gateway": "gateway",
-  "Azure API Management": "gateway",
-  "AWS Route53": "dns",
-  "Azure DNS": "dns",
-  "GCP Cloud DNS": "dns",
-  Redis: "cache",
-  Elasticsearch: "search",
-  "GCP BigQuery": "analytics",
-  InfluxDB: "analytics",
-  TimescaleDB: "analytics",
-  // A note shape annotates the diagram; it is not a client.
-  Note: "other"
-};
+var BY_TECH = new Map(componentCatalog.flatMap((c) => "kind" in c ? [[c.techStack, c.kind]] : []));
 var BY_TYPE = {
   shape: "client",
   cdn: "edge",
@@ -15567,7 +15716,44 @@ var BY_TYPE = {
 };
 function kindOf(node) {
   if (node.kind !== "component") return "other";
-  return BY_TECH[node.techStack] ?? BY_TYPE[node.type] ?? "other";
+  return node.inferredKind ?? BY_TECH.get(node.techStack) ?? BY_TYPE[node.type] ?? "other";
+}
+var TYPE_OF_KIND = {
+  client: "shape",
+  edge: "cdn",
+  cdn: "cdn",
+  loadbalancer: "cdn",
+  gateway: "cdn",
+  dns: "cdn",
+  service: "service",
+  function: "serverless",
+  cache: "cache",
+  database: "database",
+  search: "database",
+  analytics: "database",
+  queue: "queue",
+  storage: "storage",
+  external: "external",
+  other: "shape"
+};
+var KIND_WORDS = [
+  [/\bsms\b|e-?mail|third.?party|3rd.?party|external|saas|webhook/, "external"],
+  [/\bcdn\b|edge.?cache|content.?delivery/, "cdn"],
+  [/\bdns\b/, "dns"],
+  [/load.?balanc|\blb\b|\balb\b|\bnlb\b|proxy|ingress/, "loadbalancer"],
+  [/gateway|\bapim?\b.*manage/, "gateway"],
+  [/\bwaf\b|firewall/, "edge"],
+  [/cache|memcache/, "cache"],
+  [/queue|\bmq\b|mq$|broker|event.?stream|\bbus\b|topic|pub.?sub|event.?hub|kafka/, "queue"],
+  [/search|lucene|\bindex\b/, "search"],
+  [/warehouse|analytic|olap|data.?lake|lakehouse|time.?series|\btsdb\b/, "analytics"],
+  [/bucket|blob|object.?stor|storage|\bfs\b|file.?system|\bnas\b|\bdisk\b|volume/, "storage"],
+  [/\bdb\b|db$|database|\bsql\b|sql$|nosql|\bstore\b|ledger|key.?value|\bkv\b/, "database"],
+  [/lambda|function|serverless|\bfaas\b/, "function"]
+];
+function kindFromName(tech) {
+  const text = tech.toLowerCase();
+  return KIND_WORDS.find(([words]) => words.test(text))?.[1];
 }
 function isKind(word) {
   return KINDS.includes(word);
@@ -15677,6 +15863,7 @@ var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
 var DEFAULT_TECH = "Rectangle";
 var DEFAULT_GROUP_TECH = "Logical Group";
 var MAX_SCENARIOS = 32;
+var MAX_ALT_DEPTH = 16;
 var REPLICAS = /^x(\d+)$/;
 var PERCENTILES = { p50: 50, p90: 90, p95: 95, p99: 99, p999: 99.9 };
 var FIELD_FLAGS = ["key", "index", "unique", "optional"];
@@ -15688,12 +15875,31 @@ var UNIT_EXAMPLES = {
   MBps: "a bandwidth, e.g. 500 MB/s or 1 GB/s",
   "usd/GB": "a price per gigabyte, e.g. 0.05 usd/GB"
 };
-var CAPACITY_PARTS = "a rate, reads, writes, shards, latency, availability, cost, durable or volatile, consistency, bandwidth or egress";
+var CAPACITY_PARTS = "a rate, reads, writes, shards, latency, availability, cost, durable or volatile, consistency, bandwidth, egress or timeout";
 var ASSERTION_HELP = 'Expected an assertion: "Use case" calls <node>, "Use case" writes <node> before responding, <node> calls <node>, no path from <node> to <node>, <node> has replicas >= 2, \u2026';
 var ASSERTION_VERBS = "calls, every scenario calls, never calls, never waits for, writes, responds, starts at, has scenario or handles failure of";
-var techByName = new Map(
-  componentCatalog.map((c) => [c.techStack.toLowerCase(), { type: c.type, techStack: c.techStack }])
-);
+var GENERIC_TECH = {
+  client: "Actor",
+  edge: "WAF",
+  cdn: "CDN",
+  loadbalancer: "Load Balancer",
+  gateway: "API Gateway",
+  dns: "DNS",
+  service: "Service",
+  function: "Function",
+  cache: "Cache",
+  database: "Database",
+  search: "Search Engine",
+  analytics: "Data Warehouse",
+  queue: "Message Queue",
+  storage: "Object Storage",
+  external: "Third Party API",
+  other: "Note"
+};
+function unknownTechMessage(tech, kind, suggestion) {
+  const simulated = `simulated as a generic ${kind}${suggestion === GENERIC_TECH[kind] ? "" : `, like [${GENERIC_TECH[kind]}]`}`;
+  return suggestion ? `Unknown tech stack '${tech}'. Did you mean '${suggestion}'? Until then it is ${simulated}` : `Unknown tech stack '${tech}'; ${simulated}`;
+}
 function parse(source2, options = {}) {
   return new Parser(source2, options).run();
 }
@@ -15704,8 +15910,12 @@ var Parser = class {
   file;
   stack = [];
   diagnostics = [];
+  /** Warnings reported so far (see `warning`). */
+  warned = /* @__PURE__ */ new Set();
   nodes = /* @__PURE__ */ new Map();
   edges = [];
+  /** Connections so far per `from->to`, for the ids of repeated ones. */
+  edgeCount = /* @__PURE__ */ new Map();
   useCases = [];
   references = [];
   imports = [];
@@ -15782,6 +15992,17 @@ var Parser = class {
     const loc = (t) => this.locOf(t, line);
     const top = this.top();
     if (top?.kind === "section") {
+      if (top.skipped !== void 0) {
+        const opens = tokens[tokens.length - 1].kind === "lbrace";
+        if (first.kind !== "rbrace") top.nested = (top.nested ?? 0) + (opens ? 1 : 0);
+        else if (top.nested) top.nested += opens ? 0 : -1;
+        else {
+          this.stack.pop();
+          if (second?.kind === "ident" && second.value === "alt") this.parseAlt(tokens.slice(1), line);
+          else if (second) this.error("Unexpected input after }", loc(second));
+        }
+        return index;
+      }
       if (first.kind === "rbrace") {
         this.stack.pop();
         if (!top.discard) this.closeSection(top);
@@ -15930,8 +16151,8 @@ var Parser = class {
     if (tokens[i]?.kind === "string") name = tokens[i++].value;
     if (tokens[i]?.kind === "tech") {
       const tech = tokens[i++];
-      const resolved = this.resolveTech(tech, line);
-      if (resolved.type === "group") techStack = resolved.techStack;
+      const resolved = findTech(tech.value);
+      if (resolved?.type === "group") techStack = resolved.techStack;
       else this.warning(`'${tech.value}' is not a group style; using ${DEFAULT_GROUP_TECH}`, this.locOf(tech, line));
     }
     let position;
@@ -16006,6 +16227,12 @@ var Parser = class {
       return;
     }
     this.expectEnd(tokens, i + 1, line);
+    if (this.stack.filter((f) => f.kind === "alt").length >= MAX_ALT_DEPTH) {
+      const loc2 = this.locOf(keyword, line);
+      this.error(`alt blocks can nest at most ${MAX_ALT_DEPTH} deep; this one is skipped`, loc2);
+      this.stack.push({ kind: "section", section: "test", discard: true, skipped: `alt '${nameToken.value}'`, loc: loc2 });
+      return;
+    }
     const owner = top.body;
     let set = owner.openAlt;
     if (!set) {
@@ -16058,6 +16285,7 @@ var Parser = class {
         const resolved = this.resolveTech(t, line);
         node.type = resolved.type;
         node.techStack = resolved.techStack;
+        if (resolved.inferredKind) node.inferredKind = resolved.inferredKind;
         node.kind = resolved.type === "text" ? "text" : resolved.type === "group" ? "group" : "component";
       } else if (t.kind === "team") {
         node.ownerTeam = t.value;
@@ -16099,12 +16327,16 @@ var Parser = class {
     }
     let label = labelToken?.value ?? "";
     let lastLine = index;
-    if (bracketDepth(label) > 0) {
-      while (bracketDepth(label) > 0 && lastLine + 1 < this.lines.length) {
+    const brackets = new BracketCounter();
+    let depth = brackets.feed(label);
+    if (depth > 0) {
+      while (depth > 0 && lastLine + 1 < this.lines.length) {
         lastLine++;
-        label += "\n" + this.lines[lastLine];
+        const more = "\n" + this.lines[lastLine];
+        label += more;
+        depth = brackets.feed(more);
       }
-      if (bracketDepth(label) > 0) this.error("Unclosed { or [ in payload", this.locOf(labelToken, line));
+      if (depth > 0) this.error("Unclosed { or [ in payload", this.locOf(labelToken, line));
       label = label.trimEnd();
     }
     const loc = {
@@ -16139,7 +16371,8 @@ var Parser = class {
       this.error("'-x' marks a failed call and is only allowed in use case steps", this.locOf(arrowToken, line));
     } else {
       const base = `${from}->${to}`;
-      const count = this.edges.filter((e) => e.id === base || e.id.startsWith(`${base}#`)).length;
+      const count = this.edgeCount.get(base) ?? 0;
+      this.edgeCount.set(base, count + 1);
       this.edges.push({ id: count ? `${base}#${count + 1}` : base, source: from, target: to, label: unquote(label) || void 0, loc });
     }
     return lastLine;
@@ -16407,12 +16640,13 @@ var Parser = class {
         if (rps === void 0) return;
         override.rps = rps;
         i++;
-      } else if (isWord(t, "latency") || isWord(t, "availability") || isWord(t, "cost")) {
+      } else if (isWord(t, "latency") || isWord(t, "availability") || isWord(t, "cost") || isWord(t, "timeout")) {
         part = t.value;
-        const unit = part === "latency" ? "ms" : part === "availability" ? "%" : "usd/month";
+        const unit = part === "latency" || part === "timeout" ? "ms" : part === "availability" ? "%" : "usd/month";
         const value = this.quantityOf(tokens[i + 1], unit, t, line);
         if (value === void 0) return;
         if (part === "latency") override.latencyMs = value;
+        else if (part === "timeout") override.timeoutMs = value;
         else if (part === "availability") override.availability = value;
         else override.costUsd = value;
         i += 2;
@@ -16820,7 +17054,7 @@ var Parser = class {
   parseSelectorAtom(tokens, i, line) {
     const t = tokens[i];
     if (t?.kind === "tech") {
-      const tech = techByName.get(t.value.toLowerCase())?.techStack ?? t.value;
+      const tech = findTech(t.value)?.techStack ?? t.value;
       return { selector: { tech }, next: i + 1, token: t, loc: this.locOf(t, line) };
     }
     if (isWord(t, "any")) {
@@ -16845,7 +17079,10 @@ var Parser = class {
   /** Warns about a selector naming a tech stack that does not exist, and (once every file is read) a node that does not. */
   checkSelectorLater({ atoms }) {
     for (const { selector, token, loc } of atoms) {
-      if ("tech" in selector && !techByName.has(token.value.toLowerCase())) this.warning(`Unknown tech stack '${token.value}'`, loc);
+      if ("tech" in selector && !findTech(token.value)) {
+        const suggestion = suggestTech(token.value);
+        this.warning(`Unknown tech stack '${token.value}'${suggestion ? `. Did you mean '${suggestion}'?` : ""}`, loc);
+      }
       if ("node" in selector) {
         this.deferred.push(() => {
           if (!this.nodes.has(selector.node)) this.warning(`Unknown node '${selector.node}'`, loc);
@@ -17005,11 +17242,27 @@ var Parser = class {
   where(first, later) {
     return first.file === later.file ? `on line ${first.line}` : `in ${fileName(first.file ?? this.options.path ?? "the root document")} on line ${first.line}`;
   }
+  /**
+   * A node's `[Tech]`: the catalog entry it names (name or alias), or for an
+   * unknown tech the text as written, with a warning that names the closest
+   * catalog tech. It is drawn and simulated as the kind its name suggests
+   * (`TigerBeetle DB`: database), else the kind of that closest tech
+   * (`Postgress`: database), else a service; never a free, infinitely fast
+   * client.
+   */
   resolveTech(token, line) {
-    const resolved = techByName.get(token.value.toLowerCase());
-    if (resolved) return resolved;
-    this.warning(`Unknown tech stack '${token.value}'; drawing a ${DEFAULT_TECH}`, this.locOf(token, line));
-    return { type: "shape", techStack: DEFAULT_TECH };
+    const found = findTech(token.value);
+    if (found) return { type: found.type, techStack: found.techStack };
+    const text = token.value.trim();
+    if (!text) {
+      this.warning(`Empty tech stack; drawing a ${DEFAULT_TECH}`, this.locOf(token, line));
+      return { type: "shape", techStack: DEFAULT_TECH };
+    }
+    const suggestion = suggestTech(text);
+    const closest = suggestion && findTech(suggestion);
+    const kind = kindFromName(text) ?? (closest ? kindOf({ kind: "component", type: closest.type, techStack: closest.techStack }) : void 0) ?? "service";
+    this.warning(unknownTechMessage(text, kind, suggestion), this.locOf(token, line));
+    return { type: TYPE_OF_KIND[kind], techStack: text, inferredKind: kind };
   }
   useCaseId(name) {
     const base = slug(name) || "usecase";
@@ -17065,7 +17318,12 @@ var Parser = class {
     this.diagnostics.push({ severity: "error", message, ...loc });
   }
   warning(message, loc) {
-    if (this.diagnostics.some((d) => d.message === message && d.line === loc.line && d.col === loc.col && d.file === loc.file)) return;
+    const key = `${loc.file ?? ""}
+${loc.line}
+${loc.col}
+${message}`;
+    if (this.warned.has(key)) return;
+    this.warned.add(key);
     this.diagnostics.push({ severity: "warning", message, ...loc });
   }
 };
@@ -17098,6 +17356,7 @@ function isWord(token, word) {
   return token?.kind === "ident" && token.value === word;
 }
 function sectionName(frame) {
+  if (frame.skipped) return frame.skipped;
   if (frame.entity) return `entity '${frame.entity.name}'`;
   if (frame.decision) return `decision '${frame.decision.title}'`;
   if (frame.test) return `test '${frame.test.name}'`;
@@ -17189,14 +17448,14 @@ function describe(token) {
 
 // ../frontend/src/dsl/format.ts
 function format(source2) {
-  const entries = classify(source2.split("\n").map((l) => l.endsWith("\r") ? l.slice(0, -1) : l));
+  const entries2 = classify(source2.split("\n").map((l) => l.endsWith("\r") ? l.slice(0, -1) : l));
   const out = [];
   let run2 = [];
   const flush = () => {
     if (run2.length) out.push(...renderRun(run2));
     run2 = [];
   };
-  tidyBlankLines(entries).forEach((entry) => {
+  tidyBlankLines(entries2).forEach((entry) => {
     const last = run2[run2.length - 1];
     if (last && (entry.kind !== last.kind || entry.depth !== last.depth || last.kind === "connection" && last.continuation.length || last.kind === "cells" && entry.kind === "cells" && entry.section !== last.section))
       flush();
@@ -17212,19 +17471,19 @@ function format(source2) {
 var INDENT = "  ";
 var KEYWORDS = /* @__PURE__ */ new Set(["title", "import", "group", "usecase", "par", "alt"]);
 function classify(lines) {
-  const entries = [];
+  const entries2 = [];
   let depth = 0;
   let section;
   for (let i = 0; i < lines.length; i++) {
     const raw = lines[i];
     const original = raw.trim();
     if (!original) {
-      entries.push({ kind: "blank", depth, text: "" });
+      entries2.push({ kind: "blank", depth, text: "" });
       continue;
     }
     const { tokens, diagnostics } = tokenizeLine(raw, i + 1);
     if (diagnostics.some((d) => d.severity === "error") || tokens.length === 0) {
-      entries.push({ kind: "line", depth, text: original });
+      entries2.push({ kind: "line", depth, text: original });
       continue;
     }
     const comment = commentOf(raw, tokens);
@@ -17233,22 +17492,22 @@ function classify(lines) {
     const inSection = section !== void 0 && depth === 1 && first.kind !== "rbrace";
     const cells = inSection ? sectionCells(section, raw, tokens) : void 0;
     if (cells) {
-      entries.push({ ...base, kind: "cells", section, cells });
+      entries2.push({ ...base, kind: "cells", section, cells });
       continue;
     }
     if (!inSection && first.kind === "ident" && second?.kind === "arrow" && third?.kind === "ident" && tokens.length <= 4 && (!fourth || fourth.kind === "label")) {
       const entry = { ...base, kind: "connection", from: first.value, arrow: second.value, to: third.value, label: fourth?.value, continuation: [] };
-      if (fourth && bracketDepth(fourth.value) > 0) {
-        const delta = depth * INDENT.length - width(leadingSpace(raw));
-        let label = fourth.value;
-        while (bracketDepth(label) > 0 && i + 1 < lines.length) {
+      const brackets = new BracketCounter();
+      if (fourth && brackets.feed(fourth.value) > 0) {
+        const delta = indent(depth).length - width(leadingSpace(raw));
+        while (i + 1 < lines.length) {
           const next = lines[++i];
-          label += "\n" + next;
           entry.continuation.push(reindent(next, delta));
+          if (brackets.feed("\n" + next) <= 0) break;
         }
         while (entry.continuation[entry.continuation.length - 1] === "") entry.continuation.pop();
       }
-      entries.push(entry);
+      entries2.push(entry);
       continue;
     }
     const oneLineDecision = first.value === "decision" && second?.kind === "string" && third?.kind === "ident" && third.value === "because";
@@ -17256,19 +17515,19 @@ function classify(lines) {
       let k = 1;
       const take = (kind) => tokens[k]?.kind === kind ? source(raw, tokens[k++]) : "";
       const cells2 = [first.value, take("string"), take("tech"), take("team"), join2(raw, tokens.slice(k))];
-      entries.push({ ...base, kind: "node", cells: cells2 });
+      entries2.push({ ...base, kind: "node", cells: cells2 });
       continue;
     }
     const closes = first.kind === "rbrace";
     const opens = tokens[tokens.length - 1].kind === "lbrace";
     const code = join2(raw, tokens);
     const text = withComment(code, comment);
-    entries.push({ kind: "line", depth: Math.max(0, depth - (closes ? 1 : 0)), text: sameTokens(text, tokens) ? text : original, opens, closes });
+    entries2.push({ kind: "line", depth: Math.max(0, depth - (closes ? 1 : 0)), text: sameTokens(text, tokens) ? text : original, opens, closes });
     if (depth === 0) section = sectionOpenedBy(tokens);
     for (const t of tokens) depth = Math.max(0, depth + (t.kind === "lbrace" ? 1 : t.kind === "rbrace" ? -1 : 0));
     if (depth === 0) section = void 0;
   }
-  return entries;
+  return entries2;
 }
 function sectionOpenedBy(tokens) {
   const [first, second] = tokens;
@@ -17302,9 +17561,9 @@ function sectionCells(section, raw, tokens) {
       return void 0;
   }
 }
-function tidyBlankLines(entries) {
+function tidyBlankLines(entries2) {
   const kept = [];
-  for (const entry of entries) {
+  for (const entry of entries2) {
     if (entry.kind !== "blank") {
       if (entry.kind === "line" && entry.closes) while (kept[kept.length - 1]?.kind === "blank") kept.pop();
       kept.push(entry);
@@ -17385,7 +17644,8 @@ var source = (raw, t) => {
 var withComment = (code, comment) => comment ? code + " " + comment : code;
 var leadingSpace = (line) => /^[ \t]*/.exec(line)[0];
 var width = (space) => [...space].reduce((n, ch) => n + (ch === "	" ? INDENT.length : 1), 0);
-var indent = (depth) => INDENT.repeat(depth);
+var MAX_INDENT = 32;
+var indent = (depth) => INDENT.repeat(Math.min(depth, MAX_INDENT));
 var len = (s) => [...s].length;
 var pad = (s, to) => s + " ".repeat(Math.max(0, to - len(s)));
 
@@ -17535,6 +17795,8 @@ function accessIn(diagram) {
 
 // ../frontend/src/sim/profiles.ts
 var NEUTRAL = { rps: Infinity, latencyMs: 0, availability: 1, costUsd: 0, durable: false };
+var INTERNET_EGRESS_USD_PER_GB = 0.09;
+var CDN_EGRESS_USD_PER_GB = 0.02;
 var RELATIONAL = {
   rps: 2e4,
   readRps: 2e4,
@@ -17548,8 +17810,9 @@ var RELATIONAL = {
 };
 var KIND_PROFILES = {
   client: { ...NEUTRAL, bandwidthMBps: 10 },
+  // A firewall or accelerator in front of everything else (WAF, Global Accelerator); `any edge` also selects the four below.
   edge: { rps: 1e5, latencyMs: 2, availability: 0.9999, costUsd: 50, durable: false },
-  cdn: { rps: 2e5, latencyMs: 5, availability: 0.9999, costUsd: 100, durable: false, egressUsdPerGb: 0.02 },
+  cdn: { rps: 2e5, latencyMs: 5, availability: 0.9999, costUsd: 100, durable: false, egressUsdPerGb: CDN_EGRESS_USD_PER_GB },
   loadbalancer: { rps: 1e5, latencyMs: 2, availability: 0.9999, costUsd: 50, durable: false },
   gateway: { rps: 1e4, latencyMs: 10, availability: 0.9995, costUsd: 100, durable: false },
   // Name resolution happens before the request and is cached: off the request path.
@@ -17561,23 +17824,16 @@ var KIND_PROFILES = {
   search: { rps: 3e3, latencyMs: 15, availability: 0.999, costUsd: 400, durable: true, consistency: "eventual" },
   analytics: { rps: 200, latencyMs: 500, availability: 0.999, costUsd: 300, durable: true, consistency: "eventual" },
   queue: { rps: 5e4, latencyMs: 5, availability: 0.9999, costUsd: 200, durable: true, consistency: "strong" },
-  storage: { rps: 5e3, latencyMs: 30, availability: 0.9999, costUsd: 50, durable: true, consistency: "eventual", egressUsdPerGb: 0.09 },
+  storage: { rps: 5e3, latencyMs: 30, availability: 0.9999, costUsd: 50, durable: true, consistency: "eventual" },
   external: { rps: 1e3, latencyMs: 200, availability: 0.999, costUsd: 0, durable: false },
   other: NEUTRAL
 };
 var NOSQL = { rps: 2e4, latencyMs: 5, availability: 0.9999, costUsd: 500, durable: true, consistency: "eventual" };
 var NOSQL_STRONG = { ...NOSQL, consistency: "strong" };
-var TECH_PROFILES = {
-  DynamoDB: NOSQL,
-  "AWS DynamoDB": NOSQL,
-  Cassandra: NOSQL,
-  CouchDB: NOSQL,
-  "Azure Cosmos DB": NOSQL,
-  MongoDB: NOSQL_STRONG,
-  "GCP Bigtable": NOSQL_STRONG,
-  "GCP Firestore": NOSQL_STRONG,
-  "GCP Spanner": NOSQL_STRONG
-};
+var PROFILE_ROWS = { nosql: NOSQL, nosqlStrong: NOSQL_STRONG };
+var TECH_PROFILES = Object.fromEntries(
+  componentCatalog.flatMap((c) => "profile" in c ? [[c.techStack, PROFILE_ROWS[c.profile]]] : [])
+);
 var BANDWIDTH = {
   client: 10,
   edge: 1e3,
@@ -17588,9 +17844,10 @@ var BANDWIDTH = {
   service: 200
 };
 var DEFAULT_BANDWIDTH_MBPS = 100;
+var CHARGES_EGRESS = (kind) => kind !== "client" && kind !== "external" && kind !== "dns" && kind !== "other";
 function profileOf(node, override) {
   const kind = kindOf(node);
-  const base = TECH_PROFILES[node.techStack] ?? KIND_PROFILES[kind];
+  const base = (Object.hasOwn(TECH_PROFILES, node.techStack) ? TECH_PROFILES[node.techStack] : void 0) ?? KIND_PROFILES[kind];
   const baseRead = base.readRps ?? base.rps;
   const baseWrite = base.writeRps ?? base.rps;
   const readRps = override?.readRps ?? override?.rps ?? baseRead;
@@ -17609,7 +17866,8 @@ function profileOf(node, override) {
     durable: override?.durable ?? base.durable,
     ...consistency && isDataStore(kind) ? { consistency } : {},
     bandwidthMBps: override?.bandwidthMBps ?? base.bandwidthMBps ?? BANDWIDTH[kind] ?? DEFAULT_BANDWIDTH_MBPS,
-    egressUsdPerGb: override?.egressUsdPerGb ?? base.egressUsdPerGb ?? 0
+    egressUsdPerGb: override?.egressUsdPerGb ?? base.egressUsdPerGb ?? (CHARGES_EGRESS(kind) ? INTERNET_EGRESS_USD_PER_GB : 0),
+    ...override?.timeoutMs !== void 0 ? { timeoutMs: override.timeoutMs } : {}
   };
 }
 function capacityOf(p, replicas) {
@@ -17762,10 +18020,11 @@ function formatUsd(usd) {
 var DEFAULT_TIMEOUT_MS = 1e3;
 var HOT = 0.7;
 var QUEUE_CAP = 0.95;
+var FAILOVER_SHARE = 0.1;
+var SERVICE_SPREAD = 0.5;
 var SECONDS_PER_MONTH = 2592e3;
 var BYTES_PER_MB = 1e6;
 var BYTES_PER_GB = 1e9;
-var PERCENTILE_FACTORS = { 50: 1, 90: 1.6, 95: 2, 99: 3, 99.9: 5 };
 var PERCENTILE_KEYS = { 50: "p50", 90: "p90", 95: "p95", 99: "p99", 99.9: "p999" };
 var PERCENTILES2 = Object.keys(PERCENTILE_KEYS).map(Number);
 function components(diagram) {
@@ -17806,7 +18065,9 @@ function forEachStepRate(diagram, traffic, visit) {
     const { rps, shares } = traffic.get(u.id) ?? { rps: 0, shares: [] };
     u.scenarios.forEach((s, i) => {
       const rate = rps * (shares[i] ?? 0);
-      if (rate > 0) for (const step of s.steps) visit(step, rate);
+      if (rate > 0) {
+        for (const step of s.steps) if (!step.failed) visit(step, rate);
+      }
     });
   }
 }
@@ -17820,35 +18081,76 @@ function computeLoad(diagram, traffic) {
   });
   return load;
 }
-var egressSource = (step, access) => access === "read" ? step.toServiceId : step.fromServiceId;
-function computeEgressGb(diagram, traffic) {
+var payloadDirection = (step, access) => access === "read" ? { from: step.toServiceId, to: step.fromServiceId } : { from: step.fromServiceId, to: step.toServiceId };
+var OUTSIDE = (kind) => kind === "client" || kind === "external";
+function computeEgressGb(diagram, traffic, kindOf2 = (id) => profileOfId(diagram, id)) {
   const gb = /* @__PURE__ */ new Map();
   const access = accessIn(diagram);
   forEachStepRate(diagram, traffic, (step, rate) => {
     if (!step.sizeBytes || step.sizeBytes <= 0) return;
-    const source2 = egressSource(step, access(step));
-    gb.set(source2, (gb.get(source2) ?? 0) + rate * multiplierOf(step) * step.sizeBytes * SECONDS_PER_MONTH / BYTES_PER_GB);
+    const { from, to } = payloadDirection(step, access(step));
+    if (OUTSIDE(kindOf2(from)) || !OUTSIDE(kindOf2(to))) return;
+    gb.set(from, (gb.get(from) ?? 0) + rate * multiplierOf(step) * step.sizeBytes * SECONDS_PER_MONTH / BYTES_PER_GB);
   });
   return gb;
 }
+var BANDWIDTH_BOUND = (kind) => !["client", "external", "dns", "other", "storage", "cdn"].includes(kind);
+function computeBytesPerSecond(diagram, traffic) {
+  const bytes = /* @__PURE__ */ new Map();
+  forEachStepRate(diagram, traffic, (step, rate) => {
+    if (!step.sizeBytes || step.sizeBytes <= 0) return;
+    const b = rate * multiplierOf(step) * step.sizeBytes;
+    for (const id of /* @__PURE__ */ new Set([step.fromServiceId, step.toServiceId])) bytes.set(id, (bytes.get(id) ?? 0) + b);
+  });
+  return bytes;
+}
+function profileOfId(diagram, id) {
+  const node = diagram.nodes.find((n) => n.id === id);
+  return node ? profileOf(node).kind : "client";
+}
 function transferMs(step, bandwidthOf) {
   if (!step.sizeBytes || step.sizeBytes <= 0) return 0;
   const mbps = Math.min(bandwidthOf(step.fromServiceId), bandwidthOf(step.toServiceId));
-  return mbps > 0 && Number.isFinite(mbps) ? step.sizeBytes / BYTES_PER_MB / mbps * 1e3 : 0;
+  return mbps > 0 && Number.isFinite(mbps) ? multiplierOf(step) * step.sizeBytes / BYTES_PER_MB / mbps * 1e3 : 0;
 }
 var utilizationOf = (load, capacity) => Number.isFinite(capacity) && capacity > 0 ? load / capacity : 0;
-var hopLatency = (baseMs, utilization) => baseMs / (1 - Math.min(utilization, QUEUE_CAP));
+function erlangC(servers, rho) {
+  if (rho <= 0) return 0;
+  if (rho >= 1) return 1;
+  const c = Math.max(1, Math.round(servers));
+  const a = c * rho;
+  let b = 1;
+  for (let k = 1; k <= c; k++) b = a * b / (k + a * b);
+  return b / (1 - rho * (1 - b));
+}
+function hopModel(baseMs, rho, servers = 1) {
+  const r = Math.min(Math.max(rho, 0), QUEUE_CAP);
+  const c = Math.max(1, Math.round(servers));
+  const waitProbability = erlangC(c, r);
+  const meanMs = baseMs + waitProbability * baseMs / (c * (1 - r));
+  const fixedMs = (1 - SERVICE_SPREAD) * baseMs;
+  return { fixedMs, tailMs: meanMs - fixedMs, waitProbability };
+}
+var hopMean = (h) => h.fixedMs + h.tailMs;
+var tailFactor = (p) => -Math.log(1 - p);
 var replicatedAvailability = (a, replicas) => 1 - (1 - a) ** replicas;
-function usageOf(p, replicas, readLoadRps, writeLoadRps) {
+var primaryAvailability = (a, replicas) => replicas >= 2 ? 1 - (1 - a) * FAILOVER_SHARE : a;
+function usageOf(p, replicas, readLoadRps, writeLoadRps, bytesPerSecond = 0) {
   const { readRps: readCapacityRps, writeRps: writeCapacityRps } = capacityOf(p, replicas);
   const readUtilization = utilizationOf(readLoadRps, readCapacityRps);
   const writeUtilization = utilizationOf(writeLoadRps, writeCapacityRps);
-  const utilization = combinedUtilization(p, readUtilization, writeUtilization);
+  const requestUtilization = combinedUtilization(p, readUtilization, writeUtilization);
   const loadRps = readLoadRps + writeLoadRps;
+  const bound = BANDWIDTH_BOUND(p.kind);
+  const bandwidthLoadMBps = bound ? bytesPerSecond / BYTES_PER_MB : 0;
+  const bandwidthCapacityMBps = bound ? p.bandwidthMBps * replicas * p.shards : 0;
+  const bandwidthUtilization = utilizationOf(bandwidthLoadMBps, bandwidthCapacityMBps);
+  const utilization = Math.max(requestUtilization, bandwidthUtilization);
   return {
     loadRps,
-    capacityRps: readCapacityRps === writeCapacityRps || utilization === 0 ? readCapacityRps : loadRps / utilization,
+    capacityRps: readCapacityRps === writeCapacityRps || requestUtilization === 0 ? readCapacityRps : loadRps / requestUtilization,
     utilization,
+    requestUtilization,
     saturated: utilization >= 1,
     readLoadRps,
     writeLoadRps,
@@ -17856,27 +18158,68 @@ function usageOf(p, replicas, readLoadRps, writeLoadRps) {
     writeCapacityRps,
     readUtilization,
     writeUtilization,
+    bandwidthLoadMBps,
+    bandwidthCapacityMBps,
+    bandwidthUtilization,
     writeScaling: p.writeScaling
   };
 }
+var bandwidthBound = (n) => n.bandwidthUtilization > n.requestUtilization;
+var serversOf = (n, replicas) => writeBound(n) ? 1 : replicas;
 function usageText(n) {
   const part = (load, capacity, rho) => `${formatRps(load)} of ${formatRps(capacity)}, ${formatPercent(rho)}`;
+  if (bandwidthBound(n)) {
+    const mb = (x) => `${Number(x.toPrecision(3)).toLocaleString("en-US")} MB/s`;
+    return `bandwidth ${mb(n.bandwidthLoadMBps)} of ${mb(n.bandwidthCapacityMBps)}, ${formatPercent(n.bandwidthUtilization)}`;
+  }
   if (n.writeScaling === "shards" && n.writeLoadRps > 0) {
     return `reads ${part(n.readLoadRps, n.readCapacityRps, n.readUtilization)}; writes ${part(n.writeLoadRps, n.writeCapacityRps, n.writeUtilization)}`;
   }
-  return part(n.loadRps, n.capacityRps, n.utilization);
+  return part(n.loadRps, n.capacityRps, n.requestUtilization);
 }
 var writeBound = (n) => n.writeScaling === "shards" && n.writeUtilization >= n.readUtilization && n.writeLoadRps > 0;
-function useCasePercentile(scenarios, q) {
-  const tail = 1 - q / 100 - 1e-9;
-  const heavy = scenarios.filter((s) => s.share >= tail && s.share > 0);
-  if (heavy.length) return Math.max(...heavy.map((s) => s.value));
-  let covered = 0;
-  for (const s of [...scenarios].sort((a, b) => b.value - a.value)) {
-    covered += s.share;
-    if (covered >= tail) return s.value;
-  }
-  return scenarios.length ? Math.max(...scenarios.map((s) => s.value)) : 0;
+function pathMean(path) {
+  return path.parts.reduce((sum, part) => sum + Math.max(0, ...part.map((i) => i.fixedMs + i.tailMs)), 0);
+}
+function pathAt(path, l) {
+  let sum = 0;
+  for (const part of path.parts) {
+    let most = 0;
+    for (const i of part) most = Math.max(most, i.fixedMs + i.tailMs * l);
+    sum += most;
+  }
+  return sum;
+}
+var pathQuantile = (path, p) => pathAt(path, tailFactor(p));
+function pathCdf(path, t) {
+  if (pathAt(path, 0) > t) return 0;
+  let hi = 1;
+  while (pathAt(path, hi) <= t) {
+    hi *= 2;
+    if (hi > 1e6) return 1;
+  }
+  let lo = 0;
+  for (let i = 0; i < 50; i++) {
+    const mid = (lo + hi) / 2;
+    if (pathAt(path, mid) <= t) lo = mid;
+    else hi = mid;
+  }
+  return 1 - Math.exp(-lo);
+}
+function mixtureQuantile(paths, q) {
+  const live = paths.filter((s) => s.share > 0);
+  if (live.length === 0) return 0;
+  if (live.length === 1) return pathQuantile(live[0].path, q);
+  const total = live.reduce((sum, s) => sum + s.share, 0);
+  const cdf = (t) => live.reduce((sum, s) => sum + s.share * pathCdf(s.path, t), 0) / total;
+  let lo = Math.min(...live.map((s) => pathQuantile(s.path, 0)));
+  let hi = Math.max(...live.map((s) => pathQuantile(s.path, q)));
+  for (let i = 0; i < 60 && hi - lo > 1e-9 * Math.max(1, hi); i++) {
+    const mid = (lo + hi) / 2;
+    if (cdf(mid) >= q) hi = mid;
+    else lo = mid;
+  }
+  return hi;
 }
 function mainScenarioIndex(shares) {
   let best = 0;
@@ -17893,20 +18236,27 @@ function profilesOf(diagram, warnings = []) {
   return new Map(nodes.map((n) => [n.id, profileOf(n, overrides.get(n.id))]));
 }
 function analyze(diagram, options = {}) {
-  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const defaultTimeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const warnings = [];
   const nodes = components(diagram);
   const profiles = profilesOf(diagram, warnings);
+  const kindOf2 = (id) => profiles.get(id)?.kind ?? "client";
   const traffic = resolveTraffic(diagram, warnings);
   const load = computeLoad(diagram, traffic);
-  const egress = computeEgressGb(diagram, traffic);
+  const egress = computeEgressGb(diagram, traffic, kindOf2);
+  const bytes = computeBytesPerSecond(diagram, traffic);
+  const hops = /* @__PURE__ */ new Map();
   const nodeResults = nodes.map((n) => {
     const p = profiles.get(n.id);
-    const replicas = replicasOf(n);
+    const replicas = Math.max(1, options.replicas?.get(n.id) ?? replicasOf(n));
     const { read, write } = load.get(n.id) ?? { read: 0, write: 0 };
-    const usage = usageOf(p, replicas, read, write);
+    const usage = usageOf(p, replicas, read, write, bytes.get(n.id) ?? 0);
+    const servers = serversOf(usage, replicas);
+    const hop = hopModel(p.latencyMs, usage.utilization, servers);
+    hops.set(n.id, hop);
     const egressGbPerMonth = egress.get(n.id) ?? 0;
     const egressUsd = egressGbPerMonth * p.egressUsdPerGb;
+    const availability2 = replicatedAvailability(p.availability, replicas);
     return {
       id: n.id,
       kind: p.kind,
@@ -17914,8 +18264,11 @@ function analyze(diagram, options = {}) {
       shards: p.shards,
       ...usage,
       ...p.consistency ? { consistency: p.consistency } : {},
-      latencyMs: hopLatency(p.latencyMs, usage.utilization),
-      availability: replicatedAvailability(p.availability, replicas),
+      servers,
+      waitProbability: hop.waitProbability,
+      latencyMs: hopMean(hop),
+      availability: availability2,
+      writeAvailability: p.writeScaling === "shards" ? primaryAvailability(p.availability, replicas) : availability2,
       costUsd: replicas * p.shards * p.costUsd + egressUsd,
       egressGbPerMonth,
       egressUsd,
@@ -17923,28 +18276,49 @@ function analyze(diagram, options = {}) {
     };
   });
   const nodeById = new Map(nodeResults.map((n) => [n.id, n]));
-  const hopMs = (id) => nodeById.get(id)?.latencyMs ?? 0;
-  const availabilityOf = (id) => nodeById.get(id)?.availability ?? 1;
   const bandwidthOf = (id) => profiles.get(id)?.bandwidthMBps ?? Infinity;
+  const timeoutOf = (id) => profiles.get(id)?.timeoutMs ?? defaultTimeoutMs;
   for (const n of nodeResults) {
     const usage = usageText(n);
     if (n.saturated) warnings.push(`'${n.id}' is saturated: ${usage}. ${writeBound(n) ? "Add shards for writes" : "Add replicas"} or take load off it.`);
     else if (n.utilization > HOT) warnings.push(`'${n.id}' runs hot: ${usage}.`);
   }
+  const access = accessIn(diagram);
+  const pathOf = (hopsOfPath) => ({
+    parts: hopsOfPath.map(
+      (part) => part.map((h) => {
+        if (h.failed) return { fixedMs: timeoutOf(h.target), tailMs: 0 };
+        const hop = hops.get(h.target) ?? { fixedMs: 0, tailMs: 0 };
+        return { fixedMs: transferMs(h.step, bandwidthOf) + hop.fixedMs, tailMs: hop.tailMs };
+      })
+    )
+  });
   const useCases = diagram.useCases.map((u) => {
     const { rps, shares } = traffic.get(u.id);
-    const scenarios = u.scenarios.map((s, i) => {
-      const meanMs = criticalPath(u, s).reduce(
-        (sum, part) => sum + Math.max(...part.map((hop) => hop.failed ? timeoutMs : hopMs(hop.target) + transferMs(hop.step, bandwidthOf))),
-        0
-      );
-      return { id: s.id, name: s.name, share: shares[i] ?? 0, meanMs, percentiles: percentilesOf(meanMs) };
-    });
-    const percentiles = Object.fromEntries(
-      PERCENTILES2.map((q) => [PERCENTILE_KEYS[q], useCasePercentile(scenarios.map((s) => ({ share: s.share, value: s.percentiles[PERCENTILE_KEYS[q]] })), q)])
+    const paths = u.scenarios.map((s) => pathOf(criticalPath(u, s)));
+    const scenarios = u.scenarios.map((s, i) => ({
+      id: s.id,
+      name: s.name,
+      share: shares[i] ?? 0,
+      meanMs: pathMean(paths[i]),
+      percentiles: Object.fromEntries(PERCENTILES2.map((q) => [PERCENTILE_KEYS[q], pathQuantile(paths[i], q / 100)]))
+    }));
+    const weighted = paths.map((path, i) => ({ share: shares[i] ?? 0, path }));
+    const percentiles = Object.fromEntries(PERCENTILES2.map((q) => [PERCENTILE_KEYS[q], mixtureQuantile(weighted, q / 100)]));
+    const tailScenario = Object.fromEntries(
+      PERCENTILES2.map((q) => {
+        const t = percentiles[PERCENTILE_KEYS[q]];
+        const above = weighted.map((s) => s.share > 0 ? s.share * (1 - pathCdf(s.path, t * (1 - 1e-9))) : -1);
+        return [PERCENTILE_KEYS[q], Math.max(0, above.indexOf(Math.max(...above)))];
+      })
     );
     if (rps > 0 && u.scenarios.length === 0) warnings.push(`"${u.name}" has traffic but no steps`);
-    return { id: u.id, name: u.name, rps, scenarios, percentiles, availability: useCaseAvailability(u, shares, availabilityOf) };
+    const writes = mainWrites(u, shares, (step) => access(step) === "write");
+    const availabilityOf = (id) => {
+      const n = nodeById.get(id);
+      return !n ? 1 : writes.has(id) ? n.writeAvailability : n.availability;
+    };
+    return { id: u.id, name: u.name, rps, scenarios, percentiles, tailScenario, availability: useCaseAvailability(u, shares, availabilityOf) };
   });
   return {
     nodes: nodeResults,
@@ -17955,8 +18329,10 @@ function analyze(diagram, options = {}) {
     warnings
   };
 }
-function percentilesOf(meanMs) {
-  return Object.fromEntries(PERCENTILES2.map((q) => [PERCENTILE_KEYS[q], meanMs * PERCENTILE_FACTORS[q]]));
+function mainWrites(useCase, shares, isWrite) {
+  if (useCase.scenarios.length === 0) return /* @__PURE__ */ new Set();
+  const path = criticalPath(useCase, useCase.scenarios[mainScenarioIndex(shares)]).flat();
+  return new Set(path.filter((h) => !h.failed && !h.async && isWrite(h.step)).map((h) => h.target));
 }
 function useCaseAvailability(useCase, shares, availabilityOf) {
   if (useCase.scenarios.length === 0) return 1;
@@ -17983,9 +18359,9 @@ function singlePointsOfFailure(diagram) {
 // ../frontend/src/sim/tests.ts
 var pass = (message) => ({ passed: true, message });
 var fail = (message, hint) => ({ passed: false, message, hint });
-function runTests(diagram, analysis = analyze(diagram)) {
+function makeRun(diagram, analysis) {
   const access = accessIn(diagram);
-  const run2 = {
+  return {
     diagram,
     analysis,
     nodes: new Map(analysis.nodes.map((n) => [n.id, n])),
@@ -17994,6 +18370,9 @@ function runTests(diagram, analysis = analyze(diagram)) {
     profiles: profilesOf(diagram),
     isWrite: (step) => access(step) === "write"
   };
+}
+function runTests(diagram, analysis = analyze(diagram)) {
+  const run2 = makeRun(diagram, analysis);
   const results = (diagram.requirements ?? []).map((r, i) => {
     const { passed, message, hint } = requirement(run2, r);
     return { id: `req:${i + 1}`, name: requirementName(r), category: CATEGORY[r.kind], passed, message, hint, loc: r.loc };
@@ -18085,7 +18464,7 @@ function latency(run2, u, q, maxMs) {
   const value = `${key} of ${u.name} is ${formatMs(ms)}${result.rps > 0 ? "" : " with no traffic"}`;
   const message = `${value} (limit ${formatMs(maxMs)})`;
   if (ms < maxMs) return { ...pass(message), value };
-  const index = Math.max(0, result.scenarios.findIndex((s) => s.percentiles[key] === ms));
+  const index = Math.min(result.tailScenario[key] ?? 0, u.scenarios.length - 1);
   const lead = u.scenarios.length > 1 ? `The "${u.scenarios[index].name}" path (${formatPercent(result.scenarios[index].share)} of traffic) sets ${key}. ` : "";
   return { ...fail(message, lead + latencyHint(run2, u, u.scenarios[index])), value };
 }
@@ -18104,6 +18483,10 @@ function scenarioLatency(run2, useCase, scenario, q, maxMs) {
 }
 function saturationHint(run2, n) {
   const label = nodeLabel(run2.diagram, n.id);
+  if (bandwidthBound(n)) {
+    const replicas2 = Math.ceil(n.bandwidthUtilization * n.replicas / HOT);
+    return `${label} moves more payload bytes than its network carries. Send the bytes around it (clients upload to and download from object storage or a CDN directly, with presigned URLs), or add replicas: x${replicas2} keeps its bandwidth under ${formatPercent(HOT)}`;
+  }
   if (writeBound(n)) {
     const perShard = n.writeCapacityRps / n.shards;
     const shards = Math.ceil(n.writeLoadRps / (perShard * HOT));
@@ -18115,11 +18498,12 @@ function saturationHint(run2, n) {
 }
 function latencyHint(run2, u, scenario) {
   const hops = criticalPath(u, scenario).flat();
-  const cost2 = (h) => h.failed ? DEFAULT_TIMEOUT_MS : run2.nodes.get(h.target)?.latencyMs ?? 0;
+  const timeout = (id) => run2.profiles.get(id)?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const cost2 = (h) => h.failed ? timeout(h.target) : run2.nodes.get(h.target)?.latencyMs ?? 0;
   const slowest = hops.reduce((best, h) => !best || cost2(h) > cost2(best) ? h : best, void 0);
   if (!slowest) return "Shorten the synchronous path of the request.";
   const label = nodeLabel(run2.diagram, slowest.target);
-  if (slowest.failed) return `It waits ${formatMs(DEFAULT_TIMEOUT_MS)} for the failed call to ${label}; give that path a smaller share of traffic or avoid the call.`;
+  if (slowest.failed) return `It waits ${formatMs(timeout(slowest.target))} for the failed call to ${label}; give that path a smaller share of traffic, avoid the call, or time out sooner (capacity { ${slowest.target} timeout 200ms }).`;
   const sized = hops.find((h) => (h.step.sizeBytes ?? 0) > 0);
   const node = run2.nodes.get(slowest.target);
   if (node && node.utilization > HOT) return `${label} runs at ${formatPercent(node.utilization)} and queues requests; add replicas to it.`;
@@ -18133,8 +18517,11 @@ function availability(run2, u, minPercent) {
   if (result.availability * 100 >= minPercent - 1e-9) return { ...pass(message), value };
   const shares = run2.shares.get(u.id) ?? [];
   const main = u.scenarios.length ? pathNodes(u, u.scenarios[mainScenarioIndex(shares)]) : [];
-  const weakest = main.filter((id) => fallbacksFor(u, id).length === 0).map((id) => run2.nodes.get(id)).filter((n) => !!n && n.availability < 1).sort((a, b) => a.availability - b.availability)[0];
-  const hint = weakest ? `The weakest link is ${nodeLabel(run2.diagram, weakest.id)} at ${formatAvailability(weakest.availability)}: add a replica (x${weakest.replicas + 1}) or a fallback scenario that calls it with -x and still completes` : "Add replicas to the nodes on the main path, or fallback scenarios that complete without them";
+  const writes = mainWrites(u, shares, run2.isWrite);
+  const effective = (n) => writes.has(n.id) ? n.writeAvailability : n.availability;
+  const weakest = main.filter((id) => fallbacksFor(u, id).length === 0).map((id) => run2.nodes.get(id)).filter((n) => !!n && effective(n) < 1).sort((a, b) => effective(a) - effective(b))[0];
+  const primaryBound = weakest && writes.has(weakest.id) && weakest.writeAvailability < weakest.availability;
+  const hint = !weakest ? "Add replicas to the nodes on the main path, or fallback scenarios that complete without them" : primaryBound ? `The weakest link is writing to ${nodeLabel(run2.diagram, weakest.id)}: writes need its primary, ${formatAvailability(weakest.writeAvailability)} with failover${weakest.replicas < 2 ? " (none without a second replica; add one)" : ` (a replica takes over, but about ${formatPercent(FAILOVER_SHARE)} of each outage is lost)`}. Move the writes to a partitioned store, or add a fallback scenario that calls it with -x and still completes` : `The weakest link is ${nodeLabel(run2.diagram, weakest.id)} at ${formatAvailability(effective(weakest))}: add a replica (x${weakest.replicas + 1}) or a fallback scenario that calls it with -x and still completes`;
   return { ...fail(message, hint), value };
 }
 function writeGap(run2, u, s, accept) {
@@ -18192,20 +18579,34 @@ function survive(run2, target) {
   if (selected.length === 0) {
     return target === "any" ? pass("No nodes to lose") : fail(`No node matches ${what}`, "Use a node id, [Tech] or any <kind>");
   }
+  const latencies = (run2.diagram.requirements ?? []).filter((r) => r.kind === "latency" && requirement(run2, r).passed);
   const failures = [];
   for (const node of selected) {
     const n = run2.nodes.get(node.id);
     const label = nodeLabel(run2.diagram, node.id);
     const replicas = replicasOf(node);
     if (replicas >= 2) {
-      const left = usageOf(run2.profiles.get(node.id), replicas - 1, n.readLoadRps, n.writeLoadRps);
+      const degraded = makeRun(run2.diagram, analyze(run2.diagram, { replicas: /* @__PURE__ */ new Map([[node.id, replicas - 1]]) }));
+      const left = degraded.nodes.get(node.id);
+      const lost = n.shards > 1 ? `one of the ${replicas} replicas of a ${node.id} shard` : `one of ${replicas} ${node.id} replicas`;
       if (left.saturated) {
+        const leaves = bandwidthBound(left) ? `leaves ${usageText(left)}` : n.shards > 1 ? `leaves that shard ${formatRps(left.capacityRps / n.shards)} for ${formatRps(n.loadRps / n.shards)}` : `leaves ${formatRps(left.capacityRps)} for ${formatRps(n.loadRps)}`;
         failures.push(
           fail(
-            `Losing one of ${replicas} ${node.id} replicas leaves ${formatRps(left.capacityRps)} for ${formatRps(n.loadRps)} (${formatPercent(left.utilization)})`,
+            `Losing ${lost} ${leaves}${bandwidthBound(left) ? "" : ` (${formatPercent(left.utilization)})`}`,
             writeBound(left) ? saturationHint(run2, { ...n, ...left }) : `Add a replica to ${label} (x${replicas + 1}) so the rest carry the load`
           )
         );
+        continue;
+      }
+      const broken = latencies.map((r) => requirement(degraded, r)).find((c) => !c.passed);
+      if (broken) {
+        failures.push(
+          fail(
+            `Losing ${lost} breaks a latency limit: ${broken.message}`,
+            `Add a replica to ${label} (x${replicas + 1}) so the rest keep it under ${formatPercent(HOT)}, or take load off it`
+          )
+        );
       }
       continue;
     }
@@ -18467,16 +18868,16 @@ function startsAt(run2, a) {
   const ids = idsOf(run2, a.target);
   const what = selectorText(a.target);
   if (ids.size === 0) return noMatch(a.target);
-  const entries = u.scenarios.map((s) => s.steps[0]).filter((s) => !!s);
-  if (entries.length === 0) return fail(`${quote(u.name)} has no steps`, `Start "${u.name}" with a step sent by ${what}`);
-  const wrong = entries.find((s) => !ids.has(s.fromServiceId));
+  const entries2 = u.scenarios.map((s) => s.steps[0]).filter((s) => !!s);
+  if (entries2.length === 0) return fail(`${quote(u.name)} has no steps`, `Start "${u.name}" with a step sent by ${what}`);
+  const wrong = entries2.find((s) => !ids.has(s.fromServiceId));
   if (wrong) {
     return fail(
       `${quote(u.name)} starts at ${nodeLabel(run2.diagram, wrong.fromServiceId)}, not ${what}: ${stepText(wrong)}`,
       `Make the first step of "${u.name}" a step sent by ${what}`
     );
   }
-  return pass(`${quote(u.name)} starts at ${nodeLabel(run2.diagram, entries[0].fromServiceId)}`);
+  return pass(`${quote(u.name)} starts at ${nodeLabel(run2.diagram, entries2[0].fromServiceId)}`);
 }
 function statusMatches(status, wanted) {
   if (status === void 0) return false;
@@ -19444,7 +19845,7 @@ ${PROBLEM_USAGE}`);
 }
 
 // src/cli.ts
-var VERSION = true ? "0.5.0" : "dev";
+var VERSION2 = true ? "0.7.0" : "dev";
 var USAGE = `Usage:
   proschi check [--strict] [--format text|github|json] [--openapi <node>=<spec>]... <file|dir>...
   proschi parse <file>
@@ -19506,7 +19907,7 @@ function format2(results, style) {
 function run(argv, out = console.log, err = console.error) {
   const [command, ...rest] = argv;
   if (command === "--version" || command === "-v") {
-    out(VERSION);
+    out(VERSION2);
     return 0;
   }
   if (!command || command === "--help" || command === "-h" || command === "help") {