proschi 0.2.0 → 0.3.0

package/dist/server.cjs

@@ -1218,15 +1218,15 @@ var require_sharedArrayCancellation = __commonJS({
       constructor() {
         this.buffers = /* @__PURE__ */ new Map();
       }
-      enableCancellation(request) {
-        if (request.id === null) {
+      enableCancellation(request2) {
+        if (request2.id === null) {
           return;
         }
         const buffer = new SharedArrayBuffer(4);
         const data = new Int32Array(buffer, 0, 1);
         data[0] = CancellationState.Continue;
-        this.buffers.set(request.id, buffer);
-        request.$cancellationData = buffer;
+        this.buffers.set(request2.id, buffer);
+        request2.$cancellationData = buffer;
       }
       async sendCancellation(_conn, id) {
         const buffer = this.buffers.get(id);
@@ -1268,8 +1268,8 @@ var require_sharedArrayCancellation = __commonJS({
     };
     var SharedArrayReceiverStrategy = class {
       kind = "request";
-      createCancellationTokenSource(request) {
-        const buffer = request.$cancellationData;
+      createCancellationTokenSource(request2) {
+        const buffer = request2.$cancellationData;
         if (buffer === void 0) {
           return new cancellation_1.CancellationTokenSource();
         }
@@ -2326,13 +2326,13 @@ var require_connection = __commonJS({
             const toCancel = messageQueue.get(key);
             if (messages_1.Message.isRequest(toCancel)) {
               const strategy = options?.connectionStrategy;
-              const response = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);
-              if (response && (response.error !== void 0 || response.result !== void 0)) {
+              const response2 = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);
+              if (response2 && (response2.error !== void 0 || response2.result !== void 0)) {
                 messageQueue.delete(key);
                 requestTokens.delete(cancelId);
-                response.id = toCancel.id;
-                traceSendingResponse(response, message.method, Date.now());
-                messageWriter.write(response).catch(() => logger.error(`Sending response for canceled message failed.`));
+                response2.id = toCancel.id;
+                traceSendingResponse(response2, message.method, Date.now());
+                messageWriter.write(response2).catch(() => logger.error(`Sending response for canceled message failed.`));
                 return;
               }
             }
@@ -9849,8 +9849,8 @@ var require_main3 = __commonJS({
         return args.map((arg) => typeof arg === "string" ? arg : (0, node_util_1.inspect)(arg)).join(" ");
       }
       const counters = /* @__PURE__ */ new Map();
-      console.assert = function assert(assertion, ...args) {
-        if (assertion) {
+      console.assert = function assert(assertion2, ...args) {
+        if (assertion2) {
           return;
         }
         if (args.length === 0) {
@@ -12666,11 +12666,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));
@@ -13557,11 +13557,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;
@@ -13875,8 +13875,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)) {
@@ -13898,9 +13898,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)) {
@@ -13957,15 +13957,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)) {
@@ -13975,14 +13975,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;
@@ -14690,13 +14690,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) {
@@ -22223,11 +22223,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":
@@ -22235,10 +22235,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;
         }
@@ -22316,10 +22316,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: ""
       };
@@ -23334,9 +23334,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 {
@@ -25048,8 +25048,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) {
@@ -25204,9 +25204,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;
@@ -25217,9 +25217,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);
   }
 }
@@ -25434,6 +25434,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 = [];
@@ -25487,8 +25489,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 === "@") {
@@ -25514,6 +25524,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;
@@ -25532,15 +25562,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);
@@ -25596,11 +25626,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 }])
 );
@@ -25628,6 +25739,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;
@@ -25642,11 +25763,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);
@@ -25658,7 +25789,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);
     }
   }
@@ -25668,8 +25799,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();
@@ -25703,6 +25845,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);
     }
@@ -25714,8 +25876,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];
@@ -25924,6 +26090,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;
@@ -25979,6 +26152,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) {
@@ -26021,22 +26780,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);
@@ -26083,13 +26842,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;
@@ -26127,8 +26888,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() };
@@ -26170,6 +26940,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;
 }
@@ -26279,8 +27058,9 @@ function format(source2) {
   };
   tidyBlankLines(entries).forEach((entry) => {
     const last = run[run.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") run.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") run.push(entry);
     else {
       flush();
       out.push(entry.kind === "blank" ? "" : indent(entry.depth) + entry.text);
@@ -26294,6 +27074,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();
@@ -26309,7 +27090,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));
@@ -26324,11 +27111,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";
@@ -26336,10 +27124,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) {
@@ -26356,7 +27178,7 @@ function tidyBlankLines(entries) {
   return kept;
 }
 function renderRun(run) {
-  const codes = run[0].kind === "node" ? alignNodes(run) : alignConnections(run);
+  const codes = run[0].kind === "node" ? alignNodes(run) : run[0].kind === "cells" ? alignCells(run) : alignConnections(run);
   const items = run;
   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;
@@ -26375,6 +27197,11 @@ function alignNodes(run) {
     return (line + cells[4]).trimEnd();
   });
 }
+function alignCells(run) {
+  const widths = [];
+  for (const { cells } of run) cells.slice(0, -1).forEach((c, i) => widths[i] = Math.max(widths[i] ?? 0, len(c)));
+  return run.map(({ cells }) => cells.map((c, i) => i < cells.length - 1 ? pad(c, widths[i] + 1) : c).join(""));
+}
 function alignConnections(run) {
   const head = Math.max(...run.map((e) => len(e.from) + 1 + e.arrow.length));
   const labelled = run.filter((e) => e.label !== void 0);
@@ -26397,7 +27224,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;
@@ -26411,7 +27238,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);
@@ -26419,6 +27249,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(
   [
@@ -26468,6 +27384,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 run = {
+    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(run, 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(run, 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(run, r) {
+  switch (r.kind) {
+    case "latency":
+      return overUseCases(run, r.useCase, (u) => latency(run, u, r.percentile, r.maxMs), `(limit ${formatMs(r.maxMs)})`);
+    case "availability":
+      return overUseCases(run, r.useCase, (u) => availability(run, u, r.minPercent), `(limit ${r.minPercent}%)`, true);
+    case "durable":
+      return durable(run, r.useCase);
+    case "survive":
+      return survive(run, r.target);
+    case "cost":
+      return cost(run, r.maxUsdPerMonth);
+  }
+}
+function overUseCases(run, name, check, limit, anyWithoutTraffic = false) {
+  if (name !== void 0) {
+    const u = findUseCase(run.diagram, name);
+    return u ? check(u) : unknownUseCase(run, name);
+  }
+  let targets = run.diagram.useCases.filter((u) => (run.useCases.get(u.id)?.rps ?? 0) > 0);
+  if (targets.length === 0 && anyWithoutTraffic) targets = run.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(run, name) {
+  const known = run.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(run, u, q, maxMs) {
+  const result = run.useCases.get(u.id);
+  const key = percentileName(q);
+  const shares = run.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) => run.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(run, 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(run, u, result, key, ms)), value };
+}
+function saturationHint(run, n) {
+  const perReplica = n.capacityRps / n.replicas;
+  const replicas = Math.ceil(n.loadRps / (perReplica * HOT));
+  return `Add replicas to ${nodeLabel(run.diagram, n.id)}: x${replicas} keeps it under ${formatPercent(HOT)}, or take load off it (a cache in front, or async work)`;
+}
+function latencyHint(run, 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 : run.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(run.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 = run.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(run, u, minPercent) {
+  const result = run.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 = run.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) => run.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(run.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(run, name) {
+  const u = findUseCase(run.diagram, name);
+  if (!u) return unknownUseCase(run, name);
+  return writesCheck(u, u.scenarios, (id) => !!run.nodes.get(id)?.durable, "to a durable store");
+}
+function survive(run, target) {
+  const all = components(run.diagram);
+  const selected = target === "any" ? all.filter((n) => DEPLOYED(run.nodes.get(n.id).kind)) : selectNodes(run.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 = run.nodes.get(node.id);
+    const label = nodeLabel(run.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 run.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(run, max) {
+  const total = run.analysis.totalCostUsd;
+  const message = `Total cost is ${formatUsd(total)} (limit ${formatUsd(max)})`;
+  if (total <= max) return pass(message);
+  const top = [...run.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(run, test) {
+  const assertions = test.assertions.map((a) => ({ ...assertion(run, 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(run, useCase, scenario) {
+  const u = findUseCase(run.diagram, useCase);
+  if (!u) return unknownUseCase(run, 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(run, a) {
+  switch (a.kind) {
+    case "calls":
+      return calls(run, a);
+    case "before":
+      return before(run, a);
+    case "writesBeforeResponding": {
+      const sc = scope(run, a.useCase, a.scenario);
+      if (isCheck(sc)) return sc;
+      const ids = new Set(selectNodes(run.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(run, a);
+    case "hasScenario": {
+      const u = findUseCase(run.diagram, a.useCase);
+      if (!u) return unknownUseCase(run, 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(run.diagram, a.useCase);
+      if (!u) return unknownUseCase(run, a.useCase);
+      const ids = new Set(selectNodes(run.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(run, a.from, a.to);
+    case "replicas": {
+      const nodes = selectNodes(run.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(run, a) {
+  const sc = scope(run, a.useCase, a.scenario);
+  if (isCheck(sc)) return sc;
+  const what = selectorText(a.target);
+  const ids = new Set(selectNodes(run.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(run.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(run, a) {
+  const sc = scope(run, a.useCase, a.scenario);
+  if (isCheck(sc)) return sc;
+  const first = new Set(selectNodes(run.diagram, a.first).map((n) => n.id));
+  const then = new Set(selectNodes(run.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(run, a) {
+  const sc = scope(run, 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(run, from, to) {
+  const sources = new Set(selectNodes(run.diagram, from).map((n) => n.id));
+  const targets = new Set(selectNodes(run.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 = run.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 run.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/proschi.ts
 var KEYWORDS2 = [
   { label: "title", detail: "Document title", snippet: 'title "$1"' },
@@ -26475,15 +28080,91 @@ var KEYWORDS2 = [
   { label: "group", detail: 'group id "Name" [Style] { \u2026 }', snippet: 'group ${1:id} "${2:Name}" {\n	$0\n}' },
   { label: "usecase", detail: 'usecase "Name" { steps }', snippet: 'usecase "${1:Name}" {\n	$0\n}' },
   { label: "par", detail: "Steps that run in parallel", snippet: "par {\n	$0\n}" },
-  { label: "alt", detail: "One scenario of a use case", snippet: 'alt "${1:Scenario}" {\n	$0\n}' }
+  { label: "alt", detail: "One scenario of a use case", snippet: 'alt "${1:Scenario}" {\n	$0\n}' },
+  // High-level design sections (top level).
+  { label: "traffic", detail: 'Requests per use case: "Use case" 100 rps', snippet: 'traffic {\n	"${1:Use case}" ${2:100 rps}$0\n}' },
+  { label: "requirements", detail: "Latency, availability, durability, resilience, cost", snippet: "requirements {\n	p99 < ${1:200ms}$0\n}" },
+  { label: "capacity", detail: "Per-replica overrides: node 1k rps latency 5ms", snippet: "capacity {\n	${1:node} ${2:1k rps}$0\n}" },
+  { label: "entity", detail: "entity Name in store { fields }", snippet: "entity ${1:Name} in ${2:store} {\n	${3:id} ${4:uuid} key$0\n}" },
+  { label: "decision", detail: "A design decision with its reasons", snippet: 'decision "${1:Title}" {\n	because "${2:reason}"$0\n}' },
+  { label: "test", detail: 'Flow assertions: "Use case" calls any cache', snippet: 'test "${1:Name}" {\n	$0\n}' }
 ];
 
+// src/imports.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path4 = require("node:path");
+function fileResolver(read = () => void 0, toPath = (p) => p) {
+  return (importPath, fromPath) => {
+    const abs = (0, import_node_path4.resolve)(fromPath ? (0, import_node_path4.dirname)(fromPath) : process.cwd(), importPath);
+    const text = read(abs) ?? ((0, import_node_fs3.existsSync)(abs) && (0, import_node_fs3.statSync)(abs).isFile() ? (0, import_node_fs3.readFileSync)(abs, "utf8") : void 0);
+    return text === void 0 ? void 0 : { path: toPath(abs), source: text };
+  };
+}
+function reachableFrom(result, start) {
+  const reached = /* @__PURE__ */ new Set([start]);
+  const queue = [start];
+  while (queue.length) {
+    const file = queue.shift();
+    for (const i of result.imports ?? []) {
+      if (i.loc.file === file && i.resolved !== void 0 && !reached.has(i.resolved)) {
+        reached.add(i.resolved);
+        queue.push(i.resolved);
+      }
+    }
+  }
+  return reached;
+}
+function ownDiagnostics(result) {
+  const own = result.diagnostics.filter((d) => d.file === void 0);
+  for (const i of result.imports ?? []) {
+    if (i.loc.file !== void 0 || i.resolved === void 0) continue;
+    const files = reachableFrom(result, i.resolved);
+    const errors = result.diagnostics.filter((d) => d.severity === "error" && d.file !== void 0 && files.has(d.file)).length;
+    if (errors) own.push({ severity: "error", message: `'${(0, import_node_path4.basename)(i.path)}' has ${errors} error${errors === 1 ? "" : "s"}`, ...i.loc });
+  }
+  return own.sort((a, b) => a.line - b.line || a.col - b.col);
+}
+function importLinks(result) {
+  return (result.imports ?? []).filter((i) => i.loc.file === void 0 && i.resolved !== void 0).map((i) => {
+    const range = toRange(i.loc);
+    return {
+      range: { start: { ...range.start, character: range.start.character + 1 }, end: { ...range.end, character: Math.max(range.start.character + 1, range.end.character - 1) } },
+      target: i.resolved
+    };
+  });
+}
+
+// src/simulation.ts
+function testDiagnostics(diagram) {
+  const out = [];
+  for (const r of runTests(diagram)) {
+    if (r.passed || !r.loc || r.loc.file !== void 0) continue;
+    const message = `${r.name}: ${r.message}${r.hint ? `. ${r.hint}` : ""}`;
+    out.push({ ...r.loc, severity: "warning", message });
+    for (const a of r.assertions ?? []) {
+      if (a.passed || a.loc.file !== void 0 || a.loc.line === r.loc.line) continue;
+      out.push({ ...a.loc, severity: "warning", message: `${a.message}${a.hint ? `. ${a.hint}` : ""}` });
+    }
+  }
+  return out;
+}
+function nodeSimulation(diagram, nodeId) {
+  if ((diagram.traffic ?? []).length === 0) return void 0;
+  const n = analyze(diagram).nodes.find((x) => x.id === nodeId);
+  if (!n || n.kind === "client" || n.kind === "other") return void 0;
+  const state = n.saturated ? " \u2014 **saturated**" : n.utilization > HOT ? " \u2014 hot" : "";
+  return [
+    `Load ${formatRps(n.loadRps)} of ${formatRps(n.capacityRps)} (${formatPercent(n.utilization)} utilised${state})`,
+    `Latency ${formatMs(n.latencyMs)} per call \xB7 availability ${formatAvailability(n.availability)} \xB7 ${formatUsd(n.costUsd)}${n.replicas > 1 ? ` for ${n.replicas} replicas` : ""}`
+  ].join("  \n");
+}
+
 // src/analysis.ts
 function toRange(loc) {
   const start = { line: loc.line - 1, character: loc.col - 1 };
   return { start, end: { line: start.line, character: start.character + Math.max(loc.length, 1) } };
 }
-function analyze(text, options) {
+function analyze2(text, options) {
   const result = parse(text, options);
   return { diagram: result.diagram, diagnostics: result.diagnostics, lines: text.split("\n"), result };
 }
@@ -26496,9 +28177,9 @@ function wordAt(line, character) {
   if (start === end || !/[A-Za-z_]/.test(line[start])) return null;
   return { word: line.slice(start, end), start, end };
 }
-function inLabel(before) {
+function inLabel(before2) {
   let quoted = false;
-  for (const ch of before) {
+  for (const ch of before2) {
     if (ch === '"') quoted = !quoted;
     else if (ch === ":" && !quoted) return true;
     else if (ch === "#" && !quoted) return false;
@@ -26530,9 +28211,9 @@ function labelStart(text) {
 }
 function complete(analysis, pos) {
   const line = analysis.lines[pos.line] ?? "";
-  const before = line.slice(0, pos.character);
+  const before2 = line.slice(0, pos.character);
   if (insidePayload(analysis.lines, pos.line)) return [];
-  const tech = before.match(/\[([^\]]*)$/);
+  const tech = before2.match(/\[([^\]]*)$/);
   if (tech) {
     const closed = line[pos.character] === "]";
     const range2 = { start: { line: pos.line, character: pos.character - tech[1].length }, end: pos };
@@ -26544,11 +28225,11 @@ function complete(analysis, pos) {
       range: range2
     }));
   }
-  if (inLabel(before)) return [];
-  const word = before.match(/[A-Za-z_]\w*$/)?.[0] ?? "";
+  if (inLabel(before2)) return [];
+  const word = before2.match(/[A-Za-z_]\w*$/)?.[0] ?? "";
   const range = { start: { line: pos.line, character: pos.character - word.length }, end: pos };
-  const atLineStart = /^\s*(\}\s*)?$/.test(before.slice(0, before.length - word.length));
-  if (/^\s*(\}\s*)?alt\s+"[^"]*"\s+$/.test(before.slice(0, before.length - word.length))) {
+  const atLineStart = /^\s*(\}\s*)?$/.test(before2.slice(0, before2.length - word.length));
+  if (/^\s*(\}\s*)?alt\s+"[^"]*"\s+$/.test(before2.slice(0, before2.length - word.length))) {
     return [{ label: "when", kind: "keyword", detail: "Condition of this scenario", snippet: 'when "${1:condition}" {\n	$0\n}', range }];
   }
   const nodes = analysis.diagram.nodes.map((n) => ({
@@ -26558,7 +28239,7 @@ function complete(analysis, pos) {
     range
   }));
   if (!atLineStart) return nodes;
-  const afterBrace = /\}\s*$/.test(before.slice(0, before.length - word.length));
+  const afterBrace = /\}\s*$/.test(before2.slice(0, before2.length - word.length));
   const keywords = KEYWORDS2.filter((k) => !afterBrace || k.label === "alt").map((k) => ({
     label: k.label,
     kind: "keyword",
@@ -26576,8 +28257,8 @@ function nodeAt(analysis, pos) {
   if (insidePayload(analysis.lines, pos.line)) return null;
   const word = wordAt(line, pos.character);
   if (!word) return null;
-  const before = line.slice(0, word.start);
-  if (inLabel(before) || (before.match(/"/g)?.length ?? 0) % 2 === 1 || /\[[^\]]*$/.test(before) || /@[\w-]*$/.test(before)) return null;
+  const before2 = line.slice(0, word.start);
+  if (inLabel(before2) || (before2.match(/"/g)?.length ?? 0) % 2 === 1 || /\[[^\]]*$/.test(before2) || /@[\w-]*$/.test(before2)) return null;
   const node = analysis.diagram.nodes.find((n) => n.id === word.word);
   if (!node) return null;
   return { node, range: { start: { line: pos.line, character: word.start }, end: { line: pos.line, character: word.end } } };
@@ -26621,6 +28302,8 @@ function hover(analysis, pos) {
   if (n.implicit) lines.push("", "_Not declared; created because it is referenced._");
   else if (n.loc.file) lines.push("", `_Declared in ${n.loc.file.split(/[\\/]/).pop()}_`);
   if (useCases.length) lines.push("", `Used in: ${useCases.map((u) => `\u201C${u.name}\u201D`).join(", ")}`);
+  const load = nodeSimulation(analysis.diagram, n.id);
+  if (load) lines.push("", load);
   return { markdown: lines.join("\n"), range: hit.range };
 }
 function outline(analysis) {
@@ -26646,7 +28329,27 @@ function outline(analysis) {
       children: []
     })) : []
   }));
-  return [...top, ...useCases];
+  return [...top, ...useCases, ...sections(analysis)];
+}
+function sections(analysis) {
+  const { diagram, lines } = analysis;
+  const own = (items) => (items ?? []).filter((i) => !i.loc.file);
+  const item = (kind, name, loc, detail) => ({ name, detail: detail || void 0, kind, range: toRange(loc), children: [] });
+  const sourceOf = (loc) => (lines[loc.line - 1] ?? "").slice(loc.col - 1, loc.col - 1 + loc.length);
+  const count = (n, what) => `${n} ${what}${n === 1 ? "" : "s"}`;
+  const groups = [
+    ["traffic", own(diagram.traffic).map((t) => item("traffic", t.useCase, t.loc, [`${t.rps} rps`, t.mix ? count(t.mix.length, "scenario") : ""].filter(Boolean).join(" \xB7 ")))],
+    ["requirements", own(diagram.requirements).map((r) => item("requirement", sourceOf(r.loc), r.loc))],
+    ["entities", own(diagram.entities).map((e) => item("entity", e.name, e.loc, [e.store ? `in ${e.store}` : "", count(e.fields.length, "field")].filter(Boolean).join(" \xB7 ")))],
+    ["decisions", own(diagram.decisions).map((d) => item("decision", d.title, d.loc, d.because))],
+    ["tests", own(diagram.tests).map((t) => item("test", t.name, t.loc, count(t.assertions.length, "assertion")))]
+  ];
+  return groups.filter(([, children]) => children.length).map(([name, children]) => ({
+    name,
+    kind: "section",
+    range: { start: children[0].range.start, end: children.reduce((end, c) => c.range.end.line >= end.line ? c.range.end : end, children[0].range.end) },
+    children
+  }));
 }
 var MISSING_CONNECTION = /^No connection between '\w+' and '\w+' in the architecture; add '(\w+) -> (\w+)'$/;
 function quickFix(analysis, message) {
@@ -26658,65 +28361,21 @@ function quickFix(analysis, message) {
   if (updated === text) return null;
   return { title: `Add connection '${from} -> ${to}'`, edit: diffEdit(text, updated) };
 }
-function diffEdit(before, after) {
+function diffEdit(before2, after) {
   let start = 0;
-  while (start < before.length && start < after.length && before[start] === after[start]) start++;
+  while (start < before2.length && start < after.length && before2[start] === after[start]) start++;
   let end = 0;
-  while (end < before.length - start && end < after.length - start && before[before.length - 1 - end] === after[after.length - 1 - end]) end++;
-  return { range: { start: positionAt(before, start), end: positionAt(before, before.length - end) }, newText: after.slice(start, after.length - end) };
+  while (end < before2.length - start && end < after.length - start && before2[before2.length - 1 - end] === after[after.length - 1 - end]) end++;
+  return { range: { start: positionAt(before2, start), end: positionAt(before2, before2.length - end) }, newText: after.slice(start, after.length - end) };
 }
 function positionAt(text, offset) {
-  const before = text.slice(0, offset).split("\n");
-  return { line: before.length - 1, character: before[before.length - 1].length };
-}
-
-// src/imports.ts
-var import_node_fs3 = require("node:fs");
-var import_node_path4 = require("node:path");
-function fileResolver(read = () => void 0, toPath = (p) => p) {
-  return (importPath, fromPath) => {
-    const abs = (0, import_node_path4.resolve)(fromPath ? (0, import_node_path4.dirname)(fromPath) : process.cwd(), importPath);
-    const text = read(abs) ?? ((0, import_node_fs3.existsSync)(abs) && (0, import_node_fs3.statSync)(abs).isFile() ? (0, import_node_fs3.readFileSync)(abs, "utf8") : void 0);
-    return text === void 0 ? void 0 : { path: toPath(abs), source: text };
-  };
-}
-function reachableFrom(result, start) {
-  const reached = /* @__PURE__ */ new Set([start]);
-  const queue = [start];
-  while (queue.length) {
-    const file = queue.shift();
-    for (const i of result.imports ?? []) {
-      if (i.loc.file === file && i.resolved !== void 0 && !reached.has(i.resolved)) {
-        reached.add(i.resolved);
-        queue.push(i.resolved);
-      }
-    }
-  }
-  return reached;
-}
-function ownDiagnostics(result) {
-  const own = result.diagnostics.filter((d) => d.file === void 0);
-  for (const i of result.imports ?? []) {
-    if (i.loc.file !== void 0 || i.resolved === void 0) continue;
-    const files = reachableFrom(result, i.resolved);
-    const errors = result.diagnostics.filter((d) => d.severity === "error" && d.file !== void 0 && files.has(d.file)).length;
-    if (errors) own.push({ severity: "error", message: `'${(0, import_node_path4.basename)(i.path)}' has ${errors} error${errors === 1 ? "" : "s"}`, ...i.loc });
-  }
-  return own.sort((a, b) => a.line - b.line || a.col - b.col);
-}
-function importLinks(result) {
-  return (result.imports ?? []).filter((i) => i.loc.file === void 0 && i.resolved !== void 0).map((i) => {
-    const range = toRange(i.loc);
-    return {
-      range: { start: { ...range.start, character: range.start.character + 1 }, end: { ...range.end, character: Math.max(range.start.character + 1, range.end.character - 1) } },
-      target: i.resolved
-    };
-  });
+  const before2 = text.slice(0, offset).split("\n");
+  return { line: before2.length - 1, character: before2[before2.length - 1].length };
 }
 
 // src/server.ts
 if (process.argv.includes("--version")) {
-  console.log(true ? "0.2.0" : "dev");
+  console.log(true ? "0.3.0" : "dev");
   process.exit(0);
 }
 var connection = (0, import_node.createConnection)(import_node.ProposedFeatures.all);
@@ -26731,7 +28390,7 @@ var resolve3 = fileResolver(openText);
 function analysisOf(doc) {
   const cached = cache2.get(doc.uri);
   if (cached?.version === doc.version) return cached.analysis;
-  const analysis = analyze(doc.getText(), { path: pathOf(doc.uri), resolve: resolve3 });
+  const analysis = analyze2(doc.getText(), { path: pathOf(doc.uri), resolve: resolve3 });
   const files = new Set((analysis.result.imports ?? []).flatMap((i) => i.resolved ? [i.resolved] : []));
   cache2.set(doc.uri, { version: doc.version, analysis, files });
   return analysis;
@@ -26757,7 +28416,7 @@ connection.onInitialize(() => ({
     documentFormattingProvider: true,
     codeActionProvider: { codeActionKinds: [import_node.CodeActionKind.QuickFix] }
   },
-  serverInfo: { name: "proschi-language-server", version: true ? "0.2.0" : "dev" }
+  serverInfo: { name: "proschi-language-server", version: true ? "0.3.0" : "dev" }
 }));
 function validate(document) {
   const analysis = analysisOf(document);
@@ -26773,10 +28432,19 @@ function validate(document) {
     diagnostics: [
       ...ownDiagnostics(analysis.result).map(toLsp("proschi")),
       // Findings on steps in imported files belong to those files.
-      ...openApiFindings(document, analysis.diagram).filter((d) => d.file === void 0).map(toLsp("proschi-openapi"))
+      ...openApiFindings(document, analysis.diagram).filter((d) => d.file === void 0).map(toLsp("proschi-openapi")),
+      ...simulationFindings(analysis.diagram).map(toLsp("proschi-test"))
     ]
   });
 }
+function simulationFindings(diagram) {
+  try {
+    return testDiagnostics(diagram);
+  } catch (e) {
+    connection.console.error(`Simulation failed: ${String(e)}`);
+    return [];
+  }
+}
 function openApiFindings(document, diagram) {
   if (!document.uri.startsWith("file:")) return [];
   try {
@@ -26847,7 +28515,18 @@ connection.onReferences((params) => {
   if (!doc) return [];
   return references(analysisOf(doc), params.position).map((range) => ({ uri: params.textDocument.uri, range }));
 });
-var SYMBOL_KIND = { node: import_node.SymbolKind.Object, group: import_node.SymbolKind.Namespace, usecase: import_node.SymbolKind.Function, scenario: import_node.SymbolKind.Event };
+var SYMBOL_KIND = {
+  node: import_node.SymbolKind.Object,
+  group: import_node.SymbolKind.Namespace,
+  usecase: import_node.SymbolKind.Function,
+  scenario: import_node.SymbolKind.Event,
+  section: import_node.SymbolKind.Module,
+  traffic: import_node.SymbolKind.Property,
+  requirement: import_node.SymbolKind.Constant,
+  entity: import_node.SymbolKind.Struct,
+  decision: import_node.SymbolKind.Key,
+  test: import_node.SymbolKind.Method
+};
 function toSymbol(s) {
   return { name: s.name, detail: s.detail, kind: SYMBOL_KIND[s.kind], range: s.range, selectionRange: s.range, children: s.children.map(toSymbol) };
 }