npm - proschi - Versions diffs - 0.6.0 → 0.8.0 - Mend

proschi 0.6.0 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md +1 -1
package/dist/cli.cjs +640 -218
package/dist/render.cjs +159 -159
package/dist/server.cjs +595 -219
package/grammar/proschi.tmLanguage.json +1 -1
package/package.json +2 -2
package/schema/proschi-diagram.schema.json +138 -6

package/dist/cli.cjs CHANGED Viewed

@@ -2237,8 +2237,8 @@ var require_resolve = __commonJS({
       }
       return count;
     }
-    function getFullPath(resolver, id = "", normalize) {
-      if (normalize !== false)
+    function getFullPath(resolver, id = "", normalize2) {
+      if (normalize2 !== false)
         id = normalizeId(id);
       const p = resolver.parse(id);
       return _getFullPath(resolver, p);
@@ -3833,7 +3833,7 @@ var require_fast_uri = __commonJS({
       }
       return decodedScheme;
     }
-    function normalize(uri, options) {
+    function normalize2(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
         normalizeString(uri, options);
@@ -4211,7 +4211,7 @@ var require_fast_uri = __commonJS({
     }
     var fastUri = {
       SCHEMES,
-      normalize,
+      normalize: normalize2,
       resolve: resolve4,
       resolveComponent,
       equal,
@@ -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_]/;
@@ -15540,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",
@@ -15575,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);
@@ -15697,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();
 }
@@ -15954,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;
@@ -16088,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;
@@ -16442,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;
@@ -16855,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")) {
@@ -16880,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);
@@ -17040,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";
@@ -17230,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();
@@ -17253,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);
@@ -17274,7 +17492,7 @@ 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")) {
@@ -17289,7 +17507,7 @@ function classify(lines) {
         }
         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";
@@ -17297,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;
@@ -17343,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);
@@ -17577,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,
@@ -17590,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.
@@ -17603,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,
@@ -17630,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;
@@ -17651,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) {
@@ -17804,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) {
@@ -17848,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);
+      }
     });
   }
 }
@@ -17862,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,
@@ -17898,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;
@@ -17935,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,
@@ -17956,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,
@@ -17965,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,
@@ -17997,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;
@@ -18025,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])),
@@ -18036,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 };
@@ -18127,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 };
 }
@@ -18146,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));
@@ -18157,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.`;
@@ -18175,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) {
@@ -18234,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;
     }
@@ -18509,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;
@@ -18926,9 +19285,12 @@ var PROBLEM_MD = "problem.md";
 var GIVEN = "given.proschi";
 var STARTER = "starter.proschi";
 var SOLUTION = "solution.proschi";
+var LESSON_MD = "lesson.md";
 var WRONG_DIR = "wrong";
 var REQUIRED = [PROBLEM_MD, GIVEN, STARTER, SOLUTION];
+var OPTIONAL = [LESSON_MD];
 var ID = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var RESERVED_IDS = ["problem", "roadmap", "approach"];
 var EXPECT_FAIL = /^#\s*expect-fail:\s*(.*?)\s*$/;
 var ProblemFolderError = class extends Error {
   folder;
@@ -18954,7 +19316,7 @@ function expectFailLines(source2) {
   }
   return names;
 }
-var FIELDS = ["title", "summary", "difficulty", "tags", "order", "hints"];
+var FIELDS = ["title", "summary", "difficulty", "tags", "company", "order", "hints", "version"];
 function readProblemMd(id, text) {
   const fail2 = (message, line) => {
     throw new ProblemFolderError(id, message, PROBLEM_MD, line);
@@ -18980,17 +19342,22 @@ function readProblemMd(id, text) {
   };
   const difficulty = str("difficulty");
   if (!DIFFICULTIES.includes(difficulty)) fail2(`'difficulty' must be one of ${DIFFICULTIES.join(", ")}`);
+  const company = data.company === void 0 ? void 0 : str("company");
   const order = data.order;
   if (order !== void 0 && typeof order !== "number") fail2("'order' must be a number");
+  const version = data.version;
+  if (version !== void 0 && !(typeof version === "number" && Number.isInteger(version) && version >= 1)) fail2("'version' must be a whole number from 1");
   if (body === "") fail2("The statement (the Markdown after the front matter) is empty");
   return {
     title: str("title"),
     summary: str("summary"),
     difficulty,
     tags: list("tags"),
+    ...company !== void 0 ? { company } : {},
     ...typeof order === "number" ? { order } : {},
     statement: body,
-    hints: list("hints")
+    hints: list("hints"),
+    ...typeof version === "number" ? { version } : {}
   };
 }
 function problemFromFiles(id, files) {
@@ -18998,11 +19365,12 @@ function problemFromFiles(id, files) {
     throw new ProblemFolderError(id, message);
   };
   if (!ID.test(id)) fail2('The folder name is the problem id and must be lowercase words joined by "-", e.g. url-shortener');
+  if (RESERVED_IDS.includes(id)) fail2(`"${id}" is taken by a practice page; reserved ids: ${RESERVED_IDS.join(", ")}`);
   for (const name of REQUIRED) if (files[name] === void 0) fail2(`Missing ${name}`);
   for (const name of Object.keys(files)) {
     const wrong2 = name.startsWith(`${WRONG_DIR}/`) ? name.slice(WRONG_DIR.length + 1) : void 0;
-    if (!REQUIRED.includes(name) && !(wrong2 && /^[a-z0-9][a-z0-9-]*\.proschi$/.test(wrong2))) {
-      fail2(`Unexpected file ${name}: a problem folder holds ${REQUIRED.join(", ")} and ${WRONG_DIR}/<name>.proschi (lowercase, digits and "-")`);
+    if (!REQUIRED.includes(name) && !OPTIONAL.includes(name) && !(wrong2 && /^[a-z0-9][a-z0-9-]*\.proschi$/.test(wrong2))) {
+      fail2(`Unexpected file ${name}: a problem folder holds ${REQUIRED.join(", ")}, optionally ${OPTIONAL.join(", ")}, and ${WRONG_DIR}/<name>.proschi (lowercase, digits and "-")`);
     }
   }
   const meta = readProblemMd(id, files[PROBLEM_MD]);
@@ -19013,10 +19381,63 @@ function problemFromFiles(id, files) {
     given: files[GIVEN],
     starter: files[STARTER],
     solution: files[SOLUTION],
+    ...files[LESSON_MD] !== void 0 ? { lesson: files[LESSON_MD] } : {},
     ...wrong.length ? { wrong } : {}
   };
 }
+// ../frontend/src/practice/lesson.ts
+var LESSON_HEADINGS = [
+  "What you'll learn",
+  "The problem, explained",
+  "Back-of-the-envelope",
+  "Concepts",
+  "Designing it step by step",
+  "Common mistakes",
+  "In the interview",
+  "Further reading"
+];
+var normalize = (heading) => heading.replace(/[‘’]/g, "'").trim();
+function proseLines(source2) {
+  const out = [];
+  let fence = false;
+  source2.replace(/\r\n?/g, "\n").split("\n").forEach((text, i) => {
+    if (/^\s*```/.test(text)) fence = !fence;
+    else if (!fence) out.push({ text, line: i + 1 });
+  });
+  return out;
+}
+function h2Headings(source2) {
+  return proseLines(source2).map(({ text, line }) => ({ m: /^##\s+(.*?)\s*#*\s*$/.exec(text), line })).filter((h) => h.m !== null).map(({ m, line }) => ({ text: m[1], line }));
+}
+function lessonIssues(source2) {
+  const issues = [];
+  if (!source2.trim()) return [{ message: "The lesson is empty" }];
+  const headings = h2Headings(source2);
+  let last = -1;
+  let lastName = "";
+  for (const required of LESSON_HEADINGS) {
+    const found = headings.find((h) => normalize(h.text) === required);
+    if (!found) {
+      issues.push({ message: `The lesson needs a "## ${required}" section (the sections are: ${LESSON_HEADINGS.join(", ")})` });
+      continue;
+    }
+    const index = headings.indexOf(found);
+    if (index < last) issues.push({ message: `"## ${required}" must come after "## ${lastName}"`, line: found.line });
+    else {
+      last = index;
+      lastName = required;
+    }
+  }
+  for (const { text, line } of proseLines(source2)) {
+    const prose = text.replace(/`[^`]*`/g, "");
+    for (const m of prose.matchAll(/\]\(([^)\s]*)[^)]*\)/g)) {
+      if (!/^https?:\/\/\S+$/i.test(m[1])) issues.push({ message: `Links in a lesson must go to an http(s) address, not "${m[1]}"`, line });
+    }
+  }
+  return issues;
+}
 // ../frontend/src/dsl/imports.ts
 function joinImportPath(fromPath, importPath) {
   const parts = importPath.startsWith("/") || !fromPath ? [] : fromPath.split("/").slice(0, -1);
@@ -19111,6 +19532,7 @@ function validateProblem(problem, engine = defaultEngine) {
     if (!problem.statement.includes(`**${name}**`)) add(PROBLEM_MD, `The statement must name the use case **${name}** in bold`);
     if (!problem.solution.includes(`usecase "${name}"`)) add(SOLUTION, `The solution must define usecase "${name}" from the traffic`);
   }
+  if (problem.lesson !== void 0) for (const issue of lessonIssues(problem.lesson)) add(LESSON_MD, issue.message, issue.line);
   const importLine = problem.given.split("\n").findIndex((l) => /^\s*import /.test(l));
   if (importLine >= 0) add(GIVEN, "The given must not import anything", importLine + 1);
   report(GIVEN, parse(problem.given).diagnostics.filter((d) => d.severity === "error"));
@@ -19486,7 +19908,7 @@ ${PROBLEM_USAGE}`);
 }
 // src/cli.ts
-var VERSION = true ? "0.6.0" : "dev";
+var VERSION2 = true ? "0.8.0" : "dev";
 var USAGE = `Usage:
   proschi check [--strict] [--format text|github|json] [--openapi <node>=<spec>]... <file|dir>...
   proschi parse <file>
@@ -19548,7 +19970,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") {