proschi 0.2.0 → 0.3.0

package/dist/cli.cjs

@@ -2796,11 +2796,11 @@ var require_validate = __commonJS({
         jsonPointer = $data;
         data = names_1.default.rootData;
       } else {
-        const matches = RELATIVE_JSON_POINTER.exec($data);
-        if (!matches)
+        const matches2 = RELATIVE_JSON_POINTER.exec($data);
+        if (!matches2)
           throw new Error(`Invalid JSON-pointer: ${$data}`);
-        const up = +matches[1];
-        jsonPointer = matches[2];
+        const up = +matches2[1];
+        jsonPointer = matches2[2];
         if (jsonPointer === "#") {
           if (up >= dataLevel)
             throw new Error(errorMsg("property/index", up));
@@ -3687,11 +3687,11 @@ var require_schemes = __commonJS({
         urnComponent.error = "URN can not be parsed";
         return urnComponent;
       }
-      const matches = urnComponent.path.match(URN_REG);
-      if (matches && matches[0] === urnComponent.path) {
+      const matches2 = urnComponent.path.match(URN_REG);
+      if (matches2 && matches2[0] === urnComponent.path) {
         const scheme = options.scheme || urnComponent.scheme || "urn";
-        urnComponent.nid = matches[1].toLowerCase();
-        urnComponent.nss = matches[2];
+        urnComponent.nid = matches2[1].toLowerCase();
+        urnComponent.nss = matches2[2];
         const urnScheme = `${scheme}:${options.nid || urnComponent.nid}`;
         const schemeHandler = getSchemeHandler(urnScheme);
         urnComponent.path = void 0;
@@ -4005,8 +4005,8 @@ var require_fast_uri = __commonJS({
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
     var AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
     var AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
-    function getParseError(parsed, matches) {
-      if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
+    function getParseError(parsed, matches2) {
+      if (matches2[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
         return 'URI path must start with "/" when authority is present.';
       }
       if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) {
@@ -4028,9 +4028,9 @@ var require_fast_uri = __commonJS({
     function isIPLiteral(host) {
       return host[0] === "[" && host[host.length - 1] === "]";
     }
-    function hasMalformedComponentPercentEncoding(matches) {
-      const host = matches[4];
-      return hasMalformedPercentEncoding(matches[3]) || host !== void 0 && !isIPLiteral(host) && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
+    function hasMalformedComponentPercentEncoding(matches2) {
+      const host = matches2[4];
+      return hasMalformedPercentEncoding(matches2[3]) || host !== void 0 && !isIPLiteral(host) && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches2[6]) || hasMalformedPercentEncoding(matches2[7]) || hasMalformedPercentEncoding(matches2[8]);
     }
     function canonicalizeHost(parsed, options, schemeHandler, isIP) {
       if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
@@ -4087,15 +4087,15 @@ var require_fast_uri = __commonJS({
           }
         }
       }
-      const matches = uri.match(URI_PARSE);
-      if (matches) {
-        parsed.scheme = matches[1];
-        parsed.userinfo = matches[3];
-        parsed.host = matches[4];
-        parsed.port = parseInt(matches[5], 10);
-        parsed.path = matches[6] || "";
-        parsed.query = matches[7];
-        parsed.fragment = matches[8];
+      const matches2 = uri.match(URI_PARSE);
+      if (matches2) {
+        parsed.scheme = matches2[1];
+        parsed.userinfo = matches2[3];
+        parsed.host = matches2[4];
+        parsed.port = parseInt(matches2[5], 10);
+        parsed.path = matches2[6] || "";
+        parsed.query = matches2[7];
+        parsed.fragment = matches2[8];
         if (parsed.scheme !== void 0) {
           const decodedScheme = unescape(parsed.scheme);
           if (VALID_SCHEME.test(decodedScheme)) {
@@ -4105,14 +4105,14 @@ var require_fast_uri = __commonJS({
             malformedScheme = true;
           }
         }
-        malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
+        malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches2);
         if (malformedPercentEncoding) {
           parsed.error = parsed.error || "URI contains malformed percent-encoding.";
         }
         if (isNaN(parsed.port)) {
-          parsed.port = matches[5];
+          parsed.port = matches2[5];
         }
-        const parseError = getParseError(parsed, matches);
+        const parseError = getParseError(parsed, matches2);
         if (parseError !== void 0) {
           parsed.error = parsed.error || parseError;
           malformedAuthorityOrPort = true;
@@ -4820,13 +4820,13 @@ var require_core = __commonJS({
       RULES.all[keyword] = rule;
       (_a = definition.implements) === null || _a === void 0 ? void 0 : _a.forEach((kwd) => this.addKeyword(kwd));
     }
-    function addBeforeRule(ruleGroup, rule, before) {
-      const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before);
+    function addBeforeRule(ruleGroup, rule, before2) {
+      const i = ruleGroup.rules.findIndex((_rule) => _rule.keyword === before2);
       if (i >= 0) {
         ruleGroup.rules.splice(i, 0, rule);
       } else {
         ruleGroup.rules.push(rule);
-        this.logger.warn(`rule ${before} is not defined`);
+        this.logger.warn(`rule ${before2} is not defined`);
       }
     }
     function keywordMetaschema(def) {
@@ -12353,11 +12353,11 @@ var require_compose_scalar = __commonJS({
 var require_util_empty_scalar_position = __commonJS({
   "node_modules/yaml/dist/compose/util-empty-scalar-position.js"(exports2) {
     "use strict";
-    function emptyScalarPosition(offset, before, pos) {
-      if (before) {
-        pos ?? (pos = before.length);
+    function emptyScalarPosition(offset, before2, pos) {
+      if (before2) {
+        pos ?? (pos = before2.length);
         for (let i = pos - 1; i >= 0; --i) {
-          let st = before[i];
+          let st = before2[i];
           switch (st.type) {
             case "space":
             case "comment":
@@ -12365,10 +12365,10 @@ var require_util_empty_scalar_position = __commonJS({
               offset -= st.source.length;
               continue;
           }
-          st = before[++i];
+          st = before2[++i];
           while (st?.type === "space") {
             offset += st.source.length;
-            st = before[++i];
+            st = before2[++i];
           }
           break;
         }
@@ -12446,10 +12446,10 @@ var require_compose_node = __commonJS({
         node.srcToken = token;
       return node;
     }
-    function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag, end }, onError) {
+    function composeEmptyNode(ctx, offset, before2, pos, { spaceBefore, comment, anchor, tag, end }, onError) {
       const token = {
         type: "scalar",
-        offset: utilEmptyScalarPosition.emptyScalarPosition(offset, before, pos),
+        offset: utilEmptyScalarPosition.emptyScalarPosition(offset, before2, pos),
         indent: -1,
         source: ""
       };
@@ -13464,9 +13464,9 @@ var require_lexer = __commonJS({
         }
       }
       *parseQuotedScalar() {
-        const quote = this.charAt(0);
-        let end = this.buffer.indexOf(quote, this.pos + 1);
-        if (quote === "'") {
+        const quote2 = this.charAt(0);
+        let end = this.buffer.indexOf(quote2, this.pos + 1);
+        if (quote2 === "'") {
           while (end !== -1 && this.buffer[end + 1] === "'")
             end = this.buffer.indexOf("'", end + 2);
         } else {
@@ -14934,8 +14934,8 @@ var OpenApiSpec = class {
     return requestBody && this.validateContent(requestBody.pointer, body);
   }
   validateResponse(op, key, body) {
-    const response = this.resolve(`${op.pointer}/responses/${esc(key)}`);
-    return response && this.validateContent(response.pointer, body);
+    const response2 = this.resolve(`${op.pointer}/responses/${esc(key)}`);
+    return response2 && this.validateContent(response2.pointer, body);
   }
   /** Validates against the `application/json` (or `+json`) schema of a request body or response object. */
   validateContent(pointer, body) {
@@ -15090,9 +15090,9 @@ function checkStep(spec, step, warn) {
   }
   if (step.failed) return;
   const label = `${op.method} ${op.path}`;
-  const request = jsonBody(step.requestFormat, step.requestBody);
-  if (request !== void 0) {
-    const errors = spec.validateRequest(op, request.value);
+  const request2 = jsonBody(step.requestFormat, step.requestBody);
+  if (request2 !== void 0) {
+    const errors = spec.validateRequest(op, request2.value);
     if (errors?.length) warn(`Request body does not match the schema of ${label}: ${summarize(errors)}`, step.loc);
   }
   if (step.statusCode === void 0) return;
@@ -15103,9 +15103,9 @@ function checkStep(spec, step, warn) {
     warn(`Status ${step.statusCode} is not documented for ${label} (documented: ${documented.join(", ") || "none"})`, responseLoc);
     return;
   }
-  const response = jsonBody(step.responseFormat, step.responseBody);
-  if (response !== void 0) {
-    const errors = spec.validateResponse(op, key, response.value);
+  const response2 = jsonBody(step.responseFormat, step.responseBody);
+  if (response2 !== void 0) {
+    const errors = spec.validateResponse(op, key, response2.value);
     if (errors?.length) warn(`${step.statusCode} response body does not match the schema of ${label}: ${summarize(errors)}`, responseLoc);
   }
 }
@@ -15180,11 +15180,14 @@ function openApiDiagnostics(file, diagram, overrides = {}) {
 }
 
 // src/render/usage.ts
-var RENDER_USAGE = `  proschi render [--out <dir>] [--format svg|md|html] <file>`;
+var RENDER_USAGE = `  proschi render [--out <dir>] [--format svg|md|html|hld-md|hld-html] <file>`;
 var RENDER_HELP = `render  Writes the diagram as static files into --out (default: the current
         directory). svg (default): architecture.svg and <usecase>--<scenario>.svg
         per scenario; md: <file>.md with Mermaid blocks; html: <file>.html with
-        the SVGs. Refuses (exit 1) when the document has errors.`;
+        the SVGs; hld-md / hld-html: <file>.hld.md / <file>.hld.html, the
+        high-level design document (overview, requirements, capacity,
+        components, data model, APIs, scenarios, decisions, risks).
+        Refuses (exit 1) when the document has errors.`;
 
 // src/fmt.ts
 var import_node_fs3 = require("node:fs");
@@ -15333,6 +15336,8 @@ var IDENT_START = /[A-Za-z_]/;
 var IDENT_PART = /[A-Za-z0-9_]/;
 var TEAM_PART = /[A-Za-z0-9_-]/;
 var DIGIT = /[0-9]/;
+var LETTER = /[A-Za-z]/;
+var SEPARATE_UNIT = /^[ \t]+(rps|rpm|rpd|ms|s|%|usd\/month)(?![A-Za-z0-9_/])/;
 function tokenizeLine(text, line) {
   const tokens = [];
   const diagnostics = [];
@@ -15386,8 +15391,16 @@ function tokenizeLine(text, line) {
       }
     }
     if (DIGIT.test(ch)) {
-      while (i < text.length && DIGIT.test(text[i])) i++;
-      tokens.push({ kind: "number", value: text.slice(start, i), col: start + 1, length: i - start });
+      i = readQuantity(text, i);
+      const value = text.slice(start, i).replace(/[ \t]+/g, "");
+      const kind = /^\d+$/.test(value) ? "number" : "quantity";
+      tokens.push({ kind, value, col: start + 1, length: i - start });
+      continue;
+    }
+    if (ch === "<" || ch === ">") {
+      const value = text[i + 1] === "=" ? ch + "=" : ch;
+      tokens.push({ kind: "op", value, col: start + 1, length: value.length });
+      i += value.length;
       continue;
     }
     if (ch === "@") {
@@ -15413,6 +15426,26 @@ function tokenizeLine(text, line) {
   }
   return { tokens, diagnostics };
 }
+function readQuantity(text, start) {
+  let i = start;
+  while (i < text.length && DIGIT.test(text[i])) i++;
+  if (text[i] === "." && DIGIT.test(text[i + 1] ?? "")) {
+    i++;
+    while (i < text.length && DIGIT.test(text[i])) i++;
+  }
+  const suffixStart = i;
+  if (text[i] === "%") return i + 1;
+  while (i < text.length && LETTER.test(text[i])) i++;
+  if (i > suffixStart && text[i] === "/" && LETTER.test(text[i + 1] ?? "")) {
+    i++;
+    while (i < text.length && LETTER.test(text[i])) i++;
+  }
+  if (/^[kmb]?$/.test(text.slice(suffixStart, i))) {
+    const unit = SEPARATE_UNIT.exec(text.slice(i));
+    if (unit) i += unit[0].length;
+  }
+  return i;
+}
 function readString(text, start) {
   let value = "";
   let i = start + 1;
@@ -15431,15 +15464,15 @@ function readString(text, start) {
 }
 function stripTrailingComment(text) {
   let depth = 0;
-  let quote = null;
+  let quote2 = null;
   for (let i = 0; i < text.length; i++) {
     const ch = text[i];
-    if (quote) {
+    if (quote2) {
       if (ch === "\\") i++;
-      else if (ch === quote) quote = null;
+      else if (ch === quote2) quote2 = null;
       continue;
     }
-    if (ch === '"') quote = ch;
+    if (ch === '"') quote2 = ch;
     else if (ch === "{" || ch === "[") depth++;
     else if (ch === "}" || ch === "]") depth = Math.max(0, depth - 1);
     else if (ch === "#" && depth === 0 && (i === 0 || /\s/.test(text[i - 1]))) return text.slice(0, i);
@@ -15495,11 +15528,92 @@ function endpointGroupKey(endpoint, all) {
   return method ? `${method} ${templatize(path)}` : templatize(path);
 }
 
+// ../frontend/src/dsl/kinds.ts
+var KINDS = ["client", "edge", "service", "function", "cache", "database", "search", "analytics", "queue", "storage", "external", "other"];
+var DATA_STORE_KINDS = ["cache", "database", "search", "analytics", "queue", "storage"];
+var BY_TECH = {
+  "AWS API Gateway": "edge",
+  "Azure API Management": "edge",
+  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_TYPE = {
+  shape: "client",
+  cdn: "edge",
+  service: "service",
+  compute: "service",
+  container: "service",
+  serverless: "function",
+  cache: "cache",
+  database: "database",
+  queue: "queue",
+  storage: "storage",
+  external: "external"
+};
+function kindOf(node) {
+  if (node.kind !== "component") return "other";
+  return BY_TECH[node.techStack] ?? BY_TYPE[node.type] ?? "other";
+}
+function isKind(word) {
+  return KINDS.includes(word);
+}
+function isDataStore(kind) {
+  return DATA_STORE_KINDS.includes(kind);
+}
+
+// ../frontend/src/dsl/quantity.ts
+function parseQuantity(text) {
+  const m = /^(\d+(?:\.\d+)?)(.*)$/.exec(text.replace(/\s+/g, ""));
+  if (!m) return { error: `'${text}' is not a number` };
+  const number = Number(m[1]);
+  const suffix = m[2];
+  const unit = UNITS.get(suffix);
+  if (suffix === "" || unit) return unit ? { value: round(number * unit.factor), unit: unit.unit } : { value: number };
+  const magnitude = MAGNITUDES.get(suffix[0]);
+  const rest = suffix.slice(1);
+  const after = UNITS.get(rest);
+  if (magnitude && (rest === "" || after)) {
+    return after ? { value: round(number * magnitude * after.factor), unit: after.unit } : { value: round(number * magnitude) };
+  }
+  return { error: `Unknown unit '${suffix}' in '${text}'; use rps, rpm, rpd, ms, s, % or usd/month (with k, m or b for thousands, millions, billions)` };
+}
+var round = (n) => Number(n.toPrecision(12));
+var MAGNITUDES = /* @__PURE__ */ new Map([
+  ["k", 1e3],
+  ["m", 1e6],
+  ["b", 1e9]
+]);
+var UNITS = /* @__PURE__ */ new Map([
+  ["rps", { unit: "rps", factor: 1 }],
+  ["rpm", { unit: "rps", factor: 1 / 60 }],
+  ["rpd", { unit: "rps", factor: 1 / 86400 }],
+  ["ms", { unit: "ms", factor: 1 }],
+  ["s", { unit: "ms", factor: 1e3 }],
+  ["%", { unit: "%", factor: 1 }],
+  ["usd/month", { unit: "usd/month", factor: 1 }]
+]);
+
 // ../frontend/src/dsl/parser.ts
 var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
 var DEFAULT_TECH = "Rectangle";
 var DEFAULT_GROUP_TECH = "Logical Group";
 var MAX_SCENARIOS = 32;
+var REPLICAS = /^x(\d+)$/;
+var PERCENTILES = { p50: 50, p90: 90, p95: 95, p99: 99, p999: 99.9 };
+var FIELD_FLAGS = ["key", "index", "unique", "optional"];
+var UNIT_EXAMPLES = {
+  rps: "a rate, e.g. 100k rps, 6k rpm or 1m rpd",
+  ms: "a duration, e.g. 50ms or 1.5s",
+  "%": "a percentage, e.g. 99.9%",
+  "usd/month": "a monthly cost, e.g. 400 usd/month"
+};
+var ASSERTION_HELP = 'Expected an assertion: "Use case" calls <node>, "Use case" writes <node> before responding, no path from <node> to <node>, <node> has replicas >= 2, \u2026';
+var ASSERTION_VERBS = "calls, every scenario calls, never calls, writes, responds, has scenario or handles failure of";
 var techByName = new Map(
   componentCatalog.map((c) => [c.techStack.toLowerCase(), { type: c.type, techStack: c.techStack }])
 );
@@ -15527,6 +15641,16 @@ var Parser = class {
   /** `a|b` for every connection, both directions; filled before use cases are built. */
   connected = /* @__PURE__ */ new Set();
   title;
+  summary;
+  traffic = [];
+  requirements = [];
+  capacity = [];
+  entities = [];
+  decisions = [];
+  tests = [];
+  /** Checks of use case, scenario and node names, run once every file is read and use cases are built. */
+  deferred = [];
+  built = [];
   options;
   constructor(source2, options) {
     this.options = options;
@@ -15541,11 +15665,21 @@ var Parser = class {
     const useCases = this.useCases.map(({ useCase, body }) => this.buildUseCase(useCase, body));
     const endpoints = useCases.flatMap((u) => u.endpoint ? [u.endpoint] : []);
     for (const u of useCases) if (u.endpoint) u.endpointGroup = endpointGroupKey(u.endpoint, endpoints);
+    this.built = useCases;
+    for (const check of this.deferred) check();
     const diagram = {
       title: this.title,
       nodes: [...this.nodes.values()],
       edges: this.edges,
-      useCases
+      useCases,
+      // The HLD sections are left out when a document has none, so older documents parse exactly as before.
+      ...this.summary !== void 0 ? { summary: this.summary } : {},
+      ...this.traffic.length ? { traffic: this.traffic } : {},
+      ...this.requirements.length ? { requirements: this.requirements } : {},
+      ...this.capacity.length ? { capacity: this.capacity } : {},
+      ...this.entities.length ? { entities: this.entities } : {},
+      ...this.decisions.length ? { decisions: this.decisions } : {},
+      ...this.tests.length ? { tests: this.tests } : {}
     };
     const order = (d) => this.fileOrder.get(d.file) ?? 0;
     this.diagnostics.sort((a, b) => order(a) - order(b) || a.line - b.line || a.col - b.col);
@@ -15557,7 +15691,7 @@ var Parser = class {
       i = this.parseLine(i);
     }
     for (const frame of this.stack) {
-      const what = frame.kind === "group" ? `group '${frame.id}'` : frame.kind === "usecase" ? `usecase '${frame.useCase.name}'` : frame.kind === "alt" ? `alt '${frame.name}'` : "par block";
+      const what = frame.kind === "group" ? `group '${frame.id}'` : frame.kind === "usecase" ? `usecase '${frame.useCase.name}'` : frame.kind === "alt" ? `alt '${frame.name}'` : frame.kind === "par" ? "par block" : sectionName(frame);
       this.error(`Missing } to close ${what}`, frame.loc);
     }
   }
@@ -15567,8 +15701,19 @@ var Parser = class {
     const { tokens, diagnostics } = tokenizeLine(this.lines[index], line);
     this.diagnostics.push(...diagnostics.map((d) => ({ ...d, ...this.fileField() })));
     if (tokens.length === 0 || diagnostics.some((d) => d.severity === "error")) return index;
-    const [first, second] = tokens;
+    const [first, second, third] = tokens;
     const loc = (t) => this.locOf(t, line);
+    const top = this.top();
+    if (top?.kind === "section") {
+      if (first.kind === "rbrace") {
+        this.stack.pop();
+        if (!top.discard) this.closeSection(top);
+        if (second) this.error("Unexpected input after }", loc(second));
+      } else if (!top.discard) {
+        this.parseSectionLine(top, tokens, line);
+      }
+      return index;
+    }
     if (first.kind === "rbrace") {
       if (this.stack.length === 0) this.error("Unmatched }", loc(first));
       else this.closeFrame();
@@ -15602,6 +15747,26 @@ var Parser = class {
       case "import":
         this.parseImport(tokens, line);
         break;
+      // These words are keywords only in the shape of their statement, so older documents may still use them as ids.
+      case "traffic":
+      case "requirements":
+      case "capacity":
+        if (second?.kind === "lbrace") this.openSection(first.value, tokens, line);
+        else this.parseNode(tokens, line);
+        break;
+      case "entity":
+        if (second?.kind === "ident" && second.value !== "pos" && !REPLICAS.test(second.value)) this.parseEntity(tokens, line);
+        else this.parseNode(tokens, line);
+        break;
+      case "decision":
+        if (second?.kind === "string" && (third?.kind === "lbrace" || third?.kind === "ident" && third.value !== "pos" && !REPLICAS.test(third.value)))
+          this.parseDecision(tokens, line);
+        else this.parseNode(tokens, line);
+        break;
+      case "test":
+        if (second?.kind === "string" && tokens[tokens.length - 1].kind === "lbrace") this.parseTest(tokens, line);
+        else this.parseNode(tokens, line);
+        break;
       default:
         this.parseNode(tokens, line);
     }
@@ -15613,8 +15778,12 @@ var Parser = class {
       this.error('Expected a title, e.g. title "My System"', this.locOf(tokens[0], line));
       return;
     }
-    if (this.file === void 0) this.title = value.value;
-    this.expectEnd(tokens, 2, line);
+    const summary = tokens[2]?.kind === "string" ? tokens[2] : void 0;
+    if (this.file === void 0) {
+      this.title = value.value;
+      if (summary) this.summary = summary.value;
+    }
+    this.expectEnd(tokens, summary ? 3 : 2, line);
   }
   parseImport(tokens, line) {
     const keyword = tokens[0];
@@ -15823,6 +15992,13 @@ var Parser = class {
         }
         node.position = { x: Number(x.value), y: Number(y.value) };
         i += 3;
+      } else if (t.kind === "ident" && REPLICAS.test(t.value)) {
+        const replicas = Number(REPLICAS.exec(t.value)[1]);
+        if (replicas < 1) {
+          this.error("A node needs at least one replica: x1, x2, \u2026", this.locOf(t, line));
+          return;
+        }
+        node.replicas = replicas;
       } else if (t.kind === "label" || t.kind === "arrow") {
         this.error(`Expected '${idToken.value} -> target' for a connection`, this.locOf(t, line));
         return;
@@ -15878,6 +16054,592 @@ var Parser = class {
     }
     return lastLine;
   }
+  // ---- HLD sections: traffic, requirements, capacity, entity, decision, test (docs/design/hld-and-practice.md §1) ----
+  /**
+   * Starts a section block. Sections are top level only; a misplaced one, or
+   * one whose header is broken, still opens a block so that its lines and its
+   * `}` are not mistaken for nodes and the end of an enclosing block.
+   */
+  openSection(section, tokens, line, fill = {}) {
+    const keyword = tokens[0];
+    const loc = this.locOf(keyword, line);
+    if (this.stack.length > 0) {
+      this.error(`${section} is only allowed at the top level`, loc);
+      this.skipSection(section, tokens, line);
+      return false;
+    }
+    if (section === "traffic" || section === "requirements" || section === "capacity") this.expectEnd(tokens, 2, line);
+    this.stack.push({ kind: "section", section, ...fill, loc });
+    return true;
+  }
+  /** After an error in a section header: skips the block, if the line opens one. */
+  skipSection(section, tokens, line) {
+    if (tokens[tokens.length - 1].kind === "lbrace") this.stack.push({ kind: "section", section, discard: true, loc: this.locOf(tokens[0], line) });
+  }
+  closeSection(frame) {
+    if (frame.test && frame.test.assertions.length === 0) this.warning(`Test '${frame.test.name}' has no assertions`, frame.test.loc);
+  }
+  parseSectionLine(frame, tokens, line) {
+    switch (frame.section) {
+      case "traffic":
+        return this.parseTrafficLine(tokens, line);
+      case "requirements":
+        return this.parseRequirement(tokens, line);
+      case "capacity":
+        return this.parseCapacityLine(tokens, line);
+      case "entity":
+        return this.parseField(frame.entity, tokens, line);
+      case "decision":
+        return this.parseDecisionLine(frame.decision, tokens, line);
+      case "test": {
+        const assertion2 = this.parseAssertion(tokens, line);
+        if (assertion2) frame.test.assertions.push(assertion2);
+        return;
+      }
+    }
+  }
+  /** `"Redirect" 100k rps mix "Cache hit" 90%, "Cache miss" 10%` */
+  parseTrafficLine(tokens, line) {
+    const [name, rate] = tokens;
+    if (name.kind !== "string") {
+      this.error('Expected a use case name in quotes and a rate, e.g. "Redirect" 100k rps', this.locOf(name, line));
+      return;
+    }
+    const rps = this.quantityOf(rate, "rps", name, line);
+    if (rps === void 0) return;
+    const entry = { useCase: name.value, rps, loc: this.lineLoc(tokens, line) };
+    const shares = [];
+    let i = 2;
+    if (tokens[i]) {
+      const mix = tokens[i++];
+      if (!isWord(mix, "mix")) {
+        this.error(`Unexpected ${describe(mix)}; expected mix "Scenario" 90%, "Other" 10%`, this.locOf(mix, line));
+        return;
+      }
+      for (; ; ) {
+        const scenario = tokens[i];
+        if (scenario?.kind !== "string") {
+          this.error('Expected a scenario name in quotes and its share, e.g. "Cache hit" 90%', this.locOf(scenario ?? tokens[i - 1], line));
+          return;
+        }
+        const share = this.quantityOf(tokens[i + 1], "%", scenario, line);
+        if (share === void 0) return;
+        const loc = this.locOf(scenario, line);
+        if (shares.some((s) => s.scenario === scenario.value)) {
+          this.error(`Scenario '${scenario.value}' is in the mix twice`, loc);
+          return;
+        }
+        shares.push({ scenario: scenario.value, share, loc });
+        i += 2;
+        if (!tokens[i]) break;
+        if (tokens[i].kind !== "comma") {
+          this.error(`Expected , between mix shares, not ${describe(tokens[i])}`, this.locOf(tokens[i], line));
+          return;
+        }
+        i++;
+      }
+      const total = shares.reduce((sum, s) => sum + s.share, 0);
+      if (total <= 0) {
+        this.error("Mix shares must add up to more than 0%", this.locOf(mix, line));
+        return;
+      }
+      if (Math.abs(total - 100) > 1e-9) {
+        this.warning(`Mix shares add up to ${Number(total.toFixed(3))}%, not 100%; they are scaled to fit`, this.locOf(mix, line));
+      }
+      entry.mix = shares.map((s) => ({ scenario: s.scenario, share: s.share / total }));
+    }
+    const nameLoc = this.locOf(name, line);
+    const first = this.traffic.find((t) => t.useCase === entry.useCase);
+    if (first) {
+      this.error(`Duplicate traffic for '${entry.useCase}' (first ${this.where(first.loc, nameLoc)})`, nameLoc);
+      return;
+    }
+    this.traffic.push(entry);
+    this.deferred.push(() => {
+      const useCase = this.checkUseCase(entry.useCase, nameLoc);
+      if (useCase) for (const s of shares) this.checkScenario(useCase, s.scenario, s.loc);
+    });
+  }
+  /** One line of `requirements { … }`. */
+  parseRequirement(tokens, line) {
+    const [first] = tokens;
+    const loc = this.lineLoc(tokens, line);
+    const help = 'Expected a requirement: p99 "Use case" < 50ms, availability >= 99.9%, durable "Use case", survive any node failure, cost <= 3000 usd/month';
+    if (first.kind !== "ident") {
+      this.error(help, this.locOf(first, line));
+      return;
+    }
+    const word = first.value;
+    let i = 1;
+    let useCase;
+    const readUseCase = () => {
+      if (tokens[i]?.kind !== "string") return;
+      useCase = { name: tokens[i].value, loc: this.locOf(tokens[i], line) };
+      i++;
+    };
+    const commit = (requirement2) => {
+      this.requirements.push(requirement2);
+      const named = useCase;
+      if (named) this.deferred.push(() => this.checkUseCase(named.name, named.loc));
+    };
+    const withUseCase = () => useCase ? { useCase: useCase.name } : {};
+    if (/^p\d+$/.test(word)) {
+      const percentile = PERCENTILES[word];
+      if (percentile === void 0) {
+        this.error(`Unknown percentile '${word}'; use p50, p90, p95, p99 or p999`, this.locOf(first, line));
+        return;
+      }
+      readUseCase();
+      if (!this.expectOp(tokens, i, ["<", "<="], `${word} "Use case" < 50ms`, line)) return;
+      const maxMs = this.quantityOf(tokens[i + 1], "ms", tokens[i], line);
+      if (maxMs === void 0 || !this.expectEnd(tokens, i + 2, line)) return;
+      commit({ kind: "latency", percentile, ...withUseCase(), maxMs, loc });
+      return;
+    }
+    switch (word) {
+      case "availability": {
+        readUseCase();
+        if (!this.expectOp(tokens, i, [">=", ">"], 'availability "Use case" >= 99.9%', line)) return;
+        const minPercent = this.quantityOf(tokens[i + 1], "%", tokens[i], line);
+        if (minPercent === void 0) return;
+        if (minPercent > 100) {
+          this.error("Availability cannot be more than 100%", this.locOf(tokens[i + 1], line));
+          return;
+        }
+        if (!this.expectEnd(tokens, i + 2, line)) return;
+        commit({ kind: "availability", ...withUseCase(), minPercent, loc });
+        return;
+      }
+      case "durable":
+        readUseCase();
+        if (!useCase) {
+          this.error('Expected a use case name in quotes, e.g. durable "Shorten"', this.locOf(tokens[1] ?? first, line));
+          return;
+        }
+        if (!this.expectEnd(tokens, i, line)) return;
+        commit({ kind: "durable", useCase: useCase.name, loc });
+        return;
+      case "survive": {
+        if (isWord(tokens[1], "any") && isWord(tokens[2], "node") && isWord(tokens[3], "failure")) {
+          if (this.expectEnd(tokens, 4, line)) commit({ kind: "survive", target: "any", loc });
+          return;
+        }
+        if (!isWord(tokens[1], "failure") || !isWord(tokens[2], "of")) {
+          this.error("Expected survive any node failure, or survive failure of <node | [Tech] | any kind>", this.locOf(tokens[1] ?? first, line));
+          return;
+        }
+        const target = this.parseSelector(tokens, 3, line);
+        if (!target || !this.expectEnd(tokens, target.next, line)) return;
+        commit({ kind: "survive", target: target.selector, loc });
+        this.checkSelectorLater(target);
+        return;
+      }
+      case "cost": {
+        if (!this.expectOp(tokens, 1, ["<=", "<"], "cost <= 3000 usd/month", line)) return;
+        const maxUsdPerMonth = this.quantityOf(tokens[2], "usd/month", tokens[1], line);
+        if (maxUsdPerMonth === void 0 || !this.expectEnd(tokens, 3, line)) return;
+        commit({ kind: "cost", maxUsdPerMonth, loc });
+        return;
+      }
+      default:
+        this.error(`Unknown requirement '${word}'. ${help}`, this.locOf(first, line));
+    }
+  }
+  /** `db 20k rps latency 4ms availability 99.95% cost 400 usd/month durable`, parts in any order. */
+  parseCapacityLine(tokens, line) {
+    const [id] = tokens;
+    if (id.kind !== "ident") {
+      this.error("Expected a node id and its overrides, e.g. db 20k rps latency 4ms", this.locOf(id, line));
+      return;
+    }
+    const override = { node: id.value, loc: this.lineLoc(tokens, line) };
+    const seen = /* @__PURE__ */ new Set();
+    for (let i = 1; i < tokens.length; ) {
+      const t = tokens[i];
+      let part;
+      if (t.kind === "quantity" || t.kind === "number") {
+        part = "rate";
+        const rps = this.quantityOf(t, "rps", t, line);
+        if (rps === void 0) return;
+        override.rps = rps;
+        i++;
+      } else if (isWord(t, "latency") || isWord(t, "availability") || isWord(t, "cost")) {
+        part = t.value;
+        const unit = part === "latency" ? "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 === "availability") override.availability = value;
+        else override.costUsd = value;
+        i += 2;
+      } else if (isWord(t, "durable") || isWord(t, "volatile")) {
+        part = "durable or volatile";
+        override.durable = t.value === "durable";
+        i++;
+      } else {
+        this.error(`Unexpected ${describe(t)}; expected a rate, latency, availability, cost, durable or volatile`, this.locOf(t, line));
+        return;
+      }
+      if (seen.has(part)) {
+        this.error(`${part[0].toUpperCase()}${part.slice(1)} is given twice for '${id.value}'`, this.locOf(t, line));
+        return;
+      }
+      seen.add(part);
+    }
+    const idLoc = this.locOf(id, line);
+    if (seen.size === 0) {
+      this.warning(`Capacity line for '${id.value}' overrides nothing; add a rate, latency, availability, cost, durable or volatile`, idLoc);
+      return;
+    }
+    const first = this.capacity.find((c) => c.node === id.value);
+    if (first) {
+      this.error(`Duplicate capacity for '${id.value}' (first ${this.where(first.loc, idLoc)})`, idLoc);
+      return;
+    }
+    this.capacity.push(override);
+    this.deferred.push(() => {
+      if (!this.nodes.has(id.value)) this.warning(`Unknown node '${id.value}' in capacity`, idLoc);
+    });
+  }
+  /** `entity Url [in db] ["description"] {` */
+  parseEntity(tokens, line) {
+    const name = tokens[1];
+    let i = 2;
+    let store;
+    if (isWord(tokens[i], "in")) {
+      const id = tokens[i + 1];
+      if (id?.kind !== "ident") {
+        this.error("Expected the id of the node that stores the entity after in, e.g. entity Url in db {", this.locOf(id ?? tokens[i], line));
+        this.skipSection("entity", tokens, line);
+        return;
+      }
+      store = { id: id.value, loc: this.locOf(id, line) };
+      i += 2;
+    }
+    const description = tokens[i]?.kind === "string" ? tokens[i++].value : void 0;
+    if (tokens[i]?.kind !== "lbrace") {
+      this.error('Expected { after the entity header, e.g. entity Url in db "Short codes" {', this.locOf(tokens[i] ?? tokens[i - 1], line));
+      this.skipSection("entity", tokens, line);
+      return;
+    }
+    this.expectEnd(tokens, i + 1, line);
+    const loc = this.locOf(name, line);
+    const entity = { name: name.value, ...store ? { store: store.id } : {}, ...description !== void 0 ? { description } : {}, fields: [], loc };
+    const first = this.entities.find((e) => e.name === entity.name);
+    if (first) {
+      this.error(`Duplicate entity '${entity.name}' (first ${this.where(first.loc, loc)})`, loc);
+      this.skipSection("entity", tokens, line);
+      return;
+    }
+    if (!this.openSection("entity", tokens, line, { entity })) return;
+    this.entities.push(entity);
+    if (store) {
+      const { id, loc: storeLoc } = store;
+      this.deferred.push(() => {
+        const node = this.nodes.get(id);
+        if (!node) this.warning(`Unknown node '${id}'`, storeLoc);
+        else if (!isDataStore(kindOf(node)))
+          this.warning(`'${id}' is not a data store (${DATA_STORE_KINDS.join(", ")}); entity '${entity.name}' is placed in a ${kindOf(node)}`, storeLoc);
+      });
+    }
+  }
+  /** `code string key`: a field name, a type and flags. */
+  parseField(entity, tokens, line) {
+    const [name, type] = tokens;
+    if (name.kind !== "ident") {
+      this.error("Expected a field: name type [key] [index] [unique] [optional], e.g. code string key", this.locOf(name, line));
+      return;
+    }
+    if (type?.kind !== "ident") {
+      this.error(`Expected a type after '${name.value}', e.g. ${name.value} string`, this.locOf(type ?? name, line));
+      return;
+    }
+    const flags = [];
+    for (const t of tokens.slice(2)) {
+      if (t.kind !== "ident" || !FIELD_FLAGS.includes(t.value)) {
+        this.error(`Unknown field flag ${describe(t)}; use key, index, unique or optional`, this.locOf(t, line));
+        return;
+      }
+      if (flags.includes(t.value)) {
+        this.error(`Flag '${t.value}' is given twice`, this.locOf(t, line));
+        return;
+      }
+      flags.push(t.value);
+    }
+    if (entity.fields.some((f) => f.name === name.value)) {
+      this.error(`Duplicate field '${name.value}' in entity '${entity.name}'`, this.locOf(name, line));
+      return;
+    }
+    entity.fields.push({ name: name.value, type: type.value, flags });
+  }
+  /** `decision "Title" because "Reason"`, or `decision "Title" {` with because / rejected lines. */
+  parseDecision(tokens, line) {
+    const title = tokens[1];
+    const decision = { title: title.value, rejected: [], loc: this.locOf(title, line) };
+    const third = tokens[2];
+    if (third.kind === "lbrace") {
+      this.expectEnd(tokens, 3, line);
+      if (this.openSection("decision", tokens, line, { decision })) this.decisions.push(decision);
+      return;
+    }
+    if (!isWord(third, "because")) {
+      this.error(`Expected because "reason" or { after the decision title, not ${describe(third)}`, this.locOf(third, line));
+      this.skipSection("decision", tokens, line);
+      return;
+    }
+    if (this.stack.length > 0) {
+      this.error("decision is only allowed at the top level", this.locOf(tokens[0], line));
+      return;
+    }
+    const reason = tokens[3];
+    if (reason?.kind !== "string") {
+      this.error("Expected the reason in quotes after because", this.locOf(reason ?? third, line));
+      return;
+    }
+    if (!this.expectEnd(tokens, 4, line)) return;
+    decision.because = reason.value;
+    this.decisions.push(decision);
+  }
+  parseDecisionLine(decision, tokens, line) {
+    const [word] = tokens;
+    if (isWord(word, "because")) {
+      if (tokens[1]?.kind !== "string") {
+        this.error("Expected the reason in quotes after because", this.locOf(tokens[1] ?? word, line));
+        return;
+      }
+      if (decision.because !== void 0) {
+        this.error('A decision has one because; list the other options with rejected "option" "reason"', this.locOf(word, line));
+        return;
+      }
+      if (this.expectEnd(tokens, 2, line)) decision.because = tokens[1].value;
+      return;
+    }
+    if (isWord(word, "rejected")) {
+      const [, option, reason] = tokens;
+      if (option?.kind !== "string" || reason?.kind !== "string") {
+        const bad = option?.kind !== "string" ? option : reason;
+        this.error('Expected rejected "option" "reason"', this.locOf(bad ?? tokens[tokens.length - 1], line));
+        return;
+      }
+      if (this.expectEnd(tokens, 3, line)) decision.rejected.push({ option: option.value, reason: reason.value });
+      return;
+    }
+    this.error('Expected because "reason" or rejected "option" "reason"', this.locOf(word, line));
+  }
+  /** `test "Name" {` */
+  parseTest(tokens, line) {
+    const name = tokens[1];
+    const loc = this.locOf(name, line);
+    if (tokens[2].kind !== "lbrace") {
+      this.error(`Expected { after the test name, not ${describe(tokens[2])}`, this.locOf(tokens[2], line));
+      this.skipSection("test", tokens, line);
+      return;
+    }
+    this.expectEnd(tokens, 3, line);
+    const first = this.tests.find((t) => t.name === name.value);
+    if (first) {
+      this.error(`Duplicate test '${name.value}' (first ${this.where(first.loc, loc)})`, loc);
+      this.skipSection("test", tokens, line);
+      return;
+    }
+    const test = { name: name.value, assertions: [], loc };
+    if (this.openSection("test", tokens, line, { test })) this.tests.push(test);
+  }
+  /** One assertion line of a test (docs/design/hld-and-practice.md §1.9). */
+  parseAssertion(tokens, line) {
+    const loc = this.lineLoc(tokens, line);
+    const [first] = tokens;
+    const selectors = [];
+    const selector = (i2) => {
+      const s = this.parseSelector(tokens, i2, line);
+      if (s) selectors.push(s);
+      return s;
+    };
+    const done = (assertion3, end) => {
+      if (!this.expectEnd(tokens, end, line)) return void 0;
+      selectors.forEach((s) => this.checkSelectorLater(s));
+      return assertion3;
+    };
+    const expectWords = (i2, words, example) => {
+      for (const [k, w] of words.entries()) {
+        if (!isWord(tokens[i2 + k], w)) {
+          this.error(`Expected '${w}' here, e.g. ${example}`, this.locOf(tokens[i2 + k] ?? tokens[tokens.length - 1], line));
+          return false;
+        }
+      }
+      return true;
+    };
+    if (isWord(first, "no") && isWord(tokens[1], "path")) {
+      const example = "no path from client to any database";
+      if (!expectWords(2, ["from"], example)) return;
+      const from = selector(3);
+      if (!from || !expectWords(from.next, ["to"], example)) return;
+      const to = selector(from.next + 1);
+      if (!to) return;
+      return done({ kind: "noPath", from: from.selector, to: to.selector, loc }, to.next);
+    }
+    if (first.kind !== "string") {
+      if (first.kind !== "ident" && first.kind !== "tech") {
+        this.error(ASSERTION_HELP, this.locOf(first, line));
+        return;
+      }
+      const target = selector(0);
+      if (!target) return;
+      if (!isWord(tokens[target.next], "has")) {
+        this.error(ASSERTION_HELP, this.locOf(tokens[target.next] ?? first, line));
+        return;
+      }
+      const i2 = target.next + 1;
+      const example = "api has replicas >= 2";
+      if (!expectWords(i2, ["replicas"], example) || !this.expectOp(tokens, i2 + 1, [">="], example, line)) return;
+      const n = tokens[i2 + 2];
+      if (n?.kind !== "number" || Number(n.value) < 1) {
+        this.error("Expected a whole number of replicas, at least 1", this.locOf(n ?? tokens[i2 + 1], line));
+        return;
+      }
+      return done({ kind: "replicas", target: target.selector, min: Number(n.value), loc }, i2 + 3);
+    }
+    const useCase = first.value;
+    const useCaseLoc = this.locOf(first, line);
+    let i = 1;
+    let scenario;
+    if (isWord(tokens[i], "scenario")) {
+      const s = tokens[i + 1];
+      if (s?.kind !== "string") {
+        this.error("Expected a scenario name in quotes after scenario", this.locOf(s ?? tokens[i], line));
+        return;
+      }
+      scenario = { name: s.value, loc: this.locOf(s, line) };
+      i += 2;
+    }
+    const withScenario = scenario ? { scenario: scenario.name } : {};
+    const verb = tokens[i];
+    const wholeUseCase = (what) => {
+      if (!scenario) return true;
+      this.error(`${what} is about the whole use case; leave out scenario "\u2026"`, scenario.loc);
+      return false;
+    };
+    let assertion2;
+    if (isWord(verb, "calls")) {
+      const target = selector(i + 1);
+      if (!target) return;
+      if (isWord(tokens[target.next], "before")) {
+        const then = selector(target.next + 1);
+        if (!then) return;
+        assertion2 = done({ kind: "before", useCase, ...withScenario, first: target.selector, then: then.selector, loc }, then.next);
+      } else {
+        assertion2 = done({ kind: "calls", useCase, ...withScenario, target: target.selector, quantifier: "some", loc }, target.next);
+      }
+    } else if (isWord(verb, "every")) {
+      if (!expectWords(i + 1, ["scenario", "calls"], `"${useCase}" every scenario calls any cache`)) return;
+      const target = selector(i + 3);
+      if (!target) return;
+      assertion2 = done({ kind: "calls", useCase, ...withScenario, target: target.selector, quantifier: "every", loc }, target.next);
+    } else if (isWord(verb, "never")) {
+      if (!expectWords(i + 1, ["calls"], `"${useCase}" never calls any database`)) return;
+      const target = selector(i + 2);
+      if (!target) return;
+      assertion2 = done({ kind: "calls", useCase, ...withScenario, target: target.selector, quantifier: "never", loc }, target.next);
+    } else if (isWord(verb, "writes")) {
+      const target = selector(i + 1);
+      if (!target || !expectWords(target.next, ["before", "responding"], `"${useCase}" writes db before responding`)) return;
+      assertion2 = done({ kind: "writesBeforeResponding", useCase, ...withScenario, target: target.selector, loc }, target.next + 2);
+    } else if (isWord(verb, "responds")) {
+      const status = tokens[i + 1];
+      if (!status || status.kind !== "number" && status.kind !== "quantity" || !/^[1-5](\d\d|xx)$/.test(status.value)) {
+        this.error("Expected a status code or class after responds, e.g. 201 or 4xx", this.locOf(status ?? verb, line));
+        return;
+      }
+      assertion2 = done({ kind: "responds", useCase, ...withScenario, status: status.value, loc }, i + 2);
+    } else if (isWord(verb, "has")) {
+      if (!wholeUseCase("has scenario") || !expectWords(i + 1, ["scenario"], `"${useCase}" has scenario "Not found"`)) return;
+      const name = tokens[i + 2];
+      if (name?.kind !== "string") {
+        this.error("Expected a scenario name in quotes after has scenario", this.locOf(name ?? tokens[i + 1], line));
+        return;
+      }
+      assertion2 = done({ kind: "hasScenario", useCase, scenario: name.value, loc }, i + 3);
+    } else if (isWord(verb, "handles")) {
+      if (!wholeUseCase("handles failure") || !expectWords(i + 1, ["failure", "of"], `"${useCase}" handles failure of cache`)) return;
+      const target = selector(i + 3);
+      if (!target) return;
+      assertion2 = done({ kind: "handlesFailure", useCase, target: target.selector, loc }, target.next);
+    } else {
+      this.error(`Expected ${ASSERTION_VERBS} after "${useCase}"`, this.locOf(verb ?? first, line));
+      return;
+    }
+    if (assertion2) {
+      this.deferred.push(() => {
+        const found = this.checkUseCase(useCase, useCaseLoc);
+        if (found && scenario) this.checkScenario(found, scenario.name, scenario.loc);
+      });
+    }
+    return assertion2;
+  }
+  /** A node id, `[Tech]` or `any <kind>` starting at `tokens[i]`. */
+  parseSelector(tokens, i, line) {
+    const t = tokens[i];
+    if (t?.kind === "tech") {
+      const tech = techByName.get(t.value.toLowerCase())?.techStack ?? t.value;
+      return { selector: { tech }, next: i + 1, token: t, loc: this.locOf(t, line) };
+    }
+    if (isWord(t, "any")) {
+      const kind = tokens[i + 1];
+      if (kind?.kind !== "ident" || !isKind(kind.value)) {
+        this.error(`Expected a kind after any: ${KINDS.join(", ")}`, this.locOf(kind ?? t, line));
+        return void 0;
+      }
+      return { selector: { kind: kind.value }, next: i + 2, token: t, loc: this.locOf(t, line) };
+    }
+    if (t?.kind === "ident") return { selector: { node: t.value }, next: i + 1, token: t, loc: this.locOf(t, line) };
+    this.error(`Expected a node id, [Tech] or any <kind>${t ? `, not ${describe(t)}` : ""}`, this.locOf(t ?? tokens[tokens.length - 1], line));
+    return void 0;
+  }
+  /** Warns about a selector naming a tech stack that does not exist, and (once every file is read) a node that does not. */
+  checkSelectorLater({ selector, token, loc }) {
+    if ("tech" in selector && !techByName.has(token.value.toLowerCase())) this.warning(`Unknown tech stack '${token.value}'`, loc);
+    if ("node" in selector) {
+      this.deferred.push(() => {
+        if (!this.nodes.has(selector.node)) this.warning(`Unknown node '${selector.node}'`, loc);
+      });
+    }
+  }
+  checkUseCase(name, loc) {
+    const useCase = this.built.find((u) => u.name === name);
+    if (!useCase) this.warning(`Unknown use case '${name}'`, loc);
+    return useCase;
+  }
+  checkScenario(useCase, name, loc) {
+    if (useCase.scenarios.some((s) => s.name === name)) return;
+    const names = useCase.scenarios.map((s) => `'${s.name}'`).join(", ");
+    this.warning(`Use case '${useCase.name}' has no scenario '${name}'; its scenarios are ${names}`, loc);
+  }
+  /** The value of a quantity token in `unit`, or undefined after reporting what is wrong. `after` locates a missing token. */
+  quantityOf(token, unit, after, line) {
+    const expected = UNIT_EXAMPLES[unit];
+    if (token?.kind !== "quantity" && token?.kind !== "number") {
+      this.error(`Expected ${expected}${token ? `, not ${describe(token)}` : ""}`, this.locOf(token ?? after, line));
+      return void 0;
+    }
+    const loc = this.locOf(token, line);
+    const written = this.lines[line - 1].slice(token.col - 1, token.col - 1 + token.length);
+    const q = parseQuantity(written);
+    if ("error" in q) {
+      this.error(q.error, loc);
+      return void 0;
+    }
+    if (q.unit !== unit) {
+      this.error(q.unit ? `Expected ${expected}, not '${written}'` : `'${written}' needs a unit: expected ${expected}`, loc);
+      return void 0;
+    }
+    return q.value;
+  }
+  expectOp(tokens, i, ops, example, line) {
+    const t = tokens[i];
+    if (t?.kind === "op" && ops.includes(t.value)) return true;
+    this.error(`Expected ${ops[0]} here, e.g. ${example}`, this.locOf(t ?? tokens[tokens.length - 1], line));
+    return false;
+  }
   buildUseCase(useCase, body) {
     let paths = expand(body.items);
     if (paths.length > MAX_SCENARIOS) {
@@ -15920,22 +16682,22 @@ var Parser = class {
     for (const step of raw) {
       this.checkConnection(step);
       if (step.arrow === "-->") {
-        const request = [...steps].reverse().find((s) => s.fromServiceId === step.to && s.toServiceId === step.from && !answered.has(s) && !s.failed);
-        if (!request) {
+        const request2 = [...steps].reverse().find((s) => s.fromServiceId === step.to && s.toServiceId === step.from && !answered.has(s) && !s.failed);
+        if (!request2) {
           this.warning(`Response has no matching request from '${step.to}' to '${step.from}'`, step.loc);
           continue;
         }
-        answered.add(request);
-        request.responseLoc = step.loc;
+        answered.add(request2);
+        request2.responseLoc = step.loc;
         const status = step.label.match(/^(\d{3})\b\s*([\s\S]*)$/);
-        if (status) request.statusCode = Number(status[1]);
+        if (status) request2.statusCode = Number(status[1]);
         const payload = splitPayload(status ? status[2] : step.label);
         const body = payload.body ?? payload.text;
         if (body) {
-          request.responseBody = body;
-          request.responseFormat = payload.body ? payload.format : "FREE_TEXT";
+          request2.responseBody = body;
+          request2.responseFormat = payload.body ? payload.format : "FREE_TEXT";
         }
-        if (request.executionType === "ASYNC_FIRE_AND_FORGET") request.executionType = "ASYNC_REQUEST_RESPONSE";
+        if (request2.executionType === "ASYNC_FIRE_AND_FORGET") request2.executionType = "ASYNC_REQUEST_RESPONSE";
         continue;
       }
       const label = parseStepLabel(step.label);
@@ -15982,13 +16744,15 @@ var Parser = class {
   addNode(node) {
     const existing = this.nodes.get(node.id);
     if (existing) {
-      const first = existing.loc.file;
-      const where = first === node.loc.file ? `on line ${existing.loc.line}` : `in ${fileName(first ?? this.options.path ?? "the root document")} on line ${existing.loc.line}`;
-      this.error(`Duplicate id '${node.id}' (first declared ${where})`, node.loc);
+      this.error(`Duplicate id '${node.id}' (first declared ${this.where(existing.loc, node.loc)})`, node.loc);
       return;
     }
     this.nodes.set(node.id, node);
   }
+  /** `on line 3`, or `in infra.proschi on line 3` when `first` is in another file than `later`. */
+  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}`;
+  }
   resolveTech(token, line) {
     const resolved = techByName.get(token.value.toLowerCase());
     if (resolved) return resolved;
@@ -16026,8 +16790,17 @@ var Parser = class {
   inUseCase() {
     return this.currentUseCase() !== void 0;
   }
+  /** Reports the first token from `from` on; true when there is none. */
   expectEnd(tokens, from, line) {
-    if (tokens.length > from) this.error(`Unexpected ${describe(tokens[from])}`, this.locOf(tokens[from], line));
+    if (tokens.length <= from) return true;
+    this.error(`Unexpected ${describe(tokens[from])}`, this.locOf(tokens[from], line));
+    return false;
+  }
+  /** From the first token of a line to the end of its last one. */
+  lineLoc(tokens, line) {
+    const first = tokens[0];
+    const last = tokens[tokens.length - 1];
+    return { line, col: first.col, length: last.col + last.length - first.col, ...this.fileField() };
   }
   locOf(token, line) {
     return token ? { line, col: token.col, length: token.length, ...this.fileField() } : { line, col: 1, length: 1, ...this.fileField() };
@@ -16069,6 +16842,15 @@ function expand(items) {
   }
   return paths;
 }
+function isWord(token, word) {
+  return token?.kind === "ident" && token.value === word;
+}
+function sectionName(frame) {
+  if (frame.entity) return `entity '${frame.entity.name}'`;
+  if (frame.decision) return `decision '${frame.decision.title}'`;
+  if (frame.test) return `test '${frame.test.name}'`;
+  return `${frame.section} block`;
+}
 function fileName(path) {
   return path.split(/[\\/]/).pop() || path;
 }
@@ -16154,8 +16936,9 @@ function format(source2) {
   };
   tidyBlankLines(entries).forEach((entry) => {
     const last = run2[run2.length - 1];
-    if (last && (entry.kind !== last.kind || entry.depth !== last.depth || last.kind === "connection" && last.continuation.length)) flush();
-    if (entry.kind === "node" || entry.kind === "connection") run2.push(entry);
+    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();
+    if (entry.kind === "node" || entry.kind === "connection" || entry.kind === "cells") run2.push(entry);
     else {
       flush();
       out.push(entry.kind === "blank" ? "" : indent(entry.depth) + entry.text);
@@ -16169,6 +16952,7 @@ var KEYWORDS = /* @__PURE__ */ new Set(["title", "import", "group", "usecase", "
 function classify(lines) {
   const entries = [];
   let depth = 0;
+  let section;
   for (let i = 0; i < lines.length; i++) {
     const raw = lines[i];
     const original = raw.trim();
@@ -16184,7 +16968,13 @@ function classify(lines) {
     const comment = commentOf(raw, tokens);
     const base = { depth, original, tokens, comment };
     const [first, second, third, fourth] = tokens;
-    if (first.kind === "ident" && second?.kind === "arrow" && third?.kind === "ident" && tokens.length <= 4 && (!fourth || fourth.kind === "label")) {
+    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 });
+      continue;
+    }
+    if (!inSection && first.kind === "ident" && second?.kind === "arrow" && third?.kind === "ident" && tokens.length <= 4 && (!fourth || fourth.kind === "label")) {
       const entry = { ...base, kind: "connection", from: first.value, arrow: second.value, to: third.value, label: fourth?.value, continuation: [] };
       if (fourth && bracketDepth(fourth.value) > 0) {
         const delta = depth * INDENT.length - width(leadingSpace(raw));
@@ -16199,11 +16989,12 @@ function classify(lines) {
       entries.push(entry);
       continue;
     }
-    if (first.kind === "ident" && !KEYWORDS.has(first.value) && tokens.slice(1).every((t) => ["string", "tech", "team", "ident", "number", "comma"].includes(t.kind))) {
+    const oneLineDecision = first.value === "decision" && second?.kind === "string" && third?.kind === "ident" && third.value === "because";
+    if (!inSection && first.kind === "ident" && !KEYWORDS.has(first.value) && !oneLineDecision && tokens.slice(1).every((t) => ["string", "tech", "team", "ident", "number", "comma"].includes(t.kind))) {
       let k = 1;
       const take = (kind) => tokens[k]?.kind === kind ? source(raw, tokens[k++]) : "";
-      const cells = [first.value, take("string"), take("tech"), take("team"), join2(raw, tokens.slice(k))];
-      entries.push({ ...base, kind: "node", cells });
+      const cells2 = [first.value, take("string"), take("tech"), take("team"), join2(raw, tokens.slice(k))];
+      entries.push({ ...base, kind: "node", cells: cells2 });
       continue;
     }
     const closes = first.kind === "rbrace";
@@ -16211,10 +17002,44 @@ function classify(lines) {
     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 });
+    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;
 }
+function sectionOpenedBy(tokens) {
+  const [first, second] = tokens;
+  if (first.kind !== "ident" || tokens[tokens.length - 1].kind !== "lbrace") return void 0;
+  switch (first.value) {
+    case "traffic":
+    case "requirements":
+    case "capacity":
+      return second?.kind === "lbrace" ? first.value : void 0;
+    case "entity":
+      return second?.kind === "ident" ? "entity" : void 0;
+    case "decision":
+    case "test":
+      return second?.kind === "string" ? first.value : void 0;
+    default:
+      return void 0;
+  }
+}
+function sectionCells(section, raw, tokens) {
+  const [first, second] = tokens;
+  if (tokens.some((t) => t.kind === "lbrace" || t.kind === "rbrace" || t.kind === "arrow" || t.kind === "label")) return void 0;
+  const rest = (from) => tokens.length > from ? [join2(raw, tokens.slice(from))] : [];
+  switch (section) {
+    case "traffic":
+      return first.kind === "string" && (second?.kind === "quantity" || second?.kind === "number") ? [source(raw, first), source(raw, second), ...rest(2)] : void 0;
+    case "capacity":
+      return first.kind === "ident" && tokens.length > 1 ? [first.value, ...rest(1)] : void 0;
+    case "entity":
+      return first.kind === "ident" && second?.kind === "ident" ? [first.value, second.value, ...rest(2)] : void 0;
+    default:
+      return void 0;
+  }
+}
 function tidyBlankLines(entries) {
   const kept = [];
   for (const entry of entries) {
@@ -16231,7 +17056,7 @@ function tidyBlankLines(entries) {
   return kept;
 }
 function renderRun(run2) {
-  const codes = run2[0].kind === "node" ? alignNodes(run2) : alignConnections(run2);
+  const codes = run2[0].kind === "node" ? alignNodes(run2) : run2[0].kind === "cells" ? alignCells(run2) : alignConnections(run2);
   const items = run2;
   const commented = items.filter((e) => e.comment);
   const commentCol = commented.length > 1 ? Math.max(...items.map((e, i) => e.comment ? len(codes[i]) : 0)) + 1 : 0;
@@ -16250,6 +17075,11 @@ function alignNodes(run2) {
     return (line + cells[4]).trimEnd();
   });
 }
+function alignCells(run2) {
+  const widths = [];
+  for (const { cells } of run2) cells.slice(0, -1).forEach((c, i) => widths[i] = Math.max(widths[i] ?? 0, len(c)));
+  return run2.map(({ cells }) => cells.map((c, i) => i < cells.length - 1 ? pad(c, widths[i] + 1) : c).join(""));
+}
 function alignConnections(run2) {
   const head = Math.max(...run2.map((e) => len(e.from) + 1 + e.arrow.length));
   const labelled = run2.filter((e) => e.label !== void 0);
@@ -16272,7 +17102,7 @@ function join2(raw, tokens) {
   let out = "";
   for (const [i, t] of tokens.entries()) {
     const text = t.kind === "label" ? ":" + (t.value ? " " + t.value : "") : source(raw, t);
-    const tight = t.kind === "comma" || tokens[i - 1]?.kind === "comma";
+    const tight = t.kind === "comma" || tokens[i - 1]?.kind === "comma" && t.kind === "number";
     out += (i === 0 || tight ? "" : " ") + text;
   }
   return out;
@@ -16286,7 +17116,10 @@ function reindent(line, delta) {
   const body = line.slice(lead.length).trimEnd();
   return body ? " ".repeat(Math.max(0, width(lead) + delta)) + body : "";
 }
-var source = (raw, t) => raw.slice(t.col - 1, t.col - 1 + t.length);
+var source = (raw, t) => {
+  const text = raw.slice(t.col - 1, t.col - 1 + t.length);
+  return t.kind === "quantity" ? text.replace(/[ \t]+/g, " ") : text;
+};
 var withComment = (code, comment) => comment ? code + " " + comment : code;
 var leadingSpace = (line) => /^[ \t]*/.exec(line)[0];
 var width = (space) => [...space].reduce((n, ch) => n + (ch === "	" ? INDENT.length : 1), 0);
@@ -16294,6 +17127,92 @@ var indent = (depth) => INDENT.repeat(depth);
 var len = (s) => [...s].length;
 var pad = (s, to) => s + " ".repeat(Math.max(0, to - len(s)));
 
+// ../frontend/src/dsl/sequence.ts
+var PAYLOAD_LIMIT = 40;
+function shorten(text, max = PAYLOAD_LIMIT) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1).trimEnd()}\u2026` : flat;
+}
+function requestLabel(step) {
+  const name = !step.httpMethod && step.stepName === `${step.fromServiceId} \u2192 ${step.toServiceId}` ? "" : step.stepName;
+  return [name, step.description, step.requestBody && shorten(step.requestBody)].filter(Boolean).join(" ");
+}
+function responseLabel(step) {
+  return [step.statusCode, step.responseBody && shorten(step.responseBody)].filter((p) => p !== void 0 && p !== "").join(" ");
+}
+function hasResponse(step) {
+  return !step.failed && (!!step.responseLoc || step.statusCode !== void 0 || !!step.responseBody);
+}
+function request(step) {
+  return {
+    kind: "request",
+    from: step.fromServiceId,
+    to: step.toServiceId,
+    number: step.stepOrder + 1,
+    label: requestLabel(step),
+    async: step.executionType !== "SYNC_REQUEST_RESPONSE",
+    failed: !!step.failed,
+    error: !!step.failed,
+    step
+  };
+}
+function response(step) {
+  return {
+    kind: "response",
+    from: step.toServiceId,
+    to: step.fromServiceId,
+    number: step.stepOrder + 1,
+    label: responseLabel(step),
+    async: false,
+    failed: false,
+    error: (step.statusCode ?? 0) >= 400,
+    status: step.statusCode,
+    step
+  };
+}
+function buildSequence(useCase, scenario, nodes = []) {
+  const items = [];
+  const stack = [];
+  const emit = (message) => items.push({ kind: "message", message });
+  const unwindFor = (from) => {
+    const depth = stack.map((s) => s.toServiceId).lastIndexOf(from);
+    while (stack.length > depth + 1) emit(response(stack.pop()));
+  };
+  const steps = scenario.steps;
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    if (step.parallelGroup === void 0) {
+      unwindFor(step.fromServiceId);
+      emit(request(step));
+      if (hasResponse(step)) stack.push(step);
+      continue;
+    }
+    const group = [];
+    while (i < steps.length && steps[i].parallelGroup === step.parallelGroup) group.push(steps[i++]);
+    i--;
+    unwindFor(step.fromServiceId);
+    items.push({ kind: "par", branches: group.map((s) => hasResponse(s) ? [request(s), response(s)] : [request(s)]) });
+  }
+  while (stack.length) emit(response(stack.pop()));
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const participants = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (id) => {
+    if (seen.has(id)) return;
+    seen.add(id);
+    const node = byId.get(id);
+    participants.push({ id, name: node?.name ?? id, tech: node && !node.implicit ? node.techStack : void 0 });
+  };
+  for (const step of steps) {
+    add(step.fromServiceId);
+    add(step.toServiceId);
+  }
+  return { useCase, scenario, participants, items, condition: scenario.condition || void 0 };
+}
+function sequenceMessages(items) {
+  return items.flatMap((item) => item.kind === "message" ? [item.message] : item.branches.flat());
+}
+
 // ../frontend/src/dsl/mermaid.ts
 var RESERVED = new Set(
   [
@@ -16343,6 +17262,695 @@ var RESERVED = new Set(
   ].map((w) => w.toLowerCase())
 );
 
+// ../frontend/src/sim/flow.ts
+function findUseCase(diagram, name) {
+  const lower = name.toLowerCase();
+  return diagram.useCases.find((u) => u.name === name) ?? diagram.useCases.find((u) => u.name.toLowerCase() === lower) ?? diagram.useCases.find((u) => u.id === name);
+}
+function findScenario2(useCase, name) {
+  const norm = (s) => s.replace(/\s*(›|>)\s*/g, " \u203A ").trim().toLowerCase();
+  const wanted = norm(name);
+  return useCase.scenarios.find((s) => s.name === name) ?? useCase.scenarios.find((s) => norm(s.name) === wanted || s.id === name);
+}
+function afterEntryResponse(entry, step) {
+  const r = entry.responseLoc;
+  if (!r || step === entry || step.loc.file !== r.file) return false;
+  return step.loc.line > r.line || step.loc.line === r.line && step.loc.col > r.col;
+}
+function criticalPath(useCase, scenario) {
+  const entry = scenario.steps[0];
+  if (!entry) return [];
+  const { items } = buildSequence(useCase, scenario);
+  const working = /* @__PURE__ */ new Map([[entry.fromServiceId, 1]]);
+  const opened = /* @__PURE__ */ new Set();
+  let answered = false;
+  const parts = [];
+  const visit = (m, hops) => {
+    if (m.kind === "response") {
+      if (opened.delete(m.step)) working.set(m.step.toServiceId, (working.get(m.step.toServiceId) ?? 1) - 1);
+      if (m.step === entry) answered = true;
+      return;
+    }
+    if (afterEntryResponse(entry, m.step)) answered = true;
+    if (answered || !working.get(m.from)) return;
+    hops.push({ step: m.step, target: m.to, failed: m.failed, async: m.async });
+    if (!m.async && !m.failed) {
+      opened.add(m.step);
+      working.set(m.to, (working.get(m.to) ?? 0) + 1);
+    }
+  };
+  for (const item of items) {
+    const hops = [];
+    if (item.kind === "message") visit(item.message, hops);
+    else for (const branch of item.branches) for (const m of branch) visit(m, hops);
+    if (hops.length) parts.push(hops);
+  }
+  return parts;
+}
+function pathNodes(useCase, scenario) {
+  const entry = scenario.steps[0];
+  if (!entry) return [];
+  const ids = [entry.fromServiceId, ...criticalPath(useCase, scenario).flatMap((part) => part.filter((h) => !h.failed).map((h) => h.target))];
+  return [...new Set(ids)];
+}
+function requestOrder(useCase, scenario) {
+  const entry = scenario.steps[0];
+  const messages = sequenceMessages(buildSequence(useCase, scenario).items);
+  const requests = [];
+  let beforeResponse = -1;
+  for (const m of messages) {
+    if (m.kind === "request") {
+      if (beforeResponse < 0 && entry && afterEntryResponse(entry, m.step)) beforeResponse = requests.length;
+      requests.push(m);
+    } else if (m.step === entry && beforeResponse < 0) beforeResponse = requests.length;
+  }
+  return { requests, beforeResponse: beforeResponse < 0 ? requests.length : beforeResponse };
+}
+function writesBeforeResponse(useCase, scenario, accept) {
+  const { requests, beforeResponse } = requestOrder(useCase, scenario);
+  return requests.slice(0, beforeResponse).some((m) => !m.async && !m.failed && accept(m.to));
+}
+function callsOk(scenario, nodeId) {
+  return scenario.steps.some((s) => s.toServiceId === nodeId && !s.failed);
+}
+function needs(useCase, nodeId) {
+  return useCase.scenarios.some((s) => s.outcome === "success" && callsOk(s, nodeId));
+}
+function fallbacksFor(useCase, nodeId) {
+  return useCase.scenarios.filter(
+    (s) => s.outcome === "success" && s.steps.some((step) => step.toServiceId === nodeId && step.failed) && !callsOk(s, nodeId)
+  );
+}
+function selectorText(selector) {
+  if ("node" in selector) return selector.node;
+  if ("tech" in selector) return `[${selector.tech}]`;
+  return `any ${selector.kind}`;
+}
+function selectNodes(diagram, selector) {
+  return diagram.nodes.filter((n) => n.kind === "component" && matches(n, selector));
+}
+function matches(node, selector) {
+  if (node.kind !== "component") return false;
+  if ("node" in selector) return node.id === selector.node;
+  if ("tech" in selector) return node.techStack.toLowerCase() === selector.tech.toLowerCase();
+  return kindOf(node) === selector.kind;
+}
+function techOf(node) {
+  return node && !node.implicit ? node.techStack : void 0;
+}
+function nodeLabel(diagram, id) {
+  const tech = techOf(diagram.nodes.find((n) => n.id === id));
+  return tech ? `${id} (${tech})` : id;
+}
+
+// ../frontend/src/sim/format.ts
+var trim = (n, digits) => String(Number(n.toFixed(digits)));
+function formatRps(rps) {
+  if (!Number.isFinite(rps)) return "\u221E rps";
+  if (rps >= 1e6) return `${trim(rps / 1e6, 1)}m rps`;
+  if (rps >= 1e3) return `${trim(rps / 1e3, 1)}k rps`;
+  return `${trim(rps, rps < 10 ? 2 : 0)} rps`;
+}
+function formatMs(ms) {
+  return `${trim(ms, ms < 100 ? 1 : 0)} ms`;
+}
+function formatAvailability(fraction) {
+  if (fraction >= 1) return "100%";
+  const down = (1 - fraction) * 100;
+  const digits = Math.min(6, Math.max(1, Math.ceil(-Math.log10(down)) + 1));
+  return `${trim(Math.floor(fraction * 100 * 10 ** digits + 1e-6) / 10 ** digits, digits)}%`;
+}
+function formatPercent(fraction) {
+  return `${Math.round(fraction * 100)}%`;
+}
+function formatUsd(usd) {
+  return `$${Math.round(usd).toLocaleString("en-US")}/month`;
+}
+
+// ../frontend/src/sim/profiles.ts
+var NEUTRAL = { rps: Infinity, latencyMs: 0, availability: 1, costUsd: 0, durable: false };
+var KIND_PROFILES = {
+  client: NEUTRAL,
+  edge: { rps: 1e5, latencyMs: 2, availability: 0.9999, costUsd: 50, durable: false },
+  service: { rps: 2e3, latencyMs: 10, availability: 0.995, costUsd: 100, durable: false },
+  function: { rps: 1e4, latencyMs: 25, availability: 0.9995, costUsd: 200, durable: false },
+  cache: { rps: 1e5, latencyMs: 1, availability: 0.999, costUsd: 150, durable: false },
+  database: { rps: 5e3, latencyMs: 5, availability: 0.9995, costUsd: 400, durable: true },
+  search: { rps: 3e3, latencyMs: 15, availability: 0.999, costUsd: 400, durable: true },
+  analytics: { rps: 200, latencyMs: 500, availability: 0.999, costUsd: 300, durable: true },
+  queue: { rps: 5e4, latencyMs: 5, availability: 0.9999, costUsd: 200, durable: true },
+  storage: { rps: 5e3, latencyMs: 30, availability: 0.9999, costUsd: 50, durable: true },
+  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 };
+var TECH_PROFILES = {
+  DynamoDB: NOSQL,
+  "AWS DynamoDB": NOSQL,
+  Cassandra: NOSQL,
+  MongoDB: NOSQL,
+  CouchDB: NOSQL,
+  "Azure Cosmos DB": NOSQL,
+  "GCP Bigtable": NOSQL,
+  "GCP Firestore": NOSQL,
+  "GCP Spanner": NOSQL
+};
+function profileOf(node, override) {
+  const kind = kindOf(node);
+  const base = TECH_PROFILES[node.techStack] ?? KIND_PROFILES[kind];
+  return {
+    kind,
+    rps: override?.rps ?? base.rps,
+    latencyMs: override?.latencyMs ?? base.latencyMs,
+    availability: override?.availability !== void 0 ? override.availability / 100 : base.availability,
+    costUsd: override?.costUsd ?? base.costUsd,
+    durable: override?.durable ?? base.durable
+  };
+}
+
+// ../frontend/src/sim/analyze.ts
+var DEFAULT_TIMEOUT_MS = 1e3;
+var HOT = 0.7;
+var QUEUE_CAP = 0.95;
+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) {
+  return diagram.nodes.filter((n) => n.kind === "component");
+}
+var replicasOf = (node) => Math.max(1, node.replicas ?? 1);
+function resolveTraffic(diagram, warnings = []) {
+  const result = /* @__PURE__ */ new Map();
+  for (const u of diagram.useCases) result.set(u.id, { rps: 0, shares: u.scenarios.map((_, i) => i === 0 ? 1 : 0) });
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of diagram.traffic ?? []) {
+    const useCase = findUseCase(diagram, entry.useCase);
+    if (!useCase) {
+      warnings.push(`Traffic for unknown use case "${entry.useCase}" is ignored`);
+      continue;
+    }
+    if (seen.has(useCase.id)) continue;
+    seen.add(useCase.id);
+    const shares = useCase.scenarios.map(() => 0);
+    for (const { scenario, share } of entry.mix ?? []) {
+      const found = findScenario2(useCase, scenario);
+      if (found) shares[useCase.scenarios.indexOf(found)] += share;
+      else warnings.push(`"${useCase.name}" has no scenario "${scenario}"; its traffic share is ignored`);
+    }
+    const total = shares.reduce((a, b) => a + b, 0);
+    if (total <= 0) shares[0] = 1;
+    else {
+      if (Math.abs(total - 1) > 1e-6) warnings.push(`Traffic mix of "${useCase.name}" adds up to ${formatPercent(total)}; shares are scaled to 100%`);
+      for (let i = 0; i < shares.length; i++) shares[i] /= total;
+    }
+    result.set(useCase.id, { rps: entry.rps, shares: useCase.scenarios.length ? shares : [] });
+  }
+  return result;
+}
+function computeLoad(diagram, traffic) {
+  const load = /* @__PURE__ */ new Map();
+  for (const u of diagram.useCases) {
+    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) load.set(step.toServiceId, (load.get(step.toServiceId) ?? 0) + rate);
+    });
+  }
+  return load;
+}
+var utilizationOf = (load, capacity) => Number.isFinite(capacity) && capacity > 0 ? load / capacity : 0;
+var hopLatency = (baseMs, utilization) => baseMs / (1 - Math.min(utilization, QUEUE_CAP));
+var replicatedAvailability = (a, replicas) => 1 - (1 - a) ** replicas;
+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 mainScenarioIndex(shares) {
+  let best = 0;
+  shares.forEach((share, i) => {
+    if (share > shares[best]) best = i;
+  });
+  return best;
+}
+function analyze(diagram, options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const warnings = [];
+  const nodes = components(diagram);
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const overrides = new Map((diagram.capacity ?? []).map((o) => [o.node, o]));
+  for (const o of diagram.capacity ?? []) if (!byId.has(o.node)) warnings.push(`Capacity for unknown node '${o.node}' is ignored`);
+  const profiles = new Map(nodes.map((n) => [n.id, profileOf(n, overrides.get(n.id))]));
+  const traffic = resolveTraffic(diagram, warnings);
+  const load = computeLoad(diagram, traffic);
+  const nodeResults = nodes.map((n) => {
+    const p = profiles.get(n.id);
+    const replicas = replicasOf(n);
+    const loadRps = load.get(n.id) ?? 0;
+    const capacityRps = p.rps * replicas;
+    const utilization = utilizationOf(loadRps, capacityRps);
+    return {
+      id: n.id,
+      kind: p.kind,
+      replicas,
+      loadRps,
+      capacityRps,
+      utilization,
+      saturated: utilization >= 1,
+      latencyMs: hopLatency(p.latencyMs, utilization),
+      availability: replicatedAvailability(p.availability, replicas),
+      costUsd: replicas * p.costUsd,
+      durable: p.durable
+    };
+  });
+  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;
+  for (const n of nodeResults) {
+    const usage = `${formatRps(n.loadRps)} of ${formatRps(n.capacityRps)}, ${formatPercent(n.utilization)}`;
+    if (n.saturated) warnings.push(`'${n.id}' is saturated: ${usage}. Add replicas or take load off it.`);
+    else if (n.utilization > HOT) warnings.push(`'${n.id}' runs hot: ${usage}.`);
+  }
+  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))),
+        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)])
+    );
+    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) };
+  });
+  return {
+    nodes: nodeResults,
+    useCases,
+    totalCostUsd: nodeResults.reduce((sum, n) => sum + n.costUsd, 0),
+    singlePointsOfFailure: singlePointsOfFailure(diagram),
+    warnings
+  };
+}
+function percentilesOf(meanMs) {
+  return Object.fromEntries(PERCENTILES2.map((q) => [PERCENTILE_KEYS[q], meanMs * PERCENTILE_FACTORS[q]]));
+}
+function useCaseAvailability(useCase, shares, availabilityOf) {
+  if (useCase.scenarios.length === 0) return 1;
+  const main = pathNodes(useCase, useCase.scenarios[mainScenarioIndex(shares)]);
+  const onMain = new Set(main);
+  let result = 1;
+  for (const id of main) {
+    const a = availabilityOf(id);
+    const fallback = Math.max(
+      0,
+      ...fallbacksFor(useCase, id).map(
+        (s) => pathNodes(useCase, s).filter((other) => other !== id && !onMain.has(other)).reduce((product, other) => product * availabilityOf(other), 1)
+      )
+    );
+    result *= 1 - (1 - a) * (1 - fallback);
+  }
+  return result;
+}
+var DEPLOYED = (kind) => kind !== "client" && kind !== "other" && kind !== "external";
+function singlePointsOfFailure(diagram) {
+  return components(diagram).filter((n) => replicasOf(n) === 1 && DEPLOYED(profileOf(n).kind)).filter((n) => diagram.useCases.some((u) => needs(u, n.id) && fallbacksFor(u, n.id).length === 0)).map((n) => n.id);
+}
+
+// ../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)) {
+  const run2 = {
+    diagram,
+    analysis,
+    nodes: new Map(analysis.nodes.map((n) => [n.id, n])),
+    useCases: new Map(analysis.useCases.map((u) => [u.id, u])),
+    shares: new Map([...resolveTraffic(diagram)].map(([id, t]) => [id, t.shares]))
+  };
+  const results = (diagram.requirements ?? []).map((r, i) => ({
+    id: `req:${i + 1}`,
+    name: requirementName(r),
+    category: CATEGORY[r.kind],
+    ...requirement(run2, r),
+    loc: r.loc
+  }));
+  const names = /* @__PURE__ */ new Map();
+  for (const test of diagram.tests ?? []) {
+    const n = (names.get(test.name) ?? 0) + 1;
+    names.set(test.name, n);
+    results.push({ id: n === 1 ? `test:${test.name}` : `test:${test.name}#${n}`, name: test.name, category: "flow", ...flowTest(run2, test), loc: test.loc });
+  }
+  return results.map(({ hint, ...r }) => r.passed || !hint ? r : { ...r, hint });
+}
+var CATEGORY = {
+  latency: "latency",
+  availability: "availability",
+  durable: "durability",
+  survive: "resilience",
+  cost: "cost"
+};
+var percentileName = (q) => PERCENTILE_KEYS[q];
+function requirementName(r) {
+  switch (r.kind) {
+    case "latency":
+      return `${percentileName(r.percentile)} of ${r.useCase ?? "every use case"} < ${formatMs(r.maxMs)}`;
+    case "availability":
+      return `availability of ${r.useCase ?? "every use case"} \u2265 ${r.minPercent}%`;
+    case "durable":
+      return `${r.useCase} is durable`;
+    case "survive":
+      return r.target === "any" ? "survive any node failure" : `survive failure of ${selectorText(r.target)}`;
+    case "cost":
+      return `cost \u2264 ${formatUsd(r.maxUsdPerMonth)}`;
+  }
+}
+function requirement(run2, r) {
+  switch (r.kind) {
+    case "latency":
+      return overUseCases(run2, r.useCase, (u) => latency(run2, u, r.percentile, r.maxMs), `(limit ${formatMs(r.maxMs)})`);
+    case "availability":
+      return overUseCases(run2, r.useCase, (u) => availability(run2, u, r.minPercent), `(limit ${r.minPercent}%)`, true);
+    case "durable":
+      return durable(run2, r.useCase);
+    case "survive":
+      return survive(run2, r.target);
+    case "cost":
+      return cost(run2, r.maxUsdPerMonth);
+  }
+}
+function overUseCases(run2, name, check, limit, anyWithoutTraffic = false) {
+  if (name !== void 0) {
+    const u = findUseCase(run2.diagram, name);
+    return u ? check(u) : unknownUseCase(run2, name);
+  }
+  let targets = run2.diagram.useCases.filter((u) => (run2.useCases.get(u.id)?.rps ?? 0) > 0);
+  if (targets.length === 0 && anyWithoutTraffic) targets = run2.diagram.useCases;
+  if (targets.length === 0) return fail("No use case has traffic, so there is nothing to measure", 'Add traffic { "<use case>" 1k rps } for the use cases this applies to');
+  const checks = targets.map(check);
+  const failed = checks.filter((c) => !c.passed);
+  if (failed.length === 0) {
+    return pass(checks.length === 1 ? checks[0].message : `All ${checks.length} use cases hold; ${checks.map((c) => c.value).join(", ")} ${limit}`);
+  }
+  return fail(failed.length === 1 ? failed[0].message : `${failed.map((c) => c.value ?? c.message).join("; ")} ${limit}`, failed[0].hint);
+}
+function unknownUseCase(run2, name) {
+  const known = run2.diagram.useCases.map((u) => `"${u.name}"`);
+  return fail(`No use case named "${name}"`, known.length ? `Use one of ${known.join(", ")}` : 'Add a usecase "\u2026" { \u2026 } block');
+}
+function latency(run2, u, q, maxMs) {
+  const result = run2.useCases.get(u.id);
+  const key = percentileName(q);
+  const shares = run2.shares.get(u.id) ?? [];
+  const touched = new Set(u.scenarios.flatMap((s, i) => (shares[i] ?? 0) > 0 ? s.steps.map((step) => step.toServiceId) : []));
+  const saturated = [...touched].map((id) => run2.nodes.get(id)).filter((n) => !!n?.saturated);
+  if (saturated.length) {
+    const n = saturated[0];
+    const usage = `${formatRps(n.loadRps)} of ${formatRps(n.capacityRps)}, ${formatPercent(n.utilization)}`;
+    const value2 = `${key} of ${u.name}: ${n.id} is saturated (${usage})`;
+    return { ...fail(`${value2} (limit ${formatMs(maxMs)})`, saturationHint(run2, n)), value: value2 };
+  }
+  const ms = result.percentiles[key];
+  const value = `${key} of ${u.name} is ${formatMs(ms)}${result.rps > 0 ? "" : " with no traffic"}`;
+  const message = `${value} (limit ${formatMs(maxMs)})`;
+  return ms < maxMs ? { ...pass(message), value } : { ...fail(message, latencyHint(run2, u, result, key, ms)), value };
+}
+function saturationHint(run2, n) {
+  const perReplica = n.capacityRps / n.replicas;
+  const replicas = Math.ceil(n.loadRps / (perReplica * HOT));
+  return `Add replicas to ${nodeLabel(run2.diagram, n.id)}: x${replicas} keeps it under ${formatPercent(HOT)}, or take load off it (a cache in front, or async work)`;
+}
+function latencyHint(run2, u, result, key, ms) {
+  const index = result.scenarios.findIndex((s) => s.percentiles[key] === ms);
+  const scenario = u.scenarios[Math.max(0, index)];
+  const lead = u.scenarios.length > 1 ? `The "${scenario.name}" path (${formatPercent(result.scenarios[Math.max(0, index)].share)} of traffic) sets ${key}. ` : "";
+  const hops = criticalPath(u, scenario).flat();
+  const cost2 = (h) => h.failed ? DEFAULT_TIMEOUT_MS : 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 `${lead}Shorten the synchronous path of the request.`;
+  const label = nodeLabel(run2.diagram, slowest.target);
+  if (slowest.failed) return `${lead}It waits ${formatMs(DEFAULT_TIMEOUT_MS)} for the failed call to ${label}; give that path a smaller share of traffic or avoid the call.`;
+  const node = run2.nodes.get(slowest.target);
+  if (node && node.utilization > HOT) return `${lead}${label} runs at ${formatPercent(node.utilization)} and queues requests; add replicas to it.`;
+  return `${lead}Its slowest hop is ${label} at ${formatMs(cost2(slowest))}: put a cache in front of it, run independent calls in par, or move work off the request path with ->>.`;
+}
+function availability(run2, u, minPercent) {
+  const result = run2.useCases.get(u.id);
+  const value = `availability of ${u.name} is ${formatAvailability(result.availability)}`;
+  const message = `${value} (limit ${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";
+  return { ...fail(message, hint), value };
+}
+function writeGap(u, s, accept) {
+  const { requests, beforeResponse } = requestOrder(u, s);
+  const writes = requests.map((m, i) => ({ m, i })).filter(({ m }) => !m.failed && accept(m.to));
+  if (writes.some(({ m, i }) => m.async && i < beforeResponse)) return "async";
+  if (writes.some(({ i }) => i >= beforeResponse)) return "after";
+  return "none";
+}
+var GAP_TEXT = {
+  async: "writes only asynchronously (->>)",
+  after: "writes only after responding",
+  none: "never writes"
+};
+function writesCheck(u, scenarios, accept, what) {
+  const success = scenarios.filter((s) => s.outcome === "success");
+  if (success.length === 0) return fail(`"${u.name}" has no success scenario to check`, "Add a scenario whose entry request is answered with a 2xx");
+  const gaps = success.map((s) => ({ s, ok: writesBeforeResponse(u, s, accept) })).filter((x) => !x.ok);
+  if (gaps.length === 0) {
+    const label = success.length === 1 ? `"${u.name}"` : `Every success scenario of "${u.name}"`;
+    return pass(`${label} writes ${what} before responding`);
+  }
+  const details = gaps.map(({ s }) => ({ s, gap: writeGap(u, s, accept) }));
+  const where = (s) => u.scenarios.length > 1 ? `"${s.name}"` : `"${u.name}"`;
+  const message = details.map(({ s, gap: gap2 }) => `${where(s)} ${GAP_TEXT[gap2]} ${what} before responding`).join("; ");
+  const gap = details[0].gap;
+  const hint = gap === "async" ? `Make the write a synchronous request (->) so it is acknowledged before the response` : gap === "after" ? `Move the write before the step that answers the entry request` : `Add a synchronous write (->) to ${what} before the entry request is answered`;
+  return fail(message, hint);
+}
+function durable(run2, name) {
+  const u = findUseCase(run2.diagram, name);
+  if (!u) return unknownUseCase(run2, name);
+  return writesCheck(u, u.scenarios, (id) => !!run2.nodes.get(id)?.durable, "to a durable store");
+}
+function survive(run2, target) {
+  const all = components(run2.diagram);
+  const selected = target === "any" ? all.filter((n) => DEPLOYED(run2.nodes.get(n.id).kind)) : selectNodes(run2.diagram, target);
+  const what = target === "any" ? "any one node" : selectorText(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 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 = n.capacityRps / replicas * (replicas - 1);
+      const rho = n.loadRps / left;
+      if (rho >= 1) {
+        failures.push(
+          fail(
+            `Losing one of ${replicas} ${node.id} replicas leaves ${formatRps(left)} for ${formatRps(n.loadRps)} (${formatPercent(rho)})`,
+            `Add a replica to ${label} (x${replicas + 1}) so the rest carry the load`
+          )
+        );
+      }
+      continue;
+    }
+    for (const u of run2.diagram.useCases) {
+      if (needs(u, node.id) && fallbacksFor(u, node.id).length === 0) {
+        failures.push(
+          fail(
+            `Losing ${label} breaks "${u.name}"`,
+            `Add a replica (x2 on ${node.id}) or a fallback scenario in "${u.name}" that calls ${node.id} with -x and still completes`
+          )
+        );
+      }
+    }
+  }
+  if (failures.length === 0) {
+    const count = selected.length === 1 ? selected[0].id : `any of ${selected.length} nodes`;
+    return pass(`Every use case keeps working after losing ${count}`);
+  }
+  const more = failures.length > 1 ? ` (and ${failures.length - 1} more)` : "";
+  return fail(`${failures[0].message}${more}`, failures[0].hint);
+}
+function cost(run2, max) {
+  const total = run2.analysis.totalCostUsd;
+  const message = `Total cost is ${formatUsd(total)} (limit ${formatUsd(max)})`;
+  if (total <= max) return pass(message);
+  const top = [...run2.analysis.nodes].filter((n) => n.costUsd > 0).sort((a, b) => b.costUsd - a.costUsd).slice(0, 3).map((n) => `${n.id} ${formatUsd(n.costUsd)}${n.replicas > 1 ? ` (${n.replicas} replicas)` : ""}`);
+  return fail(message, `Biggest items: ${top.join(", ")}. Drop replicas on nodes with low utilisation or pick cheaper techs.`);
+}
+function flowTest(run2, test) {
+  const assertions = test.assertions.map((a) => ({ ...assertion(run2, a), loc: a.loc }));
+  const failed = assertions.filter((a) => !a.passed);
+  if (assertions.length === 0) return { passed: true, message: "No assertions to check", assertions };
+  if (failed.length === 0) {
+    return { passed: true, message: assertions.length === 1 ? assertions[0].message : `All ${assertions.length} assertions hold`, assertions };
+  }
+  return { passed: false, message: failed.map((a) => a.message).join("; "), hint: failed[0].hint, assertions };
+}
+var quote = (s) => `"${s}"`;
+function scope(run2, useCase, scenario) {
+  const u = findUseCase(run2.diagram, useCase);
+  if (!u) return unknownUseCase(run2, useCase);
+  if (scenario === void 0) return { u, scenarios: u.scenarios, label: quote(u.name) };
+  const s = findScenario2(u, scenario);
+  if (!s) return missingScenario(u, scenario);
+  return { u, scenarios: [s], label: `${quote(u.name)} scenario ${quote(s.name)}` };
+}
+function missingScenario(u, scenario) {
+  const names = u.scenarios.map((s) => quote(s.name)).join(", ");
+  return fail(`${quote(u.name)} has no scenario ${quote(scenario)}${names ? `; it has ${names}` : ""}`, `Add alt "${scenario}" { \u2026 } to "${u.name}"`);
+}
+var isCheck = (x) => "passed" in x;
+function assertion(run2, a) {
+  switch (a.kind) {
+    case "calls":
+      return calls(run2, a);
+    case "before":
+      return before(run2, a);
+    case "writesBeforeResponding": {
+      const sc = scope(run2, a.useCase, a.scenario);
+      if (isCheck(sc)) return sc;
+      const ids = new Set(selectNodes(run2.diagram, a.target).map((n) => n.id));
+      if (ids.size === 0) return noMatch(a.target);
+      return writesCheck(sc.u, sc.scenarios, (id) => ids.has(id), selectorText(a.target));
+    }
+    case "responds":
+      return responds(run2, a);
+    case "hasScenario": {
+      const u = findUseCase(run2.diagram, a.useCase);
+      if (!u) return unknownUseCase(run2, a.useCase);
+      const s = findScenario2(u, a.scenario);
+      return s ? pass(`${quote(u.name)} has scenario ${quote(s.name)}`) : missingScenario(u, a.scenario);
+    }
+    case "handlesFailure": {
+      const u = findUseCase(run2.diagram, a.useCase);
+      if (!u) return unknownUseCase(run2, a.useCase);
+      const ids = new Set(selectNodes(run2.diagram, a.target).map((n) => n.id));
+      if (ids.size === 0) return noMatch(a.target);
+      const handled = u.scenarios.find((s) => s.outcome === "success" && s.steps.some((step) => step.failed && ids.has(step.toServiceId)));
+      const what = selectorText(a.target);
+      return handled ? pass(`${quote(u.name)} handles a failed call to ${what} in ${quote(handled.name)}`) : fail(
+        `No success scenario of ${quote(u.name)} has a failed call to ${what}`,
+        `Add alt "${what} down" { \u2026 -x ${[...ids][0]} \u2026 } that still answers the entry request with a 2xx`
+      );
+    }
+    case "noPath":
+      return noPath(run2, a.from, a.to);
+    case "replicas": {
+      const nodes = selectNodes(run2.diagram, a.target);
+      if (nodes.length === 0) return noMatch(a.target);
+      const short = nodes.filter((n) => replicasOf(n) < a.min);
+      const has = (n) => `${n.id} has ${replicasOf(n)} replica${replicasOf(n) === 1 ? "" : "s"}`;
+      if (short.length === 0) return pass(`${nodes.map(has).join(", ")} (minimum ${a.min})`);
+      return fail(`${short.map(has).join(", ")} (minimum ${a.min})`, `Declare ${short[0].id} with x${a.min}`);
+    }
+  }
+}
+function noMatch(selector) {
+  return fail(`No node matches ${selectorText(selector)}`, "Use a node id, [Tech] or any <kind> (any cache, any database, \u2026)");
+}
+function calls(run2, a) {
+  const sc = scope(run2, a.useCase, a.scenario);
+  if (isCheck(sc)) return sc;
+  const what = selectorText(a.target);
+  const ids = new Set(selectNodes(run2.diagram, a.target).map((n) => n.id));
+  const called = (s) => s.steps.filter((step) => ids.has(step.toServiceId)).map((step) => step.toServiceId);
+  const calling = sc.scenarios.filter((s) => called(s).length > 0);
+  const names = (list) => list.map((s) => quote(s.name)).join(", ");
+  const multi = sc.scenarios.length > 1;
+  if (a.quantifier === "never") {
+    if (calling.length === 0) return pass(`${sc.label} never calls ${what}`);
+    const first = calling[0];
+    return fail(
+      `${multi ? quote(first.name) : sc.label} calls ${nodeLabel(run2.diagram, called(first)[0])}`,
+      `Take the call to ${called(first)[0]} out of ${quote(first.name)}, e.g. serve it from a cache`
+    );
+  }
+  if (ids.size === 0) return noMatch(a.target);
+  if (a.quantifier === "some") {
+    if (calling.length) return pass(`${sc.label} calls ${what}${multi ? ` in ${names(calling)}` : ""}`);
+    return fail(`${sc.label} never calls ${what}`, `Add a step to ${what}`);
+  }
+  const missing = sc.scenarios.filter((s) => !calling.includes(s));
+  if (missing.length === 0 && sc.scenarios.length) return pass(`Every scenario of ${sc.label} calls ${what}`);
+  return fail(`${sc.label} does not call ${what} in ${names(missing) || "any scenario"}`, `Add a step to ${what} in ${names(missing) || "a scenario"}`);
+}
+function before(run2, a) {
+  const sc = scope(run2, a.useCase, a.scenario);
+  if (isCheck(sc)) return sc;
+  const first = new Set(selectNodes(run2.diagram, a.first).map((n) => n.id));
+  const then = new Set(selectNodes(run2.diagram, a.then).map((n) => n.id));
+  const [x, y] = [selectorText(a.first), selectorText(a.then)];
+  if (first.size === 0) return noMatch(a.first);
+  if (then.size === 0) return noMatch(a.then);
+  let checked = 0;
+  for (const s of sc.scenarios) {
+    const order = requestOrder(sc.u, s).requests.map((m) => m.to);
+    const iy = order.findIndex((id) => then.has(id));
+    if (iy < 0) continue;
+    checked++;
+    const ix = order.findIndex((id) => first.has(id));
+    if (ix < 0 || ix > iy) {
+      const where = sc.scenarios.length > 1 || a.scenario ? `In ${quote(s.name)}` : `In ${quote(sc.u.name)}`;
+      return fail(
+        ix < 0 ? `${where}, ${order[iy]} is called but ${x} never is` : `${where}, ${order[iy]} is called before ${order[ix]}`,
+        `Call ${x} before the first call to ${y}`
+      );
+    }
+  }
+  if (checked === 0) return fail(`${sc.label} never calls ${y}`, `Add a step to ${y} after the call to ${x}`);
+  return pass(`${sc.label} calls ${x} before ${y}${checked > 1 ? ` in all ${checked} scenarios that call ${y}` : ""}`);
+}
+function statusMatches(status, wanted) {
+  if (status === void 0) return false;
+  const cls = /^([1-5])xx$/i.exec(wanted);
+  return cls ? Math.floor(status / 100) === Number(cls[1]) : String(status) === wanted;
+}
+function responds(run2, a) {
+  const sc = scope(run2, a.useCase, a.scenario);
+  if (isCheck(sc)) return sc;
+  const hit = sc.scenarios.find((s) => statusMatches(s.steps[0]?.statusCode, a.status));
+  if (hit) return pass(`${sc.label} responds ${hit.steps[0].statusCode}${sc.scenarios.length > 1 ? ` in ${quote(hit.name)}` : ""}`);
+  const seen = [...new Set(sc.scenarios.map((s) => s.steps[0]?.failed ? "a failed call" : s.steps[0]?.statusCode ?? "no status"))];
+  return fail(`${sc.label} never responds ${a.status}; it answers ${seen.join(", ") || "nothing"}`, `Add a scenario (alt) whose entry request is answered with ${a.status}`);
+}
+function noPath(run2, from, to) {
+  const sources = new Set(selectNodes(run2.diagram, from).map((n) => n.id));
+  const targets = new Set(selectNodes(run2.diagram, to).map((n) => n.id));
+  const [x, y] = [selectorText(from), selectorText(to)];
+  const line = (loc) => `${loc.file ? `${loc.file}:` : "line "}${loc.line}`;
+  const hint = `Route it through a node that guards ${y} (a gateway or a service) instead of going there directly`;
+  const edge = run2.diagram.edges.find((e) => sources.has(e.source) && targets.has(e.target));
+  if (edge) return fail(`The connection ${edge.source} -> ${edge.target} (${line(edge.loc)}) goes directly from ${x} to ${y}`, hint);
+  for (const u of run2.diagram.useCases) {
+    for (const s of u.scenarios) {
+      const step = s.steps.find((st) => sources.has(st.fromServiceId) && targets.has(st.toServiceId));
+      if (step) {
+        const where = u.scenarios.length > 1 ? `${quote(u.name)} scenario ${quote(s.name)}` : quote(u.name);
+        return fail(`The step ${step.fromServiceId} -> ${step.toServiceId} in ${where} (${line(step.loc)}) goes directly from ${x} to ${y}`, hint);
+      }
+    }
+  }
+  return pass(`No connection or step goes directly from ${x} to ${y}`);
+}
+
 // src/fmt.ts
 var FMT_USAGE = `  proschi fmt [--check] <file|dir>...`;
 var FMT_HELP = `fmt     Rewrites files in the canonical layout and lists the ones it changed.
@@ -16387,6 +17995,161 @@ function displayPath2(file) {
 // src/imports.ts
 var import_node_fs4 = require("node:fs");
 var import_node_path5 = require("node:path");
+
+// src/simulation.ts
+var SIM_USAGE = `  proschi test [--format text|github|json] <file|dir>...
+  proschi analyze [--format text|json] <file>`;
+var SIM_HELP = `test    Runs the requirements and test blocks of each file (imports are
+        followed) against the simulation. Exits with 1 if any fails or a file
+        has errors.
+analyze Prints the capacity table: load, utilisation, latency, availability
+        and cost per node; latency percentiles per use case and scenario.`;
+function testFiles(files, load = parseFile) {
+  return files.map((file) => {
+    const { diagram, diagnostics } = load(file);
+    return { file: displayPath3(file), errors: diagnostics.filter((d) => d.severity === "error"), results: runTests(diagram) };
+  });
+}
+var escape2 = (s) => s.replace(/%/g, "%25").replace(/\r?\n/g, "%0A");
+function formatTestReports(reports, style) {
+  if (style === "json") return JSON.stringify(reports, null, 2);
+  const lines = [];
+  for (const { file, errors, results } of reports) {
+    const where = (loc) => ({ file: loc?.file ?? file, line: loc?.line ?? 1, col: loc?.col ?? 1 });
+    if (style === "github") {
+      for (const e of errors) lines.push(`::error file=${e.file ?? file},line=${e.line},col=${e.col},title=proschi::${escape2(e.message)}`);
+      for (const r of results.filter((r2) => !r2.passed)) {
+        const at = where(r.loc);
+        lines.push(`::error file=${at.file},line=${at.line},col=${at.col},title=proschi test: ${escape2(r.name)}::${escape2(r.hint ? `${r.message}. ${r.hint}` : r.message)}`);
+      }
+      continue;
+    }
+    lines.push(file);
+    for (const e of errors) lines.push(`  error ${e.file ? `${e.file}:` : ""}${e.line}:${e.col}: ${e.message}`);
+    if (results.length === 0) lines.push("  no requirements or tests");
+    for (const r of results) {
+      const at = r.loc ? ` (${r.loc.file ? `${r.loc.file}:` : "line "}${r.loc.line})` : "";
+      lines.push(`  ${r.passed ? "\u2713" : "\u2717"} ${r.name}${r.passed ? "" : at}: ${r.message}`);
+      if (!r.passed) {
+        for (const a of r.assertions ?? []) if (!a.passed && r.assertions.length > 1) lines.push(`      \u2717 line ${a.loc.line}: ${a.message}`);
+        if (r.hint) lines.push(`      \u2192 ${r.hint}`);
+      }
+    }
+  }
+  if (style === "text") {
+    const all = reports.flatMap((r) => r.results);
+    const failed = all.filter((r) => !r.passed).length;
+    const errors = reports.reduce((n, r) => n + r.errors.length, 0);
+    const files = reports.length === 1 ? "1 file" : `${reports.length} files`;
+    lines.push(`${files}: ${all.length - failed} passed, ${failed} failed${errors ? `, ${errors} error(s)` : ""}`);
+  }
+  return lines.join("\n");
+}
+function parseArgs(args, styles, err) {
+  let style = "text";
+  const paths = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--format") {
+      const value = args[++i];
+      if (!styles.includes(value)) {
+        err(`Unknown format '${value ?? ""}'; use ${styles.join(", ")}`);
+        return void 0;
+      }
+      style = value;
+    } else if (arg.startsWith("-")) {
+      err(`Unknown option ${arg}
+
+Usage:
+${SIM_USAGE}`);
+      return void 0;
+    } else paths.push(arg);
+  }
+  if (paths.length === 0) {
+    err(`Usage:
+${SIM_USAGE}`);
+    return void 0;
+  }
+  return { style, paths };
+}
+function runTest(args, collectFiles2, out, err, load = parseFile) {
+  const parsed = parseArgs(args, ["text", "github", "json"], err);
+  if (!parsed) return 2;
+  let reports;
+  try {
+    reports = testFiles(collectFiles2(parsed.paths), load);
+  } catch (e) {
+    err(String(e.message));
+    return 2;
+  }
+  const text = formatTestReports(reports, parsed.style);
+  if (text) out(text);
+  return reports.some((r) => r.errors.length > 0 || r.results.some((t) => !t.passed)) ? 1 : 0;
+}
+function runAnalyze(args, out, err, load = parseFile) {
+  const parsed = parseArgs(args, ["text", "json"], err);
+  if (!parsed) return 2;
+  if (parsed.paths.length !== 1) {
+    err(`Usage:
+${SIM_USAGE}`);
+    return 2;
+  }
+  const [file] = parsed.paths;
+  let result;
+  try {
+    result = load(file);
+  } catch (e) {
+    err(String(e.message));
+    return 2;
+  }
+  const analysis = analyze(result.diagram);
+  if (parsed.style === "json") out(JSON.stringify({ file: displayPath3(file), analysis }, null, 2));
+  else out(capacityReport(result.diagram, analysis, displayPath3(file)));
+  return result.diagnostics.some((d) => d.severity === "error") ? 1 : 0;
+}
+function table(rows, left = 1) {
+  const widths = rows[0].map((_, c) => Math.max(...rows.map((r) => r[c].length)));
+  return rows.map((r) => r.map((cell, c) => c < left ? cell.padEnd(widths[c]) : cell.padStart(widths[c])).join("  ").trimEnd());
+}
+function capacityReport(diagram, analysis, file) {
+  const lines = [diagram.title ? `${diagram.title} (${file})` : file, ""];
+  if ((diagram.traffic ?? []).length === 0) lines.push("No traffic { \u2026 } block: loads are zero and latencies are at idle.", "");
+  const nodes = analysis.nodes.filter((n) => n.kind !== "client" && n.kind !== "other");
+  lines.push(
+    ...table([
+      ["Node", "Kind", "Replicas", "Load", "Capacity", "Util", "Latency", "Availability", "Cost/month"],
+      ...nodes.map((n) => [
+        n.id,
+        n.kind,
+        String(n.replicas),
+        formatRps(n.loadRps),
+        formatRps(n.capacityRps),
+        `${formatPercent(n.utilization)}${n.saturated ? " SATURATED" : n.utilization > HOT ? " hot" : ""}`,
+        formatMs(n.latencyMs),
+        formatAvailability(n.availability),
+        formatUsd(n.costUsd).replace("/month", "")
+      ])
+    ], 2),
+    "",
+    `Total cost: ${formatUsd(analysis.totalCostUsd)}`,
+    ""
+  );
+  if (analysis.useCases.length) {
+    const rows = [["Use case", "Traffic", "p50", "p95", "p99", "p99.9", "Availability"]];
+    for (const u of analysis.useCases) {
+      rows.push([u.name, u.rps > 0 ? formatRps(u.rps) : "-", ...["p50", "p95", "p99", "p999"].map((p) => formatMs(u.percentiles[p])), formatAvailability(u.availability)]);
+      if (u.scenarios.length > 1) {
+        for (const s of u.scenarios) rows.push([`  ${s.name}`, formatPercent(s.share), formatMs(s.percentiles.p50), formatMs(s.percentiles.p95), formatMs(s.percentiles.p99), formatMs(s.percentiles.p999), ""]);
+      }
+    }
+    lines.push(...table(rows), "");
+  }
+  lines.push(`Single points of failure: ${analysis.singlePointsOfFailure.join(", ") || "none"}`);
+  if (analysis.warnings.length) lines.push("", "Warnings:", ...analysis.warnings.map((w) => `  ${w}`));
+  return lines.join("\n");
+}
+
+// src/imports.ts
 function displayPath3(file, cwd = process.cwd()) {
   const abs = (0, import_node_path5.resolve)(cwd, file);
   const rel = (0, import_node_path5.relative)(cwd, abs);
@@ -16422,12 +18185,13 @@ function checkFiles(files, extra) {
 }
 
 // src/cli.ts
-var VERSION = true ? "0.2.0" : "dev";
+var VERSION = true ? "0.3.0" : "dev";
 var USAGE = `Usage:
   proschi check [--strict] [--format text|github|json] [--openapi <node>=<spec>]... <file|dir>...
   proschi parse <file>
 ${RENDER_USAGE}
 ${FMT_USAGE}
+${SIM_USAGE}
   proschi --version
 
 check   Reports errors and warnings. Directories are searched for *.proschi files.
@@ -16439,7 +18203,8 @@ check   Reports errors and warnings. Directories are searched for *.proschi file
 parse   Prints {"diagram", "diagnostics"} as JSON; the shape is described by
         schema/proschi-diagram.schema.json.
 ${RENDER_HELP}
-${FMT_HELP}`;
+${FMT_HELP}
+${SIM_HELP}`;
 function collectFiles(paths) {
   const out = [];
   const walk = (dir) => {
@@ -16497,6 +18262,8 @@ function run(argv, out = console.log, err = console.error) {
   }
   if (command === "render") return import("./render.cjs").then((m) => m.renderCommand(rest, out, err, USAGE));
   if (command === "fmt") return runFmt(rest, collectFiles, out, err);
+  if (command === "test") return runTest(rest, collectFiles, out, err);
+  if (command === "analyze") return runAnalyze(rest, out, err);
   if (command === "check") {
     let strict = false;
     let style = "text";