proschi 0.3.0 → 0.5.0

package/dist/server.cjs

@@ -25435,7 +25435,7 @@ 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_/])/;
+var SEPARATE_UNIT = /^[ \t]+(rps|rpm|rpd|ms|s|%|usd\/month|usd\/GB|MB\/s|GB\/s)(?![A-Za-z0-9_/])/;
 function tokenizeLine(text, line) {
   const tokens = [];
   const diagnostics = [];
@@ -25627,11 +25627,21 @@ function endpointGroupKey(endpoint, all) {
 }
 
 // ../frontend/src/dsl/kinds.ts
-var KINDS = ["client", "edge", "service", "function", "cache", "database", "search", "analytics", "queue", "storage", "external", "other"];
+var KINDS = ["client", "edge", "cdn", "loadbalancer", "gateway", "dns", "service", "function", "cache", "database", "search", "analytics", "queue", "storage", "external", "other"];
 var DATA_STORE_KINDS = ["cache", "database", "search", "analytics", "queue", "storage"];
+var EDGE_KINDS = ["edge", "cdn", "loadbalancer", "gateway", "dns"];
 var BY_TECH = {
-  "AWS API Gateway": "edge",
-  "Azure API Management": "edge",
+  "AWS CloudFront": "cdn",
+  "Azure CDN": "cdn",
+  "GCP Cloud CDN": "cdn",
+  "Azure Front Door": "cdn",
+  "AWS Load Balancer": "loadbalancer",
+  "GCP Load Balancing": "loadbalancer",
+  "AWS API Gateway": "gateway",
+  "Azure API Management": "gateway",
+  "AWS Route53": "dns",
+  "Azure DNS": "dns",
+  "GCP Cloud DNS": "dns",
   Redis: "cache",
   Elasticsearch: "search",
   "GCP BigQuery": "analytics",
@@ -25663,6 +25673,12 @@ function isKind(word) {
 function isDataStore(kind) {
   return DATA_STORE_KINDS.includes(kind);
 }
+function isEdge(kind) {
+  return EDGE_KINDS.includes(kind);
+}
+function kindMatches(actual, wanted) {
+  return actual === wanted || wanted === "edge" && isEdge(actual);
+}
 
 // ../frontend/src/dsl/quantity.ts
 function parseQuantity(text) {
@@ -25674,11 +25690,11 @@ function parseQuantity(text) {
   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) };
+  const after2 = UNITS.get(rest);
+  if (magnitude && (rest === "" || after2)) {
+    return after2 ? { value: round(number * magnitude * after2.factor), unit: after2.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)` };
+  return { error: `Unknown unit '${suffix}' in '${text}'; use rps, rpm, rpd, ms, s, %, usd/month, MB/s, GB/s or usd/GB (with k, m or b for thousands, millions, billions)` };
 }
 var round = (n) => Number(n.toPrecision(12));
 var MAGNITUDES = /* @__PURE__ */ new Map([
@@ -25693,9 +25709,67 @@ var UNITS = /* @__PURE__ */ new Map([
   ["ms", { unit: "ms", factor: 1 }],
   ["s", { unit: "ms", factor: 1e3 }],
   ["%", { unit: "%", factor: 1 }],
-  ["usd/month", { unit: "usd/month", factor: 1 }]
+  ["usd/month", { unit: "usd/month", factor: 1 }],
+  ["MB/s", { unit: "MBps", factor: 1 }],
+  ["GB/s", { unit: "MBps", factor: 1e3 }],
+  ["usd/GB", { unit: "usd/GB", factor: 1 }]
 ]);
 
+// ../frontend/src/dsl/access.ts
+var WRITE_METHODS = ["POST", "PUT", "PATCH", "DELETE"];
+var WRITE_VERBS = [
+  "INSERT",
+  "UPDATE",
+  "UPSERT",
+  "DELETE",
+  "PUT",
+  "SET",
+  "WRITE",
+  "APPEND",
+  "INCR",
+  "DECR",
+  "LPUSH",
+  "RPUSH",
+  "ZADD",
+  "HSET",
+  "GEOADD",
+  "PUBLISH",
+  "SEND",
+  "ENQUEUE",
+  "PRODUCE",
+  "CHARGE",
+  "CREATE",
+  // DynamoDB and Redis commands that store data
+  "PUTITEM",
+  "UPDATEITEM",
+  "DELETEITEM",
+  "BATCHWRITEITEM",
+  "INCRBY",
+  "HINCRBY",
+  "SADD",
+  "XADD",
+  "MSET",
+  // Plain words for storing something
+  "SAVE",
+  "STORE",
+  "UPLOAD",
+  "COMMIT",
+  "RECORD",
+  "MARK",
+  // Claiming a resource changes state: a seat, a driver, stock
+  "RESERVE",
+  "HOLD",
+  "BOOK",
+  // Handing something on: a write at the receiver (a queue, a provider), like SEND and PUBLISH
+  "EMIT",
+  "NOTIFY"
+];
+function accessOf(httpMethod, label) {
+  if (httpMethod) return WRITE_METHODS.includes(httpMethod.toUpperCase()) ? "write" : "read";
+  const word = /^\s*"?([A-Za-z_]+)/.exec(label)?.[1];
+  return word && WRITE_VERBS.includes(word.toUpperCase()) ? "write" : "read";
+}
+
 // ../frontend/src/dsl/parser.ts
 var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
 var DEFAULT_TECH = "Rectangle";
@@ -25708,10 +25782,13 @@ 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"
+  "usd/month": "a monthly cost, e.g. 400 usd/month",
+  MBps: "a bandwidth, e.g. 500 MB/s or 1 GB/s",
+  "usd/GB": "a price per gigabyte, e.g. 0.05 usd/GB"
 };
-var 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 CAPACITY_PARTS = "a rate, reads, writes, shards, latency, availability, cost, durable or volatile, consistency, bandwidth or egress";
+var ASSERTION_HELP = 'Expected an assertion: "Use case" calls <node>, "Use case" writes <node> before responding, <node> calls <node>, no path from <node> to <node>, <node> has replicas >= 2, \u2026';
+var ASSERTION_VERBS = "calls, every scenario calls, never calls, never waits for, writes, responds, starts at, has scenario or handles failure of";
 var techByName = new Map(
   componentCatalog.map((c) => [c.techStack.toLowerCase(), { type: c.type, techStack: c.techStack }])
 );
@@ -26142,7 +26219,20 @@ var Parser = class {
     if (top?.kind === "usecase" || top?.kind === "alt" || top?.kind === "par") {
       const body = this.currentBody();
       body.openAlt = void 0;
-      body.items.push({ kind: "step", step: { from, to, arrow, label, parallelGroup: top.kind === "par" ? top.group : void 0, loc } });
+      const prefixes = arrow === "-->" ? { rest: label } : this.readLabelPrefixes(label, labelToken, line);
+      body.items.push({
+        kind: "step",
+        step: {
+          from,
+          to,
+          arrow,
+          label: prefixes.rest,
+          parallelGroup: top.kind === "par" ? top.group : void 0,
+          ...prefixes.multiplier !== void 0 ? { multiplier: prefixes.multiplier } : {},
+          ...prefixes.sizeBytes !== void 0 ? { sizeBytes: prefixes.sizeBytes } : {},
+          loc
+        }
+      });
     } else if (arrow === "-x") {
       this.error("'-x' marks a failed call and is only allowed in use case steps", this.locOf(arrowToken, line));
     } else {
@@ -26152,6 +26242,42 @@ var Parser = class {
     }
     return lastLine;
   }
+  /**
+   * Reads `x<N>` (fan-out) and `~<size>` (payload size) at the start of a step
+   * label, in either order (§7.3), and returns the label without them. A
+   * prefix must be followed by whitespace or end the label, so `xml …` and
+   * `x-request-id` are ordinary labels. Problems are reported at the prefix.
+   */
+  readLabelPrefixes(label, token, line) {
+    const out = { rest: label };
+    if (!token) return out;
+    const after2 = this.lines[line - 1].slice(token.col);
+    const base = token.col + 1 + (after2.length - after2.trimStart().length);
+    let offset = 0;
+    for (; ; ) {
+      const rest = label.slice(offset);
+      const at = (length) => ({ line, col: base + offset, length, ...this.fileField() });
+      const fanOut = /^x(\d+)(?=\s|$)/.exec(rest);
+      const size = rest.startsWith("~") ? /^~(\S*)/.exec(rest) : null;
+      const match = fanOut ?? size;
+      if (!match) break;
+      if (fanOut) {
+        const n = Number(fanOut[1]);
+        if (out.multiplier !== void 0) this.error("The fan-out is given twice; write one x<N>", at(match[0].length));
+        else if (n < 1) this.error("A fan-out needs at least one call per request: x1, x2, \u2026", at(match[0].length));
+        else out.multiplier = n;
+      } else {
+        const bytes = parseSize(size[1]);
+        if (out.sizeBytes !== void 0) this.error("The payload size is given twice; write one ~<size>", at(match[0].length));
+        else if ("error" in bytes) this.error(bytes.error, at(match[0].length));
+        else out.sizeBytes = bytes.value;
+      }
+      offset += match[0].length;
+      offset += label.slice(offset).length - label.slice(offset).trimStart().length;
+    }
+    out.rest = label.slice(offset);
+    return out;
+  }
   // ---- 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
@@ -26275,10 +26401,14 @@ var Parser = class {
       useCase = { name: tokens[i].value, loc: this.locOf(tokens[i], line) };
       i++;
     };
-    const commit = (requirement2) => {
+    const commit = (requirement2, scenario) => {
       this.requirements.push(requirement2);
       const named = useCase;
-      if (named) this.deferred.push(() => this.checkUseCase(named.name, named.loc));
+      if (named)
+        this.deferred.push(() => {
+          const found = this.checkUseCase(named.name, named.loc);
+          if (found && scenario) this.checkScenario(found, scenario.name, scenario.loc);
+        });
     };
     const withUseCase = () => useCase ? { useCase: useCase.name } : {};
     if (/^p\d+$/.test(word)) {
@@ -26288,10 +26418,24 @@ var Parser = class {
         return;
       }
       readUseCase();
+      let scenario;
+      if (isWord(tokens[i], "scenario")) {
+        const name = tokens[i + 1];
+        if (!useCase) {
+          this.error(`A scenario belongs to a use case; write ${word} "Use case" scenario "Scenario" < 100ms`, this.locOf(tokens[i], line));
+          return;
+        }
+        if (name?.kind !== "string") {
+          this.error("Expected a scenario name in quotes after scenario", this.locOf(name ?? tokens[i], line));
+          return;
+        }
+        scenario = { name: name.value, loc: this.locOf(name, line) };
+        i += 2;
+      }
       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 });
+      commit({ kind: "latency", percentile, ...withUseCase(), ...scenario ? { scenario: scenario.name } : {}, maxMs, loc }, scenario);
       return;
     }
     switch (word) {
@@ -26374,8 +26518,50 @@ var Parser = class {
         part = "durable or volatile";
         override.durable = t.value === "durable";
         i++;
+      } else if (isWord(t, "reads") || isWord(t, "writes")) {
+        part = t.value;
+        const value = this.quantityOf(tokens[i + 1], "rps", t, line);
+        if (value === void 0) return;
+        if (part === "reads") override.readRps = value;
+        else override.writeRps = value;
+        i += 2;
+      } else if (isWord(t, "shards")) {
+        part = "shards";
+        const n = tokens[i + 1];
+        if (n?.kind !== "number" || Number(n.value) < 1) {
+          this.error("Expected a whole number of shards, at least 1, e.g. shards 4", this.locOf(n ?? t, line));
+          return;
+        }
+        override.shards = Number(n.value);
+        i += 2;
+      } else if (isWord(t, "consistency")) {
+        part = "consistency";
+        const value = tokens[i + 1];
+        if (!isWord(value, "strong") && !isWord(value, "eventual")) {
+          this.error(`Expected strong or eventual after consistency${value ? `, not ${describe(value)}` : ""}`, this.locOf(value ?? t, line));
+          return;
+        }
+        override.consistency = value.value;
+        i += 2;
+      } else if (isWord(t, "bandwidth") || isWord(t, "egress")) {
+        part = t.value;
+        const value = this.quantityOf(tokens[i + 1], part === "bandwidth" ? "MBps" : "usd/GB", t, line);
+        if (value === void 0) return;
+        if (part === "bandwidth") {
+          if (value <= 0) {
+            this.error("Bandwidth must be more than 0", this.locOf(tokens[i + 1], line));
+            return;
+          }
+          override.bandwidthMBps = value;
+        } else override.egressUsdPerGb = value;
+        i += 2;
       } else {
-        this.error(`Unexpected ${describe(t)}; expected a rate, latency, availability, cost, durable or volatile`, this.locOf(t, line));
+        this.error(`Unexpected ${describe(t)}; expected ${CAPACITY_PARTS}`, this.locOf(t, line));
+        return;
+      }
+      const clash = part === "rate" ? ["reads", "writes"].find((p) => seen.has(p)) : part === "reads" || part === "writes" ? seen.has("rate") ? part : void 0 : void 0;
+      if (clash) {
+        this.error(`A rate sets both reads and writes; give either a rate or reads and writes for '${id.value}'`, this.locOf(t, line));
         return;
       }
       if (seen.has(part)) {
@@ -26386,7 +26572,7 @@ var Parser = class {
     }
     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);
+      this.warning(`Capacity line for '${id.value}' overrides nothing; add ${CAPACITY_PARTS}`, idLoc);
       return;
     }
     const first = this.capacity.find((c) => c.node === id.value);
@@ -26396,7 +26582,14 @@ var Parser = class {
     }
     this.capacity.push(override);
     this.deferred.push(() => {
-      if (!this.nodes.has(id.value)) this.warning(`Unknown node '${id.value}' in capacity`, idLoc);
+      const node = this.nodes.get(id.value);
+      if (!node) {
+        this.warning(`Unknown node '${id.value}' in capacity`, idLoc);
+        return;
+      }
+      const storeOnly = ["shards", "consistency"].filter((p) => seen.has(p));
+      if (storeOnly.length && !isDataStore(kindOf(node)))
+        this.warning(`'${id.value}' is not a data store (${DATA_STORE_KINDS.join(", ")}); ${storeOnly.join(" and ")} only apply to data stores`, idLoc);
     });
   }
   /** `entity Url [in db] ["description"] {` */
@@ -26581,10 +26774,28 @@ var Parser = class {
         this.error(ASSERTION_HELP, this.locOf(first, line));
         return;
       }
-      const target = selector(0);
+      const inUseCase = isWord(first, "in") && tokens[1]?.kind === "string" ? { name: tokens[1].value, loc: this.locOf(tokens[1], line) } : void 0;
+      const target = selector(inUseCase ? 2 : 0);
       if (!target) return;
-      if (!isWord(tokens[target.next], "has")) {
-        this.error(ASSERTION_HELP, this.locOf(tokens[target.next] ?? first, line));
+      const word = tokens[target.next];
+      if (isWord(word, "calls") || isWord(word, "never")) {
+        const never = word.value === "never";
+        if (never && !expectWords(target.next + 1, ["calls"], "any service never calls any storage")) return;
+        const to = selector(target.next + (never ? 2 : 1));
+        if (!to) return;
+        const assertion3 = done(
+          { kind: "senderCalls", ...inUseCase ? { useCase: inUseCase.name } : {}, from: target.selector, to: to.selector, quantifier: never ? "never" : "some", loc },
+          to.next
+        );
+        if (assertion3 && inUseCase) this.deferred.push(() => this.checkUseCase(inUseCase.name, inUseCase.loc));
+        return assertion3;
+      }
+      if (inUseCase) {
+        this.error(`Expected calls or never calls here, e.g. in "${inUseCase.name}" api calls db`, this.locOf(word ?? tokens[tokens.length - 1], line));
+        return;
+      }
+      if (!isWord(word, "has")) {
+        this.error(ASSERTION_HELP, this.locOf(word ?? first, line));
         return;
       }
       const i2 = target.next + 1;
@@ -26625,6 +26836,10 @@ var Parser = class {
         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 if (isWord(tokens[target.next], "after")) {
+        const after2 = selector(target.next + 1);
+        if (!after2) return;
+        assertion2 = done({ kind: "after", useCase, ...withScenario, target: target.selector, after: after2.selector, loc }, after2.next);
       } else {
         assertion2 = done({ kind: "calls", useCase, ...withScenario, target: target.selector, quantifier: "some", loc }, target.next);
       }
@@ -26633,6 +26848,16 @@ var Parser = class {
       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") && isWord(tokens[i + 1], "waits")) {
+      if (!expectWords(i + 2, ["for"], `"${useCase}" never waits for any queue`)) return;
+      const target = selector(i + 3);
+      if (!target) return;
+      assertion2 = done({ kind: "neverWaits", useCase, ...withScenario, target: target.selector, loc }, target.next);
+    } else if (isWord(verb, "starts")) {
+      if (!wholeUseCase("starts at") || !expectWords(i + 1, ["at"], `"${useCase}" starts at any queue`)) return;
+      const target = selector(i + 2);
+      if (!target) return;
+      assertion2 = done({ kind: "startsAt", useCase, target: target.selector, loc }, target.next);
     } else if (isWord(verb, "never")) {
       if (!expectWords(i + 1, ["calls"], `"${useCase}" never calls any database`)) return;
       const target = selector(i + 2);
@@ -26674,8 +26899,23 @@ var Parser = class {
     }
     return assertion2;
   }
-  /** A node id, `[Tech]` or `any <kind>` starting at `tokens[i]`. */
+  /** A selector starting at `tokens[i]`: one or more of node id, `[Tech]`, `any <kind>`, `any strong store`, joined by `or`. */
   parseSelector(tokens, i, line) {
+    const atoms = [];
+    let next = i;
+    for (; ; ) {
+      const atom = this.parseSelectorAtom(tokens, next, line);
+      if (!atom) return void 0;
+      atoms.push(atom);
+      next = atom.next;
+      if (!isWord(tokens[next], "or")) break;
+      next++;
+    }
+    const selector = atoms.length === 1 ? atoms[0].selector : { anyOf: atoms.map((a) => a.selector) };
+    return { selector, next, atoms };
+  }
+  /** One node id, `[Tech]`, `any <kind>` or `any strong|eventual store` at `tokens[i]`. */
+  parseSelectorAtom(tokens, i, line) {
     const t = tokens[i];
     if (t?.kind === "tech") {
       const tech = techByName.get(t.value.toLowerCase())?.techStack ?? t.value;
@@ -26683,8 +26923,15 @@ var Parser = class {
     }
     if (isWord(t, "any")) {
       const kind = tokens[i + 1];
+      if (isWord(kind, "strong") || isWord(kind, "eventual")) {
+        if (!isWord(tokens[i + 2], "store")) {
+          this.error(`Expected 'store' here, e.g. any ${kind.value} store`, this.locOf(tokens[i + 2] ?? kind, line));
+          return void 0;
+        }
+        return { selector: { consistency: kind.value }, next: i + 3, token: t, loc: this.locOf(t, line) };
+      }
       if (kind?.kind !== "ident" || !isKind(kind.value)) {
-        this.error(`Expected a kind after any: ${KINDS.join(", ")}`, this.locOf(kind ?? t, line));
+        this.error(`Expected a kind after any: ${KINDS.join(", ")}, or strong store / eventual store`, this.locOf(kind ?? t, line));
         return void 0;
       }
       return { selector: { kind: kind.value }, next: i + 2, token: t, loc: this.locOf(t, line) };
@@ -26694,12 +26941,14 @@ var Parser = class {
     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);
-      });
+  checkSelectorLater({ atoms }) {
+    for (const { selector, token, loc } of atoms) {
+      if ("tech" in selector && !techByName.has(token.value.toLowerCase())) this.warning(`Unknown tech stack '${token.value}'`, loc);
+      if ("node" in selector) {
+        this.deferred.push(() => {
+          if (!this.nodes.has(selector.node)) this.warning(`Unknown node '${selector.node}'`, loc);
+        });
+      }
     }
   }
   checkUseCase(name, loc) {
@@ -26713,10 +26962,10 @@ var Parser = class {
     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) {
+  quantityOf(token, unit, after2, 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));
+      this.error(`Expected ${expected}${token ? `, not ${describe(token)}` : ""}`, this.locOf(token ?? after2, line));
       return void 0;
     }
     const loc = this.locOf(token, line);
@@ -26819,7 +27068,10 @@ var Parser = class {
         isParallel: step.parallelGroup !== void 0,
         isConditional: false,
         ...step.arrow === "-x" ? { failed: true } : {},
-        loc: step.loc
+        loc: step.loc,
+        ...step.multiplier !== void 0 ? { multiplier: step.multiplier } : {},
+        ...step.sizeBytes !== void 0 ? { sizeBytes: step.sizeBytes } : {},
+        access: accessOf(label.method, step.label)
       });
     }
     return steps;
@@ -26985,6 +27237,16 @@ function parseStepLabel(input) {
   const payload = splitPayload(input);
   return { name: payload.text, format: payload.body ? payload.format : void 0, body: payload.body };
 }
+var SIZE_UNITS = { B: 1, KB: 1e3, MB: 1e6, GB: 1e9, TB: 1e12 };
+function parseSize(text) {
+  const m = /^(\d+(?:\.\d+)?)([A-Za-z]*)$/.exec(text);
+  if (!m) return { error: `Expected a payload size after ~, e.g. ~2MB, ~500KB or ~1.5GB${text ? `, not '~${text}'` : ""}` };
+  const factor = SIZE_UNITS[m[2]];
+  if (factor === void 0) return { error: m[2] ? `Unknown size unit '${m[2]}' in '~${text}'; use B, KB, MB, GB or TB` : `'~${text}' needs a unit: B, KB, MB, GB or TB` };
+  const value = Math.round(Number(m[1]) * factor);
+  if (value <= 0) return { error: `A payload size must be more than 0, not '~${text}'` };
+  return { value };
+}
 function inferProtocol(isAsync, method, target) {
   if (isAsync || target?.type === "queue") return "MESSAGING";
   if (!method) return "OTHER";
@@ -27215,8 +27477,8 @@ function alignConnections(run) {
 function commentOf(raw, tokens) {
   const last = tokens[tokens.length - 1];
   if (last.kind === "label") {
-    const after = raw.slice(last.col);
-    return after.slice(stripTrailingComment(after).length).trim();
+    const after2 = raw.slice(last.col);
+    return after2.slice(stripTrailingComment(after2).length).trim();
   }
   return raw.slice(last.col - 1 + last.length).trim();
 }
@@ -27384,6 +27646,104 @@ var RESERVED = new Set(
   ].map((w) => w.toLowerCase())
 );
 
+// ../frontend/src/sim/access.ts
+function stepAccess(step) {
+  return step.access ?? accessOf(step.httpMethod, step.stepName ?? "");
+}
+function accessIn(diagram) {
+  const queues = new Set(diagram.nodes.filter((n) => kindOf(n) === "queue").map((n) => n.id));
+  return (step) => queues.has(step.toServiceId) ? "write" : stepAccess(step);
+}
+
+// ../frontend/src/sim/profiles.ts
+var NEUTRAL = { rps: Infinity, latencyMs: 0, availability: 1, costUsd: 0, durable: false };
+var RELATIONAL = {
+  rps: 2e4,
+  readRps: 2e4,
+  writeRps: 5e3,
+  writeScaling: "shards",
+  latencyMs: 5,
+  availability: 0.9995,
+  costUsd: 400,
+  durable: true,
+  consistency: "strong"
+};
+var KIND_PROFILES = {
+  client: { ...NEUTRAL, bandwidthMBps: 10 },
+  edge: { rps: 1e5, latencyMs: 2, availability: 0.9999, costUsd: 50, durable: false },
+  cdn: { rps: 2e5, latencyMs: 5, availability: 0.9999, costUsd: 100, durable: false, egressUsdPerGb: 0.02 },
+  loadbalancer: { rps: 1e5, latencyMs: 2, availability: 0.9999, costUsd: 50, durable: false },
+  gateway: { rps: 1e4, latencyMs: 10, availability: 0.9995, costUsd: 100, durable: false },
+  // Name resolution happens before the request and is cached: off the request path.
+  dns: { rps: Infinity, latencyMs: 0, availability: 1, costUsd: 0, 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, consistency: "eventual" },
+  database: RELATIONAL,
+  search: { rps: 3e3, latencyMs: 15, availability: 0.999, costUsd: 400, durable: true, consistency: "eventual" },
+  analytics: { rps: 200, latencyMs: 500, availability: 0.999, costUsd: 300, durable: true, consistency: "eventual" },
+  queue: { rps: 5e4, latencyMs: 5, availability: 0.9999, costUsd: 200, durable: true, consistency: "strong" },
+  storage: { rps: 5e3, latencyMs: 30, availability: 0.9999, costUsd: 50, durable: true, consistency: "eventual", egressUsdPerGb: 0.09 },
+  external: { rps: 1e3, latencyMs: 200, availability: 0.999, costUsd: 0, durable: false },
+  other: NEUTRAL
+};
+var NOSQL = { rps: 2e4, latencyMs: 5, availability: 0.9999, costUsd: 500, durable: true, consistency: "eventual" };
+var NOSQL_STRONG = { ...NOSQL, consistency: "strong" };
+var TECH_PROFILES = {
+  DynamoDB: NOSQL,
+  "AWS DynamoDB": NOSQL,
+  Cassandra: NOSQL,
+  CouchDB: NOSQL,
+  "Azure Cosmos DB": NOSQL,
+  MongoDB: NOSQL_STRONG,
+  "GCP Bigtable": NOSQL_STRONG,
+  "GCP Firestore": NOSQL_STRONG,
+  "GCP Spanner": NOSQL_STRONG
+};
+var BANDWIDTH = {
+  client: 10,
+  edge: 1e3,
+  cdn: 1e3,
+  loadbalancer: 1e3,
+  gateway: 1e3,
+  dns: 1e3,
+  service: 200
+};
+var DEFAULT_BANDWIDTH_MBPS = 100;
+function profileOf(node, override) {
+  const kind = kindOf(node);
+  const base = TECH_PROFILES[node.techStack] ?? KIND_PROFILES[kind];
+  const baseRead = base.readRps ?? base.rps;
+  const baseWrite = base.writeRps ?? base.rps;
+  const readRps = override?.readRps ?? override?.rps ?? baseRead;
+  const writeRps = override?.writeRps ?? override?.rps ?? baseWrite;
+  const consistency = override?.consistency ?? base.consistency;
+  return {
+    kind,
+    rps: readRps,
+    readRps,
+    writeRps,
+    writeScaling: base.writeScaling ?? "replicas",
+    shards: Math.max(1, Math.floor(override?.shards ?? 1)),
+    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,
+    ...consistency && isDataStore(kind) ? { consistency } : {},
+    bandwidthMBps: override?.bandwidthMBps ?? base.bandwidthMBps ?? BANDWIDTH[kind] ?? DEFAULT_BANDWIDTH_MBPS,
+    egressUsdPerGb: override?.egressUsdPerGb ?? base.egressUsdPerGb ?? 0
+  };
+}
+function capacityOf(p, replicas) {
+  return {
+    readRps: p.readRps * replicas * p.shards,
+    writeRps: p.writeRps * (p.writeScaling === "shards" ? 1 : replicas) * p.shards
+  };
+}
+function combinedUtilization(p, readUtilization, writeUtilization) {
+  return p.writeScaling === "shards" ? Math.max(readUtilization, writeUtilization) : readUtilization + writeUtilization;
+}
+
 // ../frontend/src/sim/flow.ts
 function findUseCase(diagram, name) {
   const lower = name.toLowerCase();
@@ -27448,9 +27808,9 @@ function requestOrder(useCase, scenario) {
   }
   return { requests, beforeResponse: beforeResponse < 0 ? requests.length : beforeResponse };
 }
-function writesBeforeResponse(useCase, scenario, accept) {
+function writesBeforeResponse(useCase, scenario, accept, isWrite = (step) => stepAccess(step) === "write") {
   const { requests, beforeResponse } = requestOrder(useCase, scenario);
-  return requests.slice(0, beforeResponse).some((m) => !m.async && !m.failed && accept(m.to));
+  return requests.slice(0, beforeResponse).some((m) => !m.async && !m.failed && accept(m.to) && isWrite(m.step));
 }
 function callsOk(scenario, nodeId) {
   return scenario.steps.some((s) => s.toServiceId === nodeId && !s.failed);
@@ -27459,23 +27819,34 @@ 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)
-  );
+  return useCase.scenarios.filter((s) => {
+    if (s.outcome !== "success") return false;
+    const { requests, beforeResponse } = requestOrder(useCase, s);
+    const early = requests.slice(0, beforeResponse).filter((m) => m.to === nodeId);
+    const window = early.some((m) => m.failed) ? early : requests.filter((m) => m.to === nodeId);
+    return window.some((m) => m.failed) && !window.some((m) => !m.failed && !m.async);
+  });
 }
 function selectorText(selector) {
   if ("node" in selector) return selector.node;
   if ("tech" in selector) return `[${selector.tech}]`;
+  if ("anyOf" in selector) return selector.anyOf.map(selectorText).join(" or ");
+  if ("consistency" in selector) return `any ${selector.consistency} store`;
   return `any ${selector.kind}`;
 }
 function selectNodes(diagram, selector) {
-  return diagram.nodes.filter((n) => n.kind === "component" && matches(n, selector));
+  return diagram.nodes.filter((n) => n.kind === "component" && matches(n, selector, diagram));
 }
-function matches(node, selector) {
+function matches(node, selector, diagram) {
   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;
+  if ("anyOf" in selector) return selector.anyOf.some((s) => matches(node, s, diagram));
+  if ("consistency" in selector) {
+    const override = diagram?.capacity?.find((o) => o.node === node.id);
+    return profileOf(node, override).consistency === selector.consistency;
+  }
+  return kindMatches(kindOf(node), selector.kind);
 }
 function techOf(node) {
   return node && !node.implicit ? node.techStack : void 0;
@@ -27509,51 +27880,13 @@ 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 SECONDS_PER_MONTH = 2592e3;
+var BYTES_PER_MB = 1e6;
+var BYTES_PER_GB = 1e9;
 var PERCENTILE_FACTORS = { 50: 1, 90: 1.6, 95: 2, 99: 3, 99.9: 5 };
 var PERCENTILE_KEYS = { 50: "p50", 90: "p90", 95: "p95", 99: "p99", 99.9: "p999" };
 var PERCENTILES2 = Object.keys(PERCENTILE_KEYS).map(Number);
@@ -27589,20 +27922,73 @@ function resolveTraffic(diagram, warnings = []) {
   }
   return result;
 }
-function computeLoad(diagram, traffic) {
-  const load = /* @__PURE__ */ new Map();
+var multiplierOf = (step) => step.multiplier !== void 0 && step.multiplier > 0 ? step.multiplier : 1;
+function forEachStepRate(diagram, traffic, visit) {
   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);
+      if (rate > 0) for (const step of s.steps) visit(step, rate);
     });
   }
+}
+function computeLoad(diagram, traffic) {
+  const load = /* @__PURE__ */ new Map();
+  const access = accessIn(diagram);
+  forEachStepRate(diagram, traffic, (step, rate) => {
+    const entry = load.get(step.toServiceId) ?? { read: 0, write: 0 };
+    entry[access(step)] += rate * multiplierOf(step);
+    load.set(step.toServiceId, entry);
+  });
   return load;
 }
+var egressSource = (step, access) => access === "read" ? step.toServiceId : step.fromServiceId;
+function computeEgressGb(diagram, traffic) {
+  const gb = /* @__PURE__ */ new Map();
+  const access = accessIn(diagram);
+  forEachStepRate(diagram, traffic, (step, rate) => {
+    if (!step.sizeBytes || step.sizeBytes <= 0) return;
+    const source2 = egressSource(step, access(step));
+    gb.set(source2, (gb.get(source2) ?? 0) + rate * multiplierOf(step) * step.sizeBytes * SECONDS_PER_MONTH / BYTES_PER_GB);
+  });
+  return gb;
+}
+function transferMs(step, bandwidthOf) {
+  if (!step.sizeBytes || step.sizeBytes <= 0) return 0;
+  const mbps = Math.min(bandwidthOf(step.fromServiceId), bandwidthOf(step.toServiceId));
+  return mbps > 0 && Number.isFinite(mbps) ? step.sizeBytes / BYTES_PER_MB / mbps * 1e3 : 0;
+}
 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 usageOf(p, replicas, readLoadRps, writeLoadRps) {
+  const { readRps: readCapacityRps, writeRps: writeCapacityRps } = capacityOf(p, replicas);
+  const readUtilization = utilizationOf(readLoadRps, readCapacityRps);
+  const writeUtilization = utilizationOf(writeLoadRps, writeCapacityRps);
+  const utilization = combinedUtilization(p, readUtilization, writeUtilization);
+  const loadRps = readLoadRps + writeLoadRps;
+  return {
+    loadRps,
+    capacityRps: readCapacityRps === writeCapacityRps || utilization === 0 ? readCapacityRps : loadRps / utilization,
+    utilization,
+    saturated: utilization >= 1,
+    readLoadRps,
+    writeLoadRps,
+    readCapacityRps,
+    writeCapacityRps,
+    readUtilization,
+    writeUtilization,
+    writeScaling: p.writeScaling
+  };
+}
+function usageText(n) {
+  const part = (load, capacity, rho) => `${formatRps(load)} of ${formatRps(capacity)}, ${formatPercent(rho)}`;
+  if (n.writeScaling === "shards" && n.writeLoadRps > 0) {
+    return `reads ${part(n.readLoadRps, n.readCapacityRps, n.readUtilization)}; writes ${part(n.writeLoadRps, n.writeCapacityRps, n.writeUtilization)}`;
+  }
+  return part(n.loadRps, n.capacityRps, n.utilization);
+}
+var writeBound = (n) => n.writeScaling === "shards" && n.writeUtilization >= n.readUtilization && n.writeLoadRps > 0;
 function useCasePercentile(scenarios, q) {
   const tail = 1 - q / 100 - 1e-9;
   const heavy = scenarios.filter((s) => s.share >= tail && s.share > 0);
@@ -27621,49 +28007,57 @@ function mainScenarioIndex(shares) {
   });
   return best;
 }
+function profilesOf(diagram, warnings = []) {
+  const nodes = components(diagram);
+  const ids = new Set(nodes.map((n) => n.id));
+  const overrides = new Map((diagram.capacity ?? []).map((o) => [o.node, o]));
+  for (const o of diagram.capacity ?? []) if (!ids.has(o.node)) warnings.push(`Capacity for unknown node '${o.node}' is ignored`);
+  return new Map(nodes.map((n) => [n.id, profileOf(n, overrides.get(n.id))]));
+}
 function analyze(diagram, options = {}) {
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const 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 profiles = profilesOf(diagram, warnings);
   const traffic = resolveTraffic(diagram, warnings);
   const load = computeLoad(diagram, traffic);
+  const egress = computeEgressGb(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);
+    const { read, write } = load.get(n.id) ?? { read: 0, write: 0 };
+    const usage = usageOf(p, replicas, read, write);
+    const egressGbPerMonth = egress.get(n.id) ?? 0;
+    const egressUsd = egressGbPerMonth * p.egressUsdPerGb;
     return {
       id: n.id,
       kind: p.kind,
       replicas,
-      loadRps,
-      capacityRps,
-      utilization,
-      saturated: utilization >= 1,
-      latencyMs: hopLatency(p.latencyMs, utilization),
+      shards: p.shards,
+      ...usage,
+      ...p.consistency ? { consistency: p.consistency } : {},
+      latencyMs: hopLatency(p.latencyMs, usage.utilization),
       availability: replicatedAvailability(p.availability, replicas),
-      costUsd: replicas * p.costUsd,
+      costUsd: replicas * p.shards * p.costUsd + egressUsd,
+      egressGbPerMonth,
+      egressUsd,
       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;
+  const bandwidthOf = (id) => profiles.get(id)?.bandwidthMBps ?? Infinity;
   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.`);
+    const usage = usageText(n);
+    if (n.saturated) warnings.push(`'${n.id}' is saturated: ${usage}. ${writeBound(n) ? "Add shards for writes" : "Add replicas"} or take load off it.`);
     else if (n.utilization > HOT) warnings.push(`'${n.id}' runs hot: ${usage}.`);
   }
   const 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))),
+        (sum, part) => sum + Math.max(...part.map((hop) => hop.failed ? timeoutMs : hopMs(hop.target) + transferMs(hop.step, bandwidthOf))),
         0
       );
       return { id: s.id, name: s.name, share: shares[i] ?? 0, meanMs, percentiles: percentilesOf(meanMs) };
@@ -27678,6 +28072,7 @@ function analyze(diagram, options = {}) {
     nodes: nodeResults,
     useCases,
     totalCostUsd: nodeResults.reduce((sum, n) => sum + n.costUsd, 0),
+    totalEgressUsd: nodeResults.reduce((sum, n) => sum + n.egressUsd, 0),
     singlePointsOfFailure: singlePointsOfFailure(diagram),
     warnings
   };
@@ -27702,7 +28097,7 @@ function useCaseAvailability(useCase, shares, availabilityOf) {
   }
   return result;
 }
-var DEPLOYED = (kind) => kind !== "client" && kind !== "other" && kind !== "external";
+var DEPLOYED = (kind) => kind !== "client" && kind !== "other" && kind !== "external" && kind !== "dns";
 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);
 }
@@ -27711,20 +28106,20 @@ function singlePointsOfFailure(diagram) {
 var pass = (message) => ({ passed: true, message });
 var fail = (message, hint) => ({ passed: false, message, hint });
 function runTests(diagram, analysis = analyze(diagram)) {
+  const access = accessIn(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]))
+    shares: new Map([...resolveTraffic(diagram)].map(([id, t]) => [id, t.shares])),
+    profiles: profilesOf(diagram),
+    isWrite: (step) => access(step) === "write"
   };
-  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 results = (diagram.requirements ?? []).map((r, i) => {
+    const { passed, message, hint } = requirement(run, r);
+    return { id: `req:${i + 1}`, name: requirementName(r), category: CATEGORY[r.kind], passed, message, hint, loc: r.loc };
+  });
   const names = /* @__PURE__ */ new Map();
   for (const test of diagram.tests ?? []) {
     const n = (names.get(test.name) ?? 0) + 1;
@@ -27741,10 +28136,16 @@ var CATEGORY = {
   cost: "cost"
 };
 var percentileName = (q) => PERCENTILE_KEYS[q];
+var lineOf = (loc) => `${loc.file ? `${loc.file}:` : "line "}${loc.line}`;
+function stepText(step) {
+  const arrow = step.failed ? "-x" : step.executionType === "SYNC_REQUEST_RESPONSE" ? "->" : "->>";
+  const label = requestLabel(step);
+  return `${step.fromServiceId} ${arrow} ${step.toServiceId}${label ? ` : ${label}` : ""} at ${lineOf(step.loc)}`;
+}
 function requirementName(r) {
   switch (r.kind) {
     case "latency":
-      return `${percentileName(r.percentile)} of ${r.useCase ?? "every use case"} < ${formatMs(r.maxMs)}`;
+      return `${percentileName(r.percentile)} of ${r.useCase ?? "every use case"}${r.scenario !== void 0 ? ` scenario ${r.scenario}` : ""} < ${formatMs(r.maxMs)}`;
     case "availability":
       return `availability of ${r.useCase ?? "every use case"} \u2265 ${r.minPercent}%`;
     case "durable":
@@ -27758,6 +28159,7 @@ function requirementName(r) {
 function requirement(run, r) {
   switch (r.kind) {
     case "latency":
+      if (r.useCase !== void 0 && r.scenario !== void 0) return scenarioLatency(run, r.useCase, r.scenario, r.percentile, r.maxMs);
       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);
@@ -27786,43 +28188,65 @@ function overUseCases(run, name, check, limit, anyWithoutTraffic = false) {
 }
 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');
+  return { ...fail(`No use case named "${name}"`, known.length ? `Use one of ${known.join(", ")}` : 'Add a usecase "\u2026" { \u2026 } block'), missing: `use case ${name}` };
+}
+function saturatedOn(run, ids, value, maxMs) {
+  const n = [...new Set(ids)].map((id) => run.nodes.get(id)).find((x) => !!x?.saturated);
+  if (!n) return void 0;
+  const v = value(n);
+  return { ...fail(`${v} (limit ${formatMs(maxMs)})`, saturationHint(run, n)), value: v };
 }
 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 touched = u.scenarios.flatMap((s, i) => (shares[i] ?? 0) > 0 ? s.steps.map((step) => step.toServiceId) : []);
+  const saturated = saturatedOn(run, touched, (n) => `${key} of ${u.name}: ${n.id} is saturated (${usageText(n)})`, maxMs);
+  if (saturated) return saturated;
   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 };
+  if (ms < maxMs) return { ...pass(message), value };
+  const index = Math.max(0, result.scenarios.findIndex((s) => s.percentiles[key] === ms));
+  const lead = u.scenarios.length > 1 ? `The "${u.scenarios[index].name}" path (${formatPercent(result.scenarios[index].share)} of traffic) sets ${key}. ` : "";
+  return { ...fail(message, lead + latencyHint(run, u, u.scenarios[index])), value };
+}
+function scenarioLatency(run, useCase, scenario, q, maxMs) {
+  const sc = scope(run, useCase, scenario);
+  if (isCheck(sc)) return sc;
+  const s = sc.scenarios[0];
+  const key = percentileName(q);
+  const what = `${key} of "${sc.u.name}" scenario "${s.name}"`;
+  const saturated = saturatedOn(run, s.steps.map((step) => step.toServiceId), (n) => `${what}: ${n.id} is saturated (${usageText(n)})`, maxMs);
+  if (saturated) return saturated;
+  const result = run.useCases.get(sc.u.id)?.scenarios[sc.u.scenarios.indexOf(s)];
+  const ms = result?.percentiles[key] ?? 0;
+  const message = `${what} is ${formatMs(ms)} (limit ${formatMs(maxMs)})`;
+  return ms < maxMs ? pass(message) : fail(message, latencyHint(run, sc.u, s));
 }
 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)`;
+  const label = nodeLabel(run.diagram, n.id);
+  if (writeBound(n)) {
+    const perShard = n.writeCapacityRps / n.shards;
+    const shards = Math.ceil(n.writeLoadRps / (perShard * HOT));
+    return `Writes to ${label} need ${formatRps(n.writeLoadRps)} and each primary takes ${formatRps(perShard)}; read replicas do not add write capacity. Add shards (capacity { ${n.id} shards ${shards} } keeps writes under ${formatPercent(HOT)}), move the data to a partitioned store (DynamoDB, Cassandra), or batch writes through a queue`;
+  }
+  const rho = n.writeScaling === "shards" ? n.readUtilization : n.utilization;
+  const replicas = Math.ceil(rho * n.replicas / HOT);
+  return `Add replicas to ${label}: 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}. ` : "";
+function latencyHint(run, u, scenario) {
   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.`;
+  if (!slowest) return "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.`;
+  if (slowest.failed) return `It waits ${formatMs(DEFAULT_TIMEOUT_MS)} for the failed call to ${label}; give that path a smaller share of traffic or avoid the call.`;
+  const sized = hops.find((h) => (h.step.sizeBytes ?? 0) > 0);
   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 ->>.`;
+  if (node && node.utilization > HOT) return `${label} runs at ${formatPercent(node.utilization)} and queues requests; add replicas to it.`;
+  const payload = sized ? ` Payloads add transfer time too (${stepText(sized.step)}): send fewer bytes or let the client fetch them from a CDN or storage directly.` : "";
+  return `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 ->>.${payload}`;
 }
 function availability(run, u, minPercent) {
   const result = run.useCases.get(u.id);
@@ -27835,37 +28259,53 @@ function availability(run, u, minPercent) {
   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) {
+function writeGap(run, 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";
+  const hits = requests.map((m, i) => ({ m, i })).filter(({ m }) => !m.failed && accept(m.to));
+  const writes = hits.filter(({ m }) => run.isWrite(m.step));
+  const early = writes.find(({ m, i }) => m.async && i < beforeResponse);
+  if (early) return { kind: "async", step: early.m.step };
+  const late = writes.find(({ i }) => i >= beforeResponse);
+  if (late) return { kind: "after", step: late.m.step };
+  const read = hits.find(({ m, i }) => i < beforeResponse && !m.async);
+  if (read) return { kind: "read", step: read.m.step };
+  return { kind: "none" };
 }
-var GAP_TEXT = {
-  async: "writes only asynchronously (->>)",
-  after: "writes only after responding",
-  none: "never writes"
-};
-function writesCheck(u, scenarios, accept, what) {
+function writesCheck(run, 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);
+  const gaps = success.filter((s) => !writesBeforeResponse(u, s, accept, run.isWrite));
   if (gaps.length === 0) {
     const label = success.length === 1 ? `"${u.name}"` : `Every success scenario of "${u.name}"`;
-    return pass(`${label} writes ${what} before responding`);
+    return pass(`${label} writes to ${what} before responding`);
   }
-  const details = gaps.map(({ s }) => ({ s, gap: writeGap(u, s, accept) }));
+  const details = gaps.map((s) => ({ s, gap: writeGap(run, 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);
+  const text = (s, gap) => {
+    switch (gap.kind) {
+      case "async":
+        return `${where(s)} writes to ${what} only asynchronously: ${stepText(gap.step)}`;
+      case "after":
+        return `${where(s)} writes to ${what} only after responding: ${stepText(gap.step)}`;
+      case "read":
+        return `${where(s)} only reads from ${what} before responding: ${stepText(gap.step)} is a read`;
+      case "none":
+        return `${where(s)} never writes to ${what} before responding`;
+    }
+  };
+  const message = details.map(({ s, gap }) => text(s, gap)).join("; ");
+  const hints = {
+    async: "Make the write a synchronous request (->) so it is acknowledged before the response",
+    after: "Move the write before the step that answers the entry request",
+    read: "Only writes count: start the label with a write verb (INSERT, UPDATE, PUT, SET, \u2026) or use POST, PUT, PATCH or DELETE if the step stores data",
+    none: `Add a synchronous write (->) to ${what} before the entry request is answered`
+  };
+  return fail(message, hints[details[0].gap.kind]);
 }
 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");
+  return writesCheck(run, u, u.scenarios, (id) => !!run.nodes.get(id)?.durable, "a durable store");
 }
 function survive(run, target) {
   const all = components(run.diagram);
@@ -27880,13 +28320,12 @@ function survive(run, target) {
     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) {
+      const left = usageOf(run.profiles.get(node.id), replicas - 1, n.readLoadRps, n.writeLoadRps);
+      if (left.saturated) {
         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`
+            `Losing one of ${replicas} ${node.id} replicas leaves ${formatRps(left.capacityRps)} for ${formatRps(n.loadRps)} (${formatPercent(left.utilization)})`,
+            writeBound(left) ? saturationHint(run, { ...n, ...left }) : `Add a replica to ${label} (x${replicas + 1}) so the rest carry the load`
           )
         );
       }
@@ -27911,20 +28350,34 @@ function survive(run, target) {
   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)})`;
+  const { totalCostUsd: total, totalEgressUsd: egress } = run.analysis;
+  const ofWhich = egress > 0 ? `, ${formatUsd(egress)} of it egress` : "";
+  const message = `Total cost is ${formatUsd(total)}${ofWhich} (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.`);
+  const usd = (x) => formatUsd(x).replace("/month", "");
+  const top = [...run.analysis.nodes].filter((n) => n.costUsd > 0).sort((a, b) => b.costUsd - a.costUsd).slice(0, 3).map((n) => {
+    const notes = [n.replicas > 1 ? `${n.replicas} replicas` : "", n.shards > 1 ? `${n.shards} shards` : "", n.egressUsd > 0 ? `${usd(n.egressUsd)} of it egress` : ""].filter(Boolean);
+    return `${n.id} ${formatUsd(n.costUsd)}${notes.length ? ` (${notes.join(", ")})` : ""}`;
+  });
+  const egressHint = egress > total / 2 ? " Most of it is egress: serve repeated downloads from a CDN ($0.02/GB) instead of storage ($0.09/GB), or send fewer bytes." : "";
+  return fail(message, `Biggest items: ${top.join(", ")}. Drop replicas on nodes with low utilisation or pick cheaper techs.${egressHint}`);
 }
 function flowTest(run, test) {
-  const assertions = test.assertions.map((a) => ({ ...assertion(run, a), loc: a.loc }));
-  const failed = assertions.filter((a) => !a.passed);
+  const checks = test.assertions.map((a) => ({ ...assertion(run, a), loc: a.loc }));
+  const assertions = checks.map(({ passed, message, hint, loc }) => hint === void 0 ? { passed, message, loc } : { passed, message, hint, loc });
   if (assertions.length === 0) return { passed: true, message: "No assertions to check", assertions };
+  const failed = checks.filter((a) => !a.passed);
   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 };
+  const seen = /* @__PURE__ */ new Set();
+  const reported = failed.filter((a) => {
+    const key = a.missing ?? a.message;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  return { passed: false, message: reported.map((a) => a.message).join("; "), hint: reported[0].hint, assertions };
 }
 var quote = (s) => `"${s}"`;
 function scope(run, useCase, scenario) {
@@ -27937,9 +28390,13 @@ function scope(run, useCase, scenario) {
 }
 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}"`);
+  return {
+    ...fail(`${quote(u.name)} has no scenario ${quote(scenario)}${names ? `; it has ${names}` : ""}`, `Add alt "${scenario}" { \u2026 } to "${u.name}"`),
+    missing: `scenario ${u.name} \u203A ${scenario}`
+  };
 }
 var isCheck = (x) => "passed" in x;
+var idsOf = (run, selector) => new Set(selectNodes(run.diagram, selector).map((n) => n.id));
 function assertion(run, a) {
   switch (a.kind) {
     case "calls":
@@ -27949,9 +28406,9 @@ function assertion(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));
+      const ids = idsOf(run, a.target);
       if (ids.size === 0) return noMatch(a.target);
-      return writesCheck(sc.u, sc.scenarios, (id) => ids.has(id), selectorText(a.target));
+      return writesCheck(run, sc.u, sc.scenarios, (id) => ids.has(id), selectorText(a.target));
     }
     case "responds":
       return responds(run, a);
@@ -27964,7 +28421,7 @@ function assertion(run, a) {
     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));
+      const ids = idsOf(run, a.target);
       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);
@@ -27983,6 +28440,14 @@ function assertion(run, a) {
       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}`);
     }
+    case "neverWaits":
+      return neverWaits(run, a);
+    case "after":
+      return after(run, a);
+    case "senderCalls":
+      return senderCalls(run, a);
+    case "startsAt":
+      return startsAt(run, a);
   }
 }
 function noMatch(selector) {
@@ -27992,17 +28457,18 @@ 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 ids = idsOf(run, a.target);
+  const called = (s) => s.steps.filter((step) => ids.has(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];
+    const step = called(first)[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`
+      `${multi ? quote(first.name) : sc.label} calls ${nodeLabel(run.diagram, step.toServiceId)}: ${stepText(step)}`,
+      `Take the call to ${step.toServiceId} out of ${quote(first.name)}, e.g. serve it from a cache`
     );
   }
   if (ids.size === 0) return noMatch(a.target);
@@ -28017,22 +28483,22 @@ function calls(run, a) {
 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 first = idsOf(run, a.first);
+  const then = idsOf(run, a.then);
   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));
+    const order = requestOrder(sc.u, s).requests;
+    const iy = order.findIndex((m) => then.has(m.to));
     if (iy < 0) continue;
     checked++;
-    const ix = order.findIndex((id) => first.has(id));
+    const ix = order.findIndex((m) => first.has(m.to));
     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]}`,
+        ix < 0 ? `${where}, ${order[iy].to} is called (${stepText(order[iy].step)}) but ${x} never is` : `${where}, ${order[iy].to} is called (${stepText(order[iy].step)}) before ${order[ix].to} (${stepText(order[ix].step)})`,
         `Call ${x} before the first call to ${y}`
       );
     }
@@ -28040,6 +28506,100 @@ function before(run, a) {
   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 neverWaits(run, a) {
+  const sc = scope(run, a.useCase, a.scenario);
+  if (isCheck(sc)) return sc;
+  const ids = idsOf(run, a.target);
+  const what = selectorText(a.target);
+  for (const s of sc.scenarios) {
+    const hop = criticalPath(sc.u, s).flat().find((h) => !h.async && ids.has(h.target));
+    if (hop) {
+      const where = sc.scenarios.length > 1 ? quote(s.name) : sc.label;
+      return fail(
+        `${where} waits for ${nodeLabel(run.diagram, hop.target)} before responding: ${stepText(hop.step)}${hop.failed ? " times out on the request path" : " is synchronous"}`,
+        `Send it with ->> (through a queue if it must not be lost), or move it after the line that answers the entry request`
+      );
+    }
+  }
+  const calledAtAll = sc.scenarios.some((s) => s.steps.some((step) => ids.has(step.toServiceId)));
+  return pass(`${sc.label} never waits for ${what}${calledAtAll ? "" : ` (it never calls ${what})`}`);
+}
+function after(run, a) {
+  const sc = scope(run, a.useCase, a.scenario);
+  if (isCheck(sc)) return sc;
+  const targets = idsOf(run, a.target);
+  const firsts = idsOf(run, a.after);
+  const [y, x] = [selectorText(a.target), selectorText(a.after)];
+  if (targets.size === 0) return noMatch(a.target);
+  if (firsts.size === 0) return noMatch(a.after);
+  let checked = 0;
+  for (const s of sc.scenarios) {
+    const order = requestOrder(sc.u, s).requests;
+    const ix = order.findIndex((m) => firsts.has(m.to));
+    const iy = order.map((m) => targets.has(m.to)).lastIndexOf(true);
+    if (ix < 0 || iy < 0) continue;
+    checked++;
+    if (iy < ix) {
+      const where = sc.scenarios.length > 1 || a.scenario ? `In ${quote(s.name)}` : `In ${quote(sc.u.name)}`;
+      return fail(
+        `${where}, the last call to ${y} (${stepText(order[iy].step)}) comes before the first call to ${x} (${stepText(order[ix].step)})`,
+        `Call ${y} after ${x}: move the step to ${order[iy].to} below the call to ${order[ix].to}`
+      );
+    }
+  }
+  if (checked === 0) {
+    const callsY = sc.scenarios.some((s) => s.steps.some((step) => targets.has(step.toServiceId)));
+    const callsX = sc.scenarios.some((s) => s.steps.some((step) => firsts.has(step.toServiceId)));
+    const why = !callsY && !callsX ? `calls neither ${x} nor ${y}` : !callsY ? `never calls ${y}` : !callsX ? `never calls ${x}` : `never calls ${x} and ${y} in the same scenario`;
+    return fail(`${sc.label} ${why}`, `Add a step to ${y} after the call to ${x}`);
+  }
+  return pass(`${sc.label} calls ${y} after ${x}${checked > 1 ? ` in all ${checked} scenarios that call both` : ""}`);
+}
+function senderCalls(run, a) {
+  let useCases = run.diagram.useCases;
+  if (a.useCase !== void 0) {
+    const u = findUseCase(run.diagram, a.useCase);
+    if (!u) return unknownUseCase(run, a.useCase);
+    useCases = [u];
+  }
+  const from = idsOf(run, a.from);
+  const to = idsOf(run, a.to);
+  const [x, y] = [selectorText(a.from), selectorText(a.to)];
+  const within = a.useCase !== void 0 ? ` in ${quote(useCases[0].name)}` : "";
+  for (const u of useCases) {
+    for (const s of u.scenarios) {
+      const step = s.steps.find((st) => from.has(st.fromServiceId) && to.has(st.toServiceId));
+      if (!step) continue;
+      const where = u.scenarios.length > 1 ? `${quote(u.name)} scenario ${quote(s.name)}` : quote(u.name);
+      if (a.quantifier === "some") return pass(`${x} calls ${y}${within}: ${stepText(step)} in ${where}`);
+      return fail(
+        `${x} calls ${y}${within}: ${stepText(step)} in ${where}`,
+        `Let another node make this call (e.g. the client uploads to storage with a presigned URL), or remove the step`
+      );
+    }
+  }
+  if (a.quantifier === "never") return pass(`${x} never calls ${y}${within}`);
+  if (from.size === 0) return noMatch(a.from);
+  if (to.size === 0) return noMatch(a.to);
+  return fail(`No step is sent by ${x} to ${y}${within}`, `Add a step ${[...from][0]} -> ${[...to][0]}${within}`);
+}
+function startsAt(run, a) {
+  const u = findUseCase(run.diagram, a.useCase);
+  if (!u) return unknownUseCase(run, a.useCase);
+  const ids = idsOf(run, a.target);
+  const what = selectorText(a.target);
+  if (ids.size === 0) return noMatch(a.target);
+  const entries = u.scenarios.map((s) => s.steps[0]).filter((s) => !!s);
+  if (entries.length === 0) return fail(`${quote(u.name)} has no steps`, `Start "${u.name}" with a step sent by ${what}`);
+  const wrong = entries.find((s) => !ids.has(s.fromServiceId));
+  if (wrong) {
+    return fail(
+      `${quote(u.name)} starts at ${nodeLabel(run.diagram, wrong.fromServiceId)}, not ${what}: ${stepText(wrong)}`,
+      `Make the first step of "${u.name}" a step sent by ${what}`
+    );
+  }
+  return pass(`${quote(u.name)} starts at ${nodeLabel(run.diagram, entries[0].fromServiceId)}`);
+}
 function statusMatches(status, wanted) {
   if (status === void 0) return false;
   const cls = /^([1-5])xx$/i.exec(wanted);
@@ -28054,19 +28614,18 @@ function responds(run, a) {
   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 sources = idsOf(run, from);
+  const targets = idsOf(run, to);
   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);
+  if (edge) return fail(`The connection ${edge.source} -> ${edge.target} (${lineOf(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 fail(`The step ${step.fromServiceId} -> ${step.toServiceId} in ${where} (${lineOf(step.loc)}) goes directly from ${x} to ${y}`, hint);
       }
     }
   }
@@ -28089,6 +28648,24 @@ var KEYWORDS2 = [
   { 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}' }
 ];
+var ASSERTIONS = [
+  { label: '"Use case" calls', detail: "Some scenario calls the node", snippet: '"${1:Use case}" calls ${2:node}' },
+  { label: '"Use case" never calls', detail: "No scenario calls the node", snippet: '"${1:Use case}" never calls ${2:node}' },
+  { label: '"Use case" every scenario calls', detail: "Every scenario calls the node", snippet: '"${1:Use case}" every scenario calls ${2:node}' },
+  { label: '"Use case" calls \u2026 before \u2026', detail: "The first call to one node comes before the first call to another", snippet: '"${1:Use case}" calls ${2:node} before ${3:node}' },
+  { label: '"Use case" calls \u2026 after \u2026', detail: "The last call to one node comes after the first call to another", snippet: '"${1:Use case}" calls ${2:node} after ${3:node}' },
+  { label: '"Use case" never waits for', detail: "No synchronous call to the node before the response", snippet: '"${1:Use case}" never waits for ${2:node}' },
+  { label: '"Use case" writes \u2026 before responding', detail: "A write to the node happens before the response", snippet: '"${1:Use case}" writes ${2:node} before responding' },
+  { label: '"Use case" responds', detail: "Status code or class of the entry response", snippet: '"${1:Use case}" responds ${2:2xx}' },
+  { label: '"Use case" starts at', detail: "The entry request is sent by the node", snippet: '"${1:Use case}" starts at ${2:node}' },
+  { label: '"Use case" has scenario', detail: "The use case has a scenario of this name", snippet: '"${1:Use case}" has scenario "${2:Scenario}"' },
+  { label: '"Use case" handles failure of', detail: "A scenario fails the node and still answers", snippet: '"${1:Use case}" handles failure of ${2:node}' },
+  { label: "node calls node", detail: "Some step is sent by one node to the other", snippet: "${1:node} calls ${2:node}" },
+  { label: "node never calls node", detail: "No step is sent by one node to the other", snippet: "${1:node} never calls ${2:node}" },
+  { label: 'in "Use case" node calls node', detail: "A step of the use case is sent by one node to the other", snippet: 'in "${1:Use case}" ${2:node} calls ${3:node}' },
+  { label: "no path from \u2026 to \u2026", detail: "No chain of connections links the nodes", snippet: "no path from ${1:node} to ${2:node}" },
+  { label: "node has replicas >=", detail: "Minimum replica count", snippet: "${1:node} has replicas >= ${2:2}" }
+];
 
 // src/imports.ts
 var import_node_fs3 = require("node:fs");
@@ -28135,6 +28712,10 @@ function importLinks(result) {
 }
 
 // src/simulation.ts
+function formatGb(gb) {
+  const n = (x, digits) => Number(x.toFixed(digits)).toLocaleString("en-US");
+  return gb >= 1e3 ? `${n(gb / 1e3, 1)} TB` : `${n(gb, gb < 10 ? 1 : 0)} GB`;
+}
 function testDiagnostics(diagram) {
   const out = [];
   for (const r of runTests(diagram)) {
@@ -28153,9 +28734,12 @@ function nodeSimulation(diagram, nodeId) {
   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" : "";
+  const split2 = n.readLoadRps > 0 && n.writeLoadRps > 0 ? [`Reads ${formatRps(n.readLoadRps)} of ${formatRps(n.readCapacityRps)} (${formatPercent(n.readUtilization)}) \xB7 writes ${formatRps(n.writeLoadRps)} of ${formatRps(n.writeCapacityRps)} (${formatPercent(n.writeUtilization)})`] : [];
+  const egress = n.egressGbPerMonth > 0 ? ` (${formatUsd(n.egressUsd).replace("/month", "")} of it egress, ${formatGb(n.egressGbPerMonth)})` : "";
   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` : ""}`
+    ...split2,
+    `Latency ${formatMs(n.latencyMs)} per call \xB7 availability ${formatAvailability(n.availability)} \xB7 ${formatUsd(n.costUsd)}${n.replicas > 1 ? ` for ${n.replicas} replicas` : ""}${egress}`
   ].join("  \n");
 }
 
@@ -28239,6 +28823,10 @@ function complete(analysis, pos) {
     range
   }));
   if (!atLineStart) return nodes;
+  if (inTestBlock(analysis.lines, pos.line) && !/\}/.test(before2)) {
+    const assertions = ASSERTIONS.map((a) => ({ label: a.label, kind: "keyword", detail: a.detail, snippet: a.snippet, range }));
+    return [...assertions, ...nodes];
+  }
   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,
@@ -28249,6 +28837,14 @@ function complete(analysis, pos) {
   }));
   return afterBrace ? keywords : [...keywords, ...nodes];
 }
+function inTestBlock(lines, index) {
+  for (let i = index - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (/^\s*\}/.test(line)) return false;
+    if (/\{\s*(?:#.*)?$/.test(line)) return /^\s*test\s+"/.test(line);
+  }
+  return false;
+}
 function describeNode(n) {
   return [n.name !== n.id ? n.name : "", n.techStack, n.ownerTeam ? `@${n.ownerTeam}` : ""].filter(Boolean).join(" \xB7 ");
 }
@@ -28361,12 +28957,12 @@ function quickFix(analysis, message) {
   if (updated === text) return null;
   return { title: `Add connection '${from} -> ${to}'`, edit: diffEdit(text, updated) };
 }
-function diffEdit(before2, after) {
+function diffEdit(before2, after2) {
   let start = 0;
-  while (start < before2.length && start < after.length && before2[start] === after[start]) start++;
+  while (start < before2.length && start < after2.length && before2[start] === after2[start]) start++;
   let end = 0;
-  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) };
+  while (end < before2.length - start && end < after2.length - start && before2[before2.length - 1 - end] === after2[after2.length - 1 - end]) end++;
+  return { range: { start: positionAt(before2, start), end: positionAt(before2, before2.length - end) }, newText: after2.slice(start, after2.length - end) };
 }
 function positionAt(text, offset) {
   const before2 = text.slice(0, offset).split("\n");
@@ -28375,7 +28971,7 @@ function positionAt(text, offset) {
 
 // src/server.ts
 if (process.argv.includes("--version")) {
-  console.log(true ? "0.3.0" : "dev");
+  console.log(true ? "0.5.0" : "dev");
   process.exit(0);
 }
 var connection = (0, import_node.createConnection)(import_node.ProposedFeatures.all);
@@ -28416,7 +29012,7 @@ connection.onInitialize(() => ({
     documentFormattingProvider: true,
     codeActionProvider: { codeActionKinds: [import_node.CodeActionKind.QuickFix] }
   },
-  serverInfo: { name: "proschi-language-server", version: true ? "0.3.0" : "dev" }
+  serverInfo: { name: "proschi-language-server", version: true ? "0.5.0" : "dev" }
 }));
 function validate(document) {
   const analysis = analysisOf(document);