proschi 0.3.0 → 0.5.0

package/dist/cli.cjs

@@ -2986,7 +2986,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve3.call(this, root, ref);
+      let _sch = resolve4.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -3013,7 +3013,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve3(root, ref) {
+    function resolve4(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3843,7 +3843,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve3(baseURI, relativeURI, options) {
+    function resolve4(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const {
         parsed: baseParsed,
@@ -4212,7 +4212,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve3,
+      resolve: resolve4,
       resolveComponent,
       equal,
       serialize,
@@ -11869,13 +11869,13 @@ var require_resolve_block_scalar = __commonJS({
   "node_modules/yaml/dist/compose/resolve-block-scalar.js"(exports2) {
     "use strict";
     var Scalar = require_Scalar();
-    function resolveBlockScalar(ctx, scalar, onError) {
-      const start = scalar.offset;
-      const header = parseBlockScalarHeader(scalar, ctx.options.strict, onError);
+    function resolveBlockScalar(ctx, scalar2, onError) {
+      const start = scalar2.offset;
+      const header = parseBlockScalarHeader(scalar2, ctx.options.strict, onError);
       if (!header)
         return { value: "", type: null, comment: "", range: [start, start, start] };
       const type = header.mode === ">" ? Scalar.Scalar.BLOCK_FOLDED : Scalar.Scalar.BLOCK_LITERAL;
-      const lines = scalar.source ? splitLines(scalar.source) : [];
+      const lines = scalar2.source ? splitLines(scalar2.source) : [];
       let chompStart = lines.length;
       for (let i = lines.length - 1; i >= 0; --i) {
         const content = lines[i][1];
@@ -11887,12 +11887,12 @@ var require_resolve_block_scalar = __commonJS({
       if (chompStart === 0) {
         const value2 = header.chomp === "+" && lines.length > 0 ? "\n".repeat(Math.max(1, lines.length - 1)) : "";
         let end2 = start + header.length;
-        if (scalar.source)
-          end2 += scalar.source.length;
+        if (scalar2.source)
+          end2 += scalar2.source.length;
         return { value: value2, type, comment: header.comment, range: [start, end2, end2] };
       }
-      let trimIndent = scalar.indent + header.indent;
-      let offset = scalar.offset + header.length;
+      let trimIndent = scalar2.indent + header.indent;
+      let offset = scalar2.offset + header.length;
       let contentStart = 0;
       for (let i = 0; i < chompStart; ++i) {
         const [indent2, content] = lines[i];
@@ -11970,7 +11970,7 @@ var require_resolve_block_scalar = __commonJS({
         default:
           value += "\n";
       }
-      const end = start + header.length + scalar.source.length;
+      const end = start + header.length + scalar2.source.length;
       return { value, type, comment: header.comment, range: [start, end, end] };
     }
     function parseBlockScalarHeader({ offset, props }, strict, onError) {
@@ -12053,8 +12053,8 @@ var require_resolve_flow_scalar = __commonJS({
     "use strict";
     var Scalar = require_Scalar();
     var resolveEnd = require_resolve_end();
-    function resolveFlowScalar(scalar, strict, onError) {
-      const { offset, type, source: source2, end } = scalar;
+    function resolveFlowScalar(scalar2, strict, onError) {
+      const { offset, type, source: source2, end } = scalar2;
       let _type;
       let value;
       const _onError = (rel, code, msg) => onError(offset + rel, code, msg);
@@ -12073,7 +12073,7 @@ var require_resolve_flow_scalar = __commonJS({
           break;
         /* istanbul ignore next should not happen */
         default:
-          onError(scalar, "UNEXPECTED_TOKEN", `Expected a flow scalar value, but found: ${type}`);
+          onError(scalar2, "UNEXPECTED_TOKEN", `Expected a flow scalar value, but found: ${type}`);
           return {
             value: "",
             type: null,
@@ -12288,26 +12288,26 @@ var require_compose_scalar = __commonJS({
         tag = findScalarTagByTest(ctx, value, token, onError);
       else
         tag = ctx.schema[identity.SCALAR];
-      let scalar;
+      let scalar2;
       try {
         const res = tag.resolve(value, (msg) => onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg), ctx.options);
-        scalar = identity.isScalar(res) ? res : new Scalar.Scalar(res);
+        scalar2 = identity.isScalar(res) ? res : new Scalar.Scalar(res);
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
         onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg);
-        scalar = new Scalar.Scalar(value);
+        scalar2 = new Scalar.Scalar(value);
       }
-      scalar.range = range;
-      scalar.source = value;
+      scalar2.range = range;
+      scalar2.source = value;
       if (type)
-        scalar.type = type;
+        scalar2.type = type;
       if (tagName)
-        scalar.tag = tagName;
+        scalar2.tag = tagName;
       if (tag.format)
-        scalar.format = tag.format;
+        scalar2.format = tag.format;
       if (comment)
-        scalar.comment = comment;
-      return scalar;
+        scalar2.comment = comment;
+      return scalar2;
     }
     function findScalarTagByName(schema, value, tagName, tagToken, onError) {
       if (tagName === "!")
@@ -13464,9 +13464,9 @@ var require_lexer = __commonJS({
         }
       }
       *parseQuotedScalar() {
-        const quote2 = this.charAt(0);
-        let end = this.buffer.indexOf(quote2, this.pos + 1);
-        if (quote2 === "'") {
+        const quote3 = this.charAt(0);
+        let end = this.buffer.indexOf(quote3, this.pos + 1);
+        if (quote3 === "'") {
           while (end !== -1 && this.buffer[end + 1] === "'")
             end = this.buffer.indexOf("'", end + 2);
         } else {
@@ -14135,37 +14135,37 @@ var require_parser = __commonJS({
           };
         }
       }
-      *scalar(scalar) {
+      *scalar(scalar2) {
         if (this.type === "map-value-ind") {
           const prev = getPrevProps(this.peek(2));
           const start = getFirstKeyStartProps(prev);
           let sep;
-          if (scalar.end) {
-            sep = scalar.end;
+          if (scalar2.end) {
+            sep = scalar2.end;
             sep.push(this.sourceToken);
-            delete scalar.end;
+            delete scalar2.end;
           } else
             sep = [this.sourceToken];
           const map = {
             type: "block-map",
-            offset: scalar.offset,
-            indent: scalar.indent,
-            items: [{ start, key: scalar, sep }]
+            offset: scalar2.offset,
+            indent: scalar2.indent,
+            items: [{ start, key: scalar2, sep }]
           };
           this.onKeyLine = true;
           this.stack[this.stack.length - 1] = map;
         } else
-          yield* this.lineEnd(scalar);
+          yield* this.lineEnd(scalar2);
       }
-      *blockScalar(scalar) {
+      *blockScalar(scalar2) {
         switch (this.type) {
           case "space":
           case "comment":
           case "newline":
-            scalar.props.push(this.sourceToken);
+            scalar2.props.push(this.sourceToken);
             return;
           case "scalar":
-            scalar.source = this.source;
+            scalar2.source = this.source;
             this.atNewLine = true;
             this.indent = 0;
             if (this.onNewLine) {
@@ -14797,8 +14797,8 @@ __export(cli_exports, {
   run: () => run
 });
 module.exports = __toCommonJS(cli_exports);
-var import_node_fs5 = require("node:fs");
-var import_node_path6 = require("node:path");
+var import_node_fs6 = require("node:fs");
+var import_node_path7 = require("node:path");
 
 // src/openapi/config.ts
 var import_node_fs2 = require("node:fs");
@@ -15337,7 +15337,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 = [];
@@ -15464,15 +15464,15 @@ function readString(text, start) {
 }
 function stripTrailingComment(text) {
   let depth = 0;
-  let quote2 = null;
+  let quote3 = null;
   for (let i = 0; i < text.length; i++) {
     const ch = text[i];
-    if (quote2) {
+    if (quote3) {
       if (ch === "\\") i++;
-      else if (ch === quote2) quote2 = null;
+      else if (ch === quote3) quote3 = null;
       continue;
     }
-    if (ch === '"') quote2 = ch;
+    if (ch === '"') quote3 = 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);
@@ -15529,11 +15529,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",
@@ -15565,6 +15575,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) {
@@ -15576,11 +15592,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([
@@ -15595,9 +15611,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";
@@ -15610,10 +15684,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 }])
 );
@@ -15801,14 +15878,14 @@ var Parser = class {
     const loc = this.locOf(pathToken, line);
     const entry = { path, loc };
     this.imports.push(entry);
-    const { resolve: resolve3 } = this.options;
-    if (!resolve3) {
+    const { resolve: resolve4 } = this.options;
+    if (!resolve4) {
       this.warning(`Imports are not resolved in this context; '${path}' was not loaded`, loc);
       return;
     }
     let target;
     try {
-      target = resolve3(path, this.file ?? this.options.path);
+      target = resolve4(path, this.file ?? this.options.path);
     } catch {
       target = void 0;
     }
@@ -16044,7 +16121,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 {
@@ -16054,6 +16144,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
@@ -16177,10 +16303,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)) {
@@ -16190,10 +16320,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) {
@@ -16276,8 +16420,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)) {
@@ -16288,7 +16474,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);
@@ -16298,7 +16484,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"] {` */
@@ -16483,10 +16676,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;
@@ -16527,6 +16738,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);
       }
@@ -16535,6 +16750,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);
@@ -16576,8 +16801,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;
@@ -16585,8 +16825,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) };
@@ -16596,12 +16843,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) {
@@ -16615,10 +16864,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);
@@ -16721,7 +16970,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;
@@ -16887,6 +17139,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";
@@ -17093,8 +17355,8 @@ function alignConnections(run2) {
 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();
 }
@@ -17262,6 +17524,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();
@@ -17326,9 +17686,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);
@@ -17337,23 +17697,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;
@@ -17387,51 +17758,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);
@@ -17467,20 +17800,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);
@@ -17499,49 +17885,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) };
@@ -17556,6 +17950,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
   };
@@ -17580,7 +17975,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);
 }
@@ -17589,20 +17984,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 run2 = {
     diagram,
     analysis,
     nodes: new Map(analysis.nodes.map((n) => [n.id, n])),
     useCases: new Map(analysis.useCases.map((u) => [u.id, u])),
-    shares: new Map([...resolveTraffic(diagram)].map(([id, t]) => [id, t.shares]))
+    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(run2, r),
-    loc: r.loc
-  }));
+  const results = (diagram.requirements ?? []).map((r, i) => {
+    const { passed, message, hint } = requirement(run2, r);
+    return { id: `req:${i + 1}`, name: requirementName(r), category: CATEGORY[r.kind], passed, message, hint, loc: r.loc };
+  });
   const names = /* @__PURE__ */ new Map();
   for (const test of diagram.tests ?? []) {
     const n = (names.get(test.name) ?? 0) + 1;
@@ -17619,10 +18014,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":
@@ -17636,6 +18037,7 @@ function requirementName(r) {
 function requirement(run2, r) {
   switch (r.kind) {
     case "latency":
+      if (r.useCase !== void 0 && r.scenario !== void 0) return scenarioLatency(run2, r.useCase, r.scenario, r.percentile, r.maxMs);
       return overUseCases(run2, r.useCase, (u) => latency(run2, u, r.percentile, r.maxMs), `(limit ${formatMs(r.maxMs)})`);
     case "availability":
       return overUseCases(run2, r.useCase, (u) => availability(run2, u, r.minPercent), `(limit ${r.minPercent}%)`, true);
@@ -17664,43 +18066,65 @@ function overUseCases(run2, name, check, limit, anyWithoutTraffic = false) {
 }
 function unknownUseCase(run2, name) {
   const known = run2.diagram.useCases.map((u) => `"${u.name}"`);
-  return fail(`No use case named "${name}"`, known.length ? `Use one of ${known.join(", ")}` : 'Add a usecase "\u2026" { \u2026 } block');
+  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(run2, ids, value, maxMs) {
+  const n = [...new Set(ids)].map((id) => run2.nodes.get(id)).find((x) => !!x?.saturated);
+  if (!n) return void 0;
+  const v = value(n);
+  return { ...fail(`${v} (limit ${formatMs(maxMs)})`, saturationHint(run2, n)), value: v };
 }
 function latency(run2, u, q, maxMs) {
   const result = run2.useCases.get(u.id);
   const key = percentileName(q);
   const shares = run2.shares.get(u.id) ?? [];
-  const touched = new Set(u.scenarios.flatMap((s, i) => (shares[i] ?? 0) > 0 ? s.steps.map((step) => step.toServiceId) : []));
-  const saturated = [...touched].map((id) => run2.nodes.get(id)).filter((n) => !!n?.saturated);
-  if (saturated.length) {
-    const n = saturated[0];
-    const usage = `${formatRps(n.loadRps)} of ${formatRps(n.capacityRps)}, ${formatPercent(n.utilization)}`;
-    const value2 = `${key} of ${u.name}: ${n.id} is saturated (${usage})`;
-    return { ...fail(`${value2} (limit ${formatMs(maxMs)})`, saturationHint(run2, n)), value: value2 };
-  }
+  const touched = u.scenarios.flatMap((s, i) => (shares[i] ?? 0) > 0 ? s.steps.map((step) => step.toServiceId) : []);
+  const saturated = saturatedOn(run2, 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(run2, 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(run2, u, u.scenarios[index])), value };
+}
+function scenarioLatency(run2, useCase, scenario, q, maxMs) {
+  const sc = scope(run2, 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(run2, s.steps.map((step) => step.toServiceId), (n) => `${what}: ${n.id} is saturated (${usageText(n)})`, maxMs);
+  if (saturated) return saturated;
+  const result = run2.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(run2, sc.u, s));
 }
 function saturationHint(run2, n) {
-  const perReplica = n.capacityRps / n.replicas;
-  const replicas = Math.ceil(n.loadRps / (perReplica * HOT));
-  return `Add replicas to ${nodeLabel(run2.diagram, n.id)}: x${replicas} keeps it under ${formatPercent(HOT)}, or take load off it (a cache in front, or async work)`;
+  const label = nodeLabel(run2.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(run2, u, result, key, ms) {
-  const index = result.scenarios.findIndex((s) => s.percentiles[key] === ms);
-  const scenario = u.scenarios[Math.max(0, index)];
-  const lead = u.scenarios.length > 1 ? `The "${scenario.name}" path (${formatPercent(result.scenarios[Math.max(0, index)].share)} of traffic) sets ${key}. ` : "";
+function latencyHint(run2, u, scenario) {
   const hops = criticalPath(u, scenario).flat();
   const cost2 = (h) => h.failed ? DEFAULT_TIMEOUT_MS : run2.nodes.get(h.target)?.latencyMs ?? 0;
   const 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(run2.diagram, slowest.target);
-  if (slowest.failed) return `${lead}It waits ${formatMs(DEFAULT_TIMEOUT_MS)} for the failed call to ${label}; give that path a smaller share of traffic or avoid the call.`;
+  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 = run2.nodes.get(slowest.target);
-  if (node && node.utilization > HOT) return `${lead}${label} runs at ${formatPercent(node.utilization)} and queues requests; add replicas to it.`;
-  return `${lead}Its slowest hop is ${label} at ${formatMs(cost2(slowest))}: put a cache in front of it, run independent calls in par, or move work off the request path with ->>.`;
+  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(run2, u, minPercent) {
   const result = run2.useCases.get(u.id);
@@ -17713,37 +18137,53 @@ function availability(run2, u, minPercent) {
   const hint = weakest ? `The weakest link is ${nodeLabel(run2.diagram, weakest.id)} at ${formatAvailability(weakest.availability)}: add a replica (x${weakest.replicas + 1}) or a fallback scenario that calls it with -x and still completes` : "Add replicas to the nodes on the main path, or fallback scenarios that complete without them";
   return { ...fail(message, hint), value };
 }
-function writeGap(u, s, accept) {
+function writeGap(run2, 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 }) => run2.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(run2, 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, run2.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(run2, 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(run2, name) {
   const u = findUseCase(run2.diagram, name);
   if (!u) return unknownUseCase(run2, name);
-  return writesCheck(u, u.scenarios, (id) => !!run2.nodes.get(id)?.durable, "to a durable store");
+  return writesCheck(run2, u, u.scenarios, (id) => !!run2.nodes.get(id)?.durable, "a durable store");
 }
 function survive(run2, target) {
   const all = components(run2.diagram);
@@ -17758,13 +18198,12 @@ function survive(run2, target) {
     const label = nodeLabel(run2.diagram, node.id);
     const replicas = replicasOf(node);
     if (replicas >= 2) {
-      const left = n.capacityRps / replicas * (replicas - 1);
-      const rho = n.loadRps / left;
-      if (rho >= 1) {
+      const left = usageOf(run2.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(run2, { ...n, ...left }) : `Add a replica to ${label} (x${replicas + 1}) so the rest carry the load`
           )
         );
       }
@@ -17789,20 +18228,34 @@ function survive(run2, target) {
   return fail(`${failures[0].message}${more}`, failures[0].hint);
 }
 function cost(run2, max) {
-  const total = run2.analysis.totalCostUsd;
-  const message = `Total cost is ${formatUsd(total)} (limit ${formatUsd(max)})`;
+  const { totalCostUsd: total, totalEgressUsd: egress } = run2.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 = [...run2.analysis.nodes].filter((n) => n.costUsd > 0).sort((a, b) => b.costUsd - a.costUsd).slice(0, 3).map((n) => `${n.id} ${formatUsd(n.costUsd)}${n.replicas > 1 ? ` (${n.replicas} replicas)` : ""}`);
-  return fail(message, `Biggest items: ${top.join(", ")}. Drop replicas on nodes with low utilisation or pick cheaper techs.`);
+  const usd = (x) => formatUsd(x).replace("/month", "");
+  const top = [...run2.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(run2, test) {
-  const assertions = test.assertions.map((a) => ({ ...assertion(run2, a), loc: a.loc }));
-  const failed = assertions.filter((a) => !a.passed);
+  const checks = test.assertions.map((a) => ({ ...assertion(run2, 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(run2, useCase, scenario) {
@@ -17815,9 +18268,13 @@ function scope(run2, 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 = (run2, selector) => new Set(selectNodes(run2.diagram, selector).map((n) => n.id));
 function assertion(run2, a) {
   switch (a.kind) {
     case "calls":
@@ -17827,9 +18284,9 @@ function assertion(run2, a) {
     case "writesBeforeResponding": {
       const sc = scope(run2, a.useCase, a.scenario);
       if (isCheck(sc)) return sc;
-      const ids = new Set(selectNodes(run2.diagram, a.target).map((n) => n.id));
+      const ids = idsOf(run2, 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(run2, sc.u, sc.scenarios, (id) => ids.has(id), selectorText(a.target));
     }
     case "responds":
       return responds(run2, a);
@@ -17842,7 +18299,7 @@ function assertion(run2, a) {
     case "handlesFailure": {
       const u = findUseCase(run2.diagram, a.useCase);
       if (!u) return unknownUseCase(run2, a.useCase);
-      const ids = new Set(selectNodes(run2.diagram, a.target).map((n) => n.id));
+      const ids = idsOf(run2, 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);
@@ -17861,6 +18318,14 @@ function assertion(run2, 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(run2, a);
+    case "after":
+      return after(run2, a);
+    case "senderCalls":
+      return senderCalls(run2, a);
+    case "startsAt":
+      return startsAt(run2, a);
   }
 }
 function noMatch(selector) {
@@ -17870,17 +18335,18 @@ function calls(run2, a) {
   const sc = scope(run2, a.useCase, a.scenario);
   if (isCheck(sc)) return sc;
   const what = selectorText(a.target);
-  const ids = new Set(selectNodes(run2.diagram, a.target).map((n) => n.id));
-  const called = (s) => s.steps.filter((step) => ids.has(step.toServiceId)).map((step) => step.toServiceId);
+  const ids = idsOf(run2, 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(run2.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(run2.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);
@@ -17895,22 +18361,22 @@ function calls(run2, a) {
 function before(run2, a) {
   const sc = scope(run2, a.useCase, a.scenario);
   if (isCheck(sc)) return sc;
-  const first = new Set(selectNodes(run2.diagram, a.first).map((n) => n.id));
-  const then = new Set(selectNodes(run2.diagram, a.then).map((n) => n.id));
+  const first = idsOf(run2, a.first);
+  const then = idsOf(run2, 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}`
       );
     }
@@ -17918,6 +18384,100 @@ function before(run2, 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(run2, a) {
+  const sc = scope(run2, a.useCase, a.scenario);
+  if (isCheck(sc)) return sc;
+  const ids = idsOf(run2, 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(run2.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(run2, a) {
+  const sc = scope(run2, a.useCase, a.scenario);
+  if (isCheck(sc)) return sc;
+  const targets = idsOf(run2, a.target);
+  const firsts = idsOf(run2, 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(run2, a) {
+  let useCases = run2.diagram.useCases;
+  if (a.useCase !== void 0) {
+    const u = findUseCase(run2.diagram, a.useCase);
+    if (!u) return unknownUseCase(run2, a.useCase);
+    useCases = [u];
+  }
+  const from = idsOf(run2, a.from);
+  const to = idsOf(run2, 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(run2, a) {
+  const u = findUseCase(run2.diagram, a.useCase);
+  if (!u) return unknownUseCase(run2, a.useCase);
+  const ids = idsOf(run2, a.target);
+  const what = selectorText(a.target);
+  if (ids.size === 0) return noMatch(a.target);
+  const entries = u.scenarios.map((s) => s.steps[0]).filter((s) => !!s);
+  if (entries.length === 0) return fail(`${quote(u.name)} has no steps`, `Start "${u.name}" with a step sent by ${what}`);
+  const wrong = entries.find((s) => !ids.has(s.fromServiceId));
+  if (wrong) {
+    return fail(
+      `${quote(u.name)} starts at ${nodeLabel(run2.diagram, wrong.fromServiceId)}, not ${what}: ${stepText(wrong)}`,
+      `Make the first step of "${u.name}" a step sent by ${what}`
+    );
+  }
+  return pass(`${quote(u.name)} starts at ${nodeLabel(run2.diagram, entries[0].fromServiceId)}`);
+}
 function statusMatches(status, wanted) {
   if (status === void 0) return false;
   const cls = /^([1-5])xx$/i.exec(wanted);
@@ -17932,25 +18492,27 @@ function responds(run2, 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(run2, from, to) {
-  const sources = new Set(selectNodes(run2.diagram, from).map((n) => n.id));
-  const targets = new Set(selectNodes(run2.diagram, to).map((n) => n.id));
+  const sources = idsOf(run2, from);
+  const targets = idsOf(run2, 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 = run2.diagram.edges.find((e) => sources.has(e.source) && targets.has(e.target));
-  if (edge) return fail(`The connection ${edge.source} -> ${edge.target} (${line(edge.loc)}) goes directly from ${x} to ${y}`, hint);
+  if (edge) return fail(`The connection ${edge.source} -> ${edge.target} (${lineOf(edge.loc)}) goes directly from ${x} to ${y}`, hint);
   for (const u of run2.diagram.useCases) {
     for (const s of u.scenarios) {
       const step = s.steps.find((st) => sources.has(st.fromServiceId) && targets.has(st.toServiceId));
       if (step) {
         const where = u.scenarios.length > 1 ? `${quote(u.name)} scenario ${quote(s.name)}` : quote(u.name);
-        return fail(`The step ${step.fromServiceId} -> ${step.toServiceId} in ${where} (${line(step.loc)}) goes directly from ${x} to ${y}`, hint);
+        return fail(`The step ${step.fromServiceId} -> ${step.toServiceId} in ${where} (${lineOf(step.loc)}) goes directly from ${x} to ${y}`, hint);
       }
     }
   }
   return pass(`No connection or step goes directly from ${x} to ${y}`);
 }
 
+// ../frontend/src/hld/engine.ts
+var defaultEngine = { available: true, analyze: (d) => analyze(d), runTests: (d, a) => runTests(d, a) };
+
 // src/fmt.ts
 var FMT_USAGE = `  proschi fmt [--check] <file|dir>...`;
 var FMT_HELP = `fmt     Rewrites files in the canonical layout and lists the ones it changed.
@@ -18002,8 +18564,9 @@ var SIM_USAGE = `  proschi test [--format text|github|json] <file|dir>...
 var SIM_HELP = `test    Runs the requirements and test blocks of each file (imports are
         followed) against the simulation. Exits with 1 if any fails or a file
         has errors.
-analyze Prints the capacity table: load, utilisation, latency, availability
-        and cost per node; latency percentiles per use case and scenario.`;
+analyze Prints the capacity table: reads and writes (load of capacity and
+        utilisation), latency, availability, egress and cost per node; latency
+        percentiles per use case and scenario.`;
 function testFiles(files, load = parseFile) {
   return files.map((file) => {
     const { diagram, diagnostics } = load(file);
@@ -18111,27 +18674,38 @@ function table(rows, left = 1) {
   const widths = rows[0].map((_, c) => Math.max(...rows.map((r) => r[c].length)));
   return rows.map((r) => r.map((cell, c) => c < left ? cell.padEnd(widths[c]) : cell.padStart(widths[c])).join("  ").trimEnd());
 }
+function accessCell(load, capacity, utilization) {
+  return load > 0 ? `${formatRps(load).replace(" rps", "")}/${formatRps(capacity)} ${formatPercent(utilization)}` : "-";
+}
+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 egressCell(n) {
+  return n.egressGbPerMonth > 0 ? `${formatUsd(n.egressUsd).replace("/month", "")} (${formatGb(n.egressGbPerMonth)})` : "-";
+}
 function capacityReport(diagram, analysis, file) {
   const lines = [diagram.title ? `${diagram.title} (${file})` : file, ""];
   if ((diagram.traffic ?? []).length === 0) lines.push("No traffic { \u2026 } block: loads are zero and latencies are at idle.", "");
   const nodes = analysis.nodes.filter((n) => n.kind !== "client" && n.kind !== "other");
   lines.push(
     ...table([
-      ["Node", "Kind", "Replicas", "Load", "Capacity", "Util", "Latency", "Availability", "Cost/month"],
+      ["Node", "Kind", "Replicas", "Reads", "Writes", "Util", "Latency", "Availability", "Egress/month", "Cost/month"],
       ...nodes.map((n) => [
         n.id,
         n.kind,
-        String(n.replicas),
-        formatRps(n.loadRps),
-        formatRps(n.capacityRps),
+        n.shards > 1 ? `${n.replicas}x${n.shards} shards` : String(n.replicas),
+        accessCell(n.readLoadRps, n.readCapacityRps, n.readUtilization),
+        accessCell(n.writeLoadRps, n.writeCapacityRps, n.writeUtilization),
         `${formatPercent(n.utilization)}${n.saturated ? " SATURATED" : n.utilization > HOT ? " hot" : ""}`,
         formatMs(n.latencyMs),
         formatAvailability(n.availability),
+        egressCell(n),
         formatUsd(n.costUsd).replace("/month", "")
       ])
     ], 2),
     "",
-    `Total cost: ${formatUsd(analysis.totalCostUsd)}`,
+    `Total cost: ${formatUsd(analysis.totalCostUsd)}${analysis.totalEgressUsd > 0 ? ` (${formatUsd(analysis.totalEgressUsd)} of it egress)` : ""}`,
     ""
   );
   if (analysis.useCases.length) {
@@ -18184,14 +18758,700 @@ function checkFiles(files, extra) {
   return [...byFile].map(([file, diagnostics]) => ({ file, diagnostics: diagnostics.sort((x, y) => x.line - y.line || x.col - y.col) }));
 }
 
+// src/problem.ts
+var import_node_fs5 = require("node:fs");
+var import_node_path6 = require("node:path");
+
+// ../frontend/src/practice/frontMatter.ts
+var FrontMatterError = class extends Error {
+  /** 1-based line in the file. */
+  line;
+  constructor(message, line) {
+    super(`line ${line}: ${message}`);
+    this.name = "FrontMatterError";
+    this.line = line;
+  }
+};
+var KEY = /^([A-Za-z][A-Za-z0-9_-]*):(?:[ \t]+(.*))?$/;
+var NUMBER = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+var AMBIGUOUS = /^(?:true|false|yes|no|on|off|null|~)$/i;
+var INDICATORS = "-?:,[]{}#&*!|>'\"%@`";
+function isPlainSafe(s, inFlow = false) {
+  if (s === "" || s !== s.trim() || /[\n\r\t]/.test(s)) return false;
+  if (INDICATORS.includes(s[0]) || s.includes(": ") || s.includes(" #") || s.endsWith(":")) return false;
+  if (NUMBER.test(s) || AMBIGUOUS.test(s)) return false;
+  return !(inFlow && /[,[\]{}]/.test(s));
+}
+function scalar(text, line, inFlow) {
+  if (text.startsWith('"')) {
+    if (!/^"(?:[^"\\]|\\.)*"$/.test(text)) throw new FrontMatterError(`Unterminated or malformed double-quoted string: ${text}`, line);
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new FrontMatterError(`Invalid escape in double-quoted string: ${text}`, line);
+    }
+  }
+  if (text.startsWith("'")) {
+    if (!/^'(?:[^']|'')*'$/.test(text)) throw new FrontMatterError(`Unterminated or malformed single-quoted string: ${text}`, line);
+    return text.slice(1, -1).replace(/''/g, "'");
+  }
+  if (NUMBER.test(text)) return Number(text);
+  if (!isPlainSafe(text, inFlow)) throw new FrontMatterError(`Ambiguous value ${JSON.stringify(text)}; put it in double quotes`, line);
+  return text;
+}
+function stringItem(text, line, inFlow) {
+  const value = scalar(text, line, inFlow);
+  if (typeof value !== "string") throw new FrontMatterError(`List items must be strings; quote ${text}`, line);
+  return value;
+}
+function flowItems(inner, line) {
+  const items = [];
+  let current = "";
+  let quote3;
+  for (let i = 0; i < inner.length; i++) {
+    const c = inner[i];
+    if (quote3) {
+      current += c;
+      if (quote3 === '"' && c === "\\") current += inner[++i] ?? "";
+      else if (c === quote3) {
+        if (quote3 === "'" && inner[i + 1] === "'") current += inner[++i];
+        else quote3 = void 0;
+      }
+    } else if (c === '"' || c === "'") {
+      quote3 = c;
+      current += c;
+    } else if (c === ",") {
+      items.push(current.trim());
+      current = "";
+    } else current += c;
+  }
+  if (quote3) throw new FrontMatterError("Unterminated string in list", line);
+  if (current.trim() !== "" || items.length > 0) items.push(current.trim());
+  if (items.some((item) => item === "")) throw new FrontMatterError("Empty item in list", line);
+  return items.map((item) => stringItem(item, line, true));
+}
+function parseFrontMatter(text) {
+  const lines = text.replace(/\r\n?/g, "\n").split("\n");
+  if (lines[0] !== "---") throw new FrontMatterError('The file must start with a line "---"', 1);
+  const end = lines.indexOf("---", 1);
+  if (end < 0) throw new FrontMatterError('No closing "---" line after the front matter', 1);
+  const data = {};
+  let list;
+  for (let i = 1; i < end; i++) {
+    const raw = lines[i];
+    const line = i + 1;
+    if (raw.trim() === "" || /^\s*#/.test(raw)) continue;
+    if (/\t/.test(raw.match(/^\s*/)[0])) throw new FrontMatterError("Indent with spaces, not tabs", line);
+    const item = raw.match(/^ +- (.*)$/) ?? raw.match(/^ +-()$/);
+    if (item) {
+      if (!list) throw new FrontMatterError('A list item must follow a key with no value, e.g. "hints:"', line);
+      const value2 = item[1].trim();
+      if (value2 === "") throw new FrontMatterError("Empty list item", line);
+      list.items.push(stringItem(value2, line, false));
+      continue;
+    }
+    if (/^\s/.test(raw)) throw new FrontMatterError(`Unexpected indented line: ${raw.trim()}`, line);
+    list = void 0;
+    const m = raw.match(KEY);
+    if (!m) throw new FrontMatterError(`Expected "key: value", got: ${raw}`, line);
+    const [, key, rest] = m;
+    if (Object.prototype.hasOwnProperty.call(data, key)) throw new FrontMatterError(`Duplicate key '${key}'`, line);
+    const value = (rest ?? "").trim();
+    if (value === "") {
+      list = { key, items: [] };
+      data[key] = list.items;
+    } else if (value.startsWith("[")) {
+      if (!value.endsWith("]")) throw new FrontMatterError(`A list must close on the same line: ${value}`, line);
+      data[key] = flowItems(value.slice(1, -1), line);
+    } else {
+      data[key] = scalar(value, line, false);
+    }
+  }
+  for (const [key, value] of Object.entries(data)) {
+    if (Array.isArray(value) && value.length === 0) {
+      const line = lines.findIndex((l, i) => i > 0 && i < end && l.startsWith(`${key}:`)) + 1;
+      throw new FrontMatterError(`'${key}' has no value`, line);
+    }
+  }
+  return { data, body: lines.slice(end + 1).join("\n").trim() };
+}
+
+// ../frontend/src/practice/types.ts
+var DIFFICULTIES = ["easy", "medium", "hard"];
+
+// ../frontend/src/practice/problemFiles.ts
+var PROBLEM_MD = "problem.md";
+var GIVEN = "given.proschi";
+var STARTER = "starter.proschi";
+var SOLUTION = "solution.proschi";
+var WRONG_DIR = "wrong";
+var REQUIRED = [PROBLEM_MD, GIVEN, STARTER, SOLUTION];
+var ID = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var EXPECT_FAIL = /^#\s*expect-fail:\s*(.*?)\s*$/;
+var ProblemFolderError = class extends Error {
+  folder;
+  file;
+  line;
+  /** The message without the folder and file. */
+  detail;
+  constructor(folder, message, file, line) {
+    super(`problems/${folder}: ${file ? `${file}${line ? `:${line}` : ""}: ` : ""}${message}`);
+    this.name = "ProblemFolderError";
+    this.detail = message;
+    this.folder = folder;
+    this.file = file;
+    this.line = line;
+  }
+};
+function expectFailLines(source2) {
+  const names = [];
+  for (const line of source2.split("\n")) {
+    if (!line.startsWith("#")) break;
+    const m = line.match(EXPECT_FAIL);
+    if (m) names.push(m[1]);
+  }
+  return names;
+}
+var FIELDS = ["title", "summary", "difficulty", "tags", "order", "hints"];
+function readProblemMd(id, text) {
+  const fail2 = (message, line) => {
+    throw new ProblemFolderError(id, message, PROBLEM_MD, line);
+  };
+  let data;
+  let body;
+  try {
+    ({ data, body } = parseFrontMatter(text));
+  } catch (e) {
+    if (e instanceof FrontMatterError) return fail2(e.message.replace(/^line \d+: /, ""), e.line);
+    throw e;
+  }
+  for (const key of Object.keys(data)) if (!FIELDS.includes(key)) fail2(`Unknown front matter field '${key}' (use ${FIELDS.join(", ")})`);
+  const str = (key) => {
+    const v = data[key];
+    if (typeof v !== "string" || v.trim() === "") return fail2(`'${key}' must be a non-empty string`);
+    return v;
+  };
+  const list = (key) => {
+    const v = data[key];
+    if (!Array.isArray(v) || v.length === 0) return fail2(`'${key}' must be a list with at least one item`);
+    return v;
+  };
+  const difficulty = str("difficulty");
+  if (!DIFFICULTIES.includes(difficulty)) fail2(`'difficulty' must be one of ${DIFFICULTIES.join(", ")}`);
+  const order = data.order;
+  if (order !== void 0 && typeof order !== "number") fail2("'order' must be a number");
+  if (body === "") fail2("The statement (the Markdown after the front matter) is empty");
+  return {
+    title: str("title"),
+    summary: str("summary"),
+    difficulty,
+    tags: list("tags"),
+    ...typeof order === "number" ? { order } : {},
+    statement: body,
+    hints: list("hints")
+  };
+}
+function problemFromFiles(id, files) {
+  const fail2 = (message) => {
+    throw new ProblemFolderError(id, message);
+  };
+  if (!ID.test(id)) fail2('The folder name is the problem id and must be lowercase words joined by "-", e.g. url-shortener');
+  for (const name of REQUIRED) if (files[name] === void 0) fail2(`Missing ${name}`);
+  for (const name of Object.keys(files)) {
+    const wrong2 = name.startsWith(`${WRONG_DIR}/`) ? name.slice(WRONG_DIR.length + 1) : void 0;
+    if (!REQUIRED.includes(name) && !(wrong2 && /^[a-z0-9][a-z0-9-]*\.proschi$/.test(wrong2))) {
+      fail2(`Unexpected file ${name}: a problem folder holds ${REQUIRED.join(", ")} and ${WRONG_DIR}/<name>.proschi (lowercase, digits and "-")`);
+    }
+  }
+  const meta = readProblemMd(id, files[PROBLEM_MD]);
+  const wrong = Object.keys(files).filter((name) => name.startsWith(`${WRONG_DIR}/`)).sort().map((name) => ({ name: name.slice(WRONG_DIR.length + 1, -".proschi".length), source: files[name], expectFail: expectFailLines(files[name]) }));
+  return {
+    id,
+    ...meta,
+    given: files[GIVEN],
+    starter: files[STARTER],
+    solution: files[SOLUTION],
+    ...wrong.length ? { wrong } : {}
+  };
+}
+
+// ../frontend/src/dsl/imports.ts
+function joinImportPath(fromPath, importPath) {
+  const parts = importPath.startsWith("/") || !fromPath ? [] : fromPath.split("/").slice(0, -1);
+  for (const part of importPath.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === ".." && parts.length > 0 && parts[parts.length - 1] !== "..") parts.pop();
+    else parts.push(part);
+  }
+  return parts.join("/");
+}
+function mapResolver(files) {
+  const paths = Object.keys(files);
+  return (importPath, fromPath) => {
+    const path = joinImportPath(fromPath, importPath);
+    if (Object.prototype.hasOwnProperty.call(files, path)) return { path, source: files[path] };
+    const name = path.split("/").pop();
+    const sameName = paths.filter((p) => p.split("/").pop() === name);
+    return sameName.length === 1 ? { path: sameName[0], source: files[sameName[0]] } : void 0;
+  };
+}
+
+// ../frontend/src/playground/imports.ts
+function filesResolver(files, rootPath) {
+  const resolve4 = mapResolver(files);
+  return (importPath, fromPath) => {
+    if (joinImportPath(fromPath, importPath) === rootPath) return { path: rootPath, source: "" };
+    return resolve4(importPath, fromPath);
+  };
+}
+
+// ../frontend/src/practice/workspace.ts
+var PROBLEM_FILE = "problem.proschi";
+var SOLUTION_FILE = "solution.proschi";
+var CAPACITY_MESSAGE = "capacity is set by the problem; change the design (replicas, shards, caching) instead";
+function problemResolver(problem) {
+  return filesResolver({ [PROBLEM_FILE]: problem.given }, SOLUTION_FILE);
+}
+function enforceProblemCapacity(result) {
+  const capacity = result.diagram.capacity;
+  if (!capacity?.some((c) => c.loc.file !== PROBLEM_FILE)) return result;
+  const kept = [];
+  const errors = [];
+  for (const c of capacity) {
+    if (c.loc.file === PROBLEM_FILE) {
+      kept.push(c);
+      continue;
+    }
+    const { node, loc, shards, ...rest } = c;
+    if (Object.keys(rest).length > 0) {
+      errors.push({ severity: "error", message: `${CAPACITY_MESSAGE} (only \`shards <n>\` may be set in your file)`, ...loc });
+    }
+    if (shards !== void 0) kept.push({ node, shards, loc });
+  }
+  const diagram = { ...result.diagram };
+  if (kept.length) diagram.capacity = kept;
+  else delete diagram.capacity;
+  return { ...result, diagram, diagnostics: [...result.diagnostics, ...errors] };
+}
+function parseSolution(problem, source2) {
+  return enforceProblemCapacity(parse(source2, { path: SOLUTION_FILE, resolve: problemResolver(problem) }));
+}
+function runTests2(parsed, engine) {
+  if (!engine.available) return { blocked: "no-engine", results: [], passed: 0, solved: false };
+  if (parsed.diagnostics.some((d) => d.severity === "error")) return { blocked: "errors", results: [], passed: 0, solved: false };
+  const analysis = engine.analyze(parsed.diagram);
+  const results = engine.runTests(parsed.diagram, analysis);
+  const passed = results.filter((r) => r.passed).length;
+  return { results, passed, solved: results.length > 0 && passed === results.length };
+}
+
+// ../frontend/src/practice/validate.ts
+var IMPORT_LINE = `import "${PROBLEM_FILE}"`;
+function trafficUseCases(given) {
+  return [...(given.match(/traffic\s*\{([\s\S]*?)\}/)?.[1] ?? "").matchAll(/^\s*"([^"]+)"/gm)].map((m) => m[1]);
+}
+function firstCodeLine(source2) {
+  const lines = source2.split("\n");
+  const i = lines.findIndex((l) => !l.startsWith("#"));
+  return i < 0 ? { text: "", line: lines.length } : { text: lines[i], line: i + 1 };
+}
+function validateProblem(problem, engine = defaultEngine) {
+  const violations = [];
+  const add = (file, message, line) => violations.push({ file, message, ...line ? { line } : {} });
+  const fileOf = (d, own) => d.file === PROBLEM_FILE ? GIVEN : own;
+  const report = (own, ds) => {
+    for (const d of ds) add(fileOf(d, own), `${d.severity}: ${d.message}`, d.line);
+  };
+  if (!/^## Functional requirements$/m.test(problem.statement)) add(PROBLEM_MD, 'The statement needs a "## Functional requirements" section');
+  const useCases = trafficUseCases(problem.given);
+  if (useCases.length === 0) add(GIVEN, "The given needs a traffic block naming at least one use case");
+  for (const name of useCases) {
+    if (!problem.statement.includes(`**${name}**`)) add(PROBLEM_MD, `The statement must name the use case **${name}** in bold`);
+    if (!problem.solution.includes(`usecase "${name}"`)) add(SOLUTION, `The solution must define usecase "${name}" from the traffic`);
+  }
+  const importLine = problem.given.split("\n").findIndex((l) => /^\s*import /.test(l));
+  if (importLine >= 0) add(GIVEN, "The given must not import anything", importLine + 1);
+  report(GIVEN, parse(problem.given).diagnostics.filter((d) => d.severity === "error"));
+  if (format(problem.given) !== problem.given) add(GIVEN, "Not in canonical format; run proschi fmt");
+  if (!problem.solution.startsWith(`${IMPORT_LINE}
+`)) add(SOLUTION, `Must start with ${IMPORT_LINE}`, 1);
+  const solution = parseSolution(problem, problem.solution);
+  report(SOLUTION, solution.diagnostics);
+  if (format(problem.solution) !== problem.solution) add(SOLUTION, "Not in canonical format; run proschi fmt");
+  const solutionRun = runTests2(solution, engine);
+  const testNames = new Set(solutionRun.results.map((r) => r.name));
+  if (solutionRun.blocked === "no-engine") add(SOLUTION, "No simulation to run the tests with");
+  else if (solutionRun.blocked !== "errors") {
+    if (solutionRun.results.length === 0) add(GIVEN, "The problem has no requirements or tests");
+    for (const r of solutionRun.results.filter((r2) => !r2.passed)) add(SOLUTION, `Fails "${r.name}": ${r.message}`, r.loc?.file === void 0 ? r.loc?.line : void 0);
+  }
+  if (!problem.starter.startsWith(`${IMPORT_LINE}
+`)) add(STARTER, `Must start with ${IMPORT_LINE}`, 1);
+  const starter = parseSolution(problem, problem.starter);
+  report(STARTER, starter.diagnostics.filter((d) => d.severity === "error"));
+  const starterRun = runTests2(starter, engine);
+  const starterFails = starterRun.results.filter((r) => !r.passed).map((r) => r.name);
+  if (!starterRun.blocked && starterFails.length === 0) add(STARTER, "The starter passes every test; it must leave something to solve");
+  const wrong = (problem.wrong ?? []).map((w) => {
+    const file = `${WRONG_DIR}/${w.name}.proschi`;
+    const expectFail = w.expectFail.length ? w.expectFail : expectFailLines(w.source);
+    if (expectFail.length === 0) add(file, 'Start the file with one or more "# expect-fail: <test name>" lines', 1);
+    const code = firstCodeLine(w.source);
+    if (code.text !== IMPORT_LINE) add(file, `After the comment lines the file must start with ${IMPORT_LINE}`, code.line);
+    const parsed = parseSolution(problem, w.source);
+    report(file, parsed.diagnostics.filter((d) => d.severity === "error"));
+    const run2 = runTests2(parsed, engine);
+    const failed = run2.results.filter((r) => !r.passed).map((r) => r.name);
+    const missing = [];
+    if (!run2.blocked) {
+      const lines = w.source.split("\n");
+      for (const name of expectFail) {
+        const line = lines.findIndex((l) => l.startsWith("#") && l.includes(name)) + 1 || void 0;
+        if (!testNames.has(name) && !failed.includes(name)) {
+          add(file, `No test or requirement is named "${name}" (names: ${[...testNames].map((n) => JSON.stringify(n)).join(", ")})`, line);
+          missing.push(name);
+        } else if (!failed.includes(name)) {
+          add(file, `Expected to fail "${name}", but it passes`, line);
+          missing.push(name);
+        }
+      }
+    }
+    return { name: w.name, file, expectFail, failed, missing, alsoFails: failed.filter((n) => !expectFail.includes(n)) };
+  });
+  return { id: problem.id, tests: solutionRun.results.length, starterFails, wrong, violations };
+}
+
+// src/problemTemplate.ts
+function problemTemplate(id) {
+  const title = id.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
+  return {
+    "problem.md": `---
+title: ${title}
+summary: TODO One line for the problem list and the landing page.
+difficulty: easy
+tags: [caching, todo]
+hints:
+  - TODO A nudge, e.g. what answers most reads without the database?
+  - TODO Closer, e.g. a miss reads the database, then fills the cache.
+  - TODO Nearly the answer, e.g. two of everything survives any node failure.
+---
+
+TODO A short context: what the system does and for whom.
+
+## Functional requirements
+
+- **Fetch item**: a user asks for an item by id and gets it back. Name its
+  two scenarios \`"Cache hit"\` and \`"Cache miss"\`.
+
+Use these use case and scenario names exactly: the traffic, requirements and
+tests in \`problem.proschi\` refer to them.
+
+## Scale
+
+- Fetch item: **1k rps**, 90% of them for items read recently.
+
+## Constraints
+
+- p99 of fetching an item under **100 ms**.
+- Available **99.9%** of the time.
+- Losing any single machine must not take the service down.
+- At most **$2,000 / month**.
+
+## What is given
+
+\`problem.proschi\` declares the \`user\` and holds the traffic,
+requirements and tests. Your file imports it; add the components,
+connections and the use case.
+`,
+    "given.proschi": `# TODO The problem as Proschi: the fixed nodes the solver connects to, the
+# traffic, the requirements and the tests that encode the key insight.
+title "${title}" "TODO One line"
+
+user "User" [Actor]
+
+traffic {
+  "Fetch item" 1k rps mix "Cache hit" 90%, "Cache miss" 10%
+}
+
+requirements {
+  p99 "Fetch item" < 100ms
+  availability "Fetch item" >= 99.9%
+  survive any node failure
+  cost <= 2000 usd/month
+}
+
+test "Items are read from the cache first" {
+  "Fetch item" calls any cache before any database
+  "Fetch item" scenario "Cache hit" never calls any database
+}
+`,
+    "starter.proschi": `import "problem.proschi"
+
+# TODO A small, valid start: usually one use case with its first step.
+api "Item API" [REST API]
+
+user -> api
+
+usecase "Fetch item" {
+  user -> api  : GET /items/42
+  api --> user : 200 item
+}
+`,
+    "solution.proschi": `import "problem.proschi"
+
+lb    "Load Balancer" [AWS Load Balancer] x2
+api   "Item API"      [REST API]          x2
+cache "Item Cache"    [Redis]             x2
+db    "Items DB"      [PostgreSQL]        x2
+
+user -> lb
+lb   -> api   : HTTPS
+api  -> cache : GET / SET
+api  -> db    : SELECT
+
+decision "Cache items in Redis" because "Most reads are for recent items; the cache answers them in a millisecond"
+
+usecase "Fetch item" "Return one item" {
+  user -> lb    : GET /items/42
+  lb   -> api   : GET /items/42
+  api  -> cache : GET item:42
+
+  alt "Cache hit" when "the item was read recently" {
+    cache --> api : item
+  } alt "Cache miss" when "the item is not cached" {
+    cache --> api   : nil
+    api    -> db    : SELECT item 42
+    db    --> api   : item
+    api   ->> cache : SET item:42
+  }
+  api --> lb   : 200 item
+  lb  --> user : 200 item
+}
+`,
+    "wrong/database-only.proschi": `# expect-fail: Items are read from the cache first
+# TODO A plausible wrong design (here: no cache) and the tests it must fail.
+import "problem.proschi"
+
+lb  "Load Balancer" [AWS Load Balancer] x2
+api "Item API"      [REST API]          x2
+db  "Items DB"      [PostgreSQL]        x2
+
+user -> lb
+lb   -> api : HTTPS
+api  -> db  : SELECT
+
+usecase "Fetch item" {
+  user -> lb  : GET /items/42
+  lb   -> api : GET /items/42
+  api  -> db  : SELECT item 42
+  db  --> api  : item
+  api --> lb   : 200 item
+  lb  --> user : 200 item
+}
+`
+  };
+}
+
+// src/problem.ts
+var PROBLEM_USAGE = `  proschi problem check [--format text|github|json] [dir]
+  proschi problem new <id> [--dir <problems dir>]`;
+var PROBLEM_HELP = `problem Practice problems, one folder each (docs/PRACTICE.md).
+        check validates every problem folder in dir (default: the repository's
+        frontend/src/practice/problems when run inside it): front matter, the
+        given (no errors, canonical format), the solution (no diagnostics,
+        canonical, passes every test), the starter (fails a test) and each
+        wrong/ design (fails every test its "# expect-fail:" lines name).
+        Exits with 1 on any violation.
+        new scaffolds a folder that already passes check, with TODOs.`;
+var REPO_PROBLEMS = (0, import_node_path6.join)("frontend", "src", "practice", "problems");
+function findProblemsDir(cwd = process.cwd()) {
+  for (let dir = (0, import_node_path6.resolve)(cwd); ; dir = (0, import_node_path6.dirname)(dir)) {
+    const candidate = (0, import_node_path6.join)(dir, REPO_PROBLEMS);
+    if ((0, import_node_fs5.existsSync)(candidate) && (0, import_node_fs5.statSync)(candidate).isDirectory()) return candidate;
+    if ((0, import_node_path6.dirname)(dir) === dir) return void 0;
+  }
+}
+function readProblemFolder(folder) {
+  const files = {};
+  for (const entry of (0, import_node_fs5.readdirSync)(folder, { withFileTypes: true })) {
+    if (entry.name.startsWith(".")) continue;
+    if (entry.isFile()) files[entry.name] = (0, import_node_fs5.readFileSync)((0, import_node_path6.join)(folder, entry.name), "utf8");
+    else if (entry.isDirectory()) {
+      for (const sub of (0, import_node_fs5.readdirSync)((0, import_node_path6.join)(folder, entry.name), { withFileTypes: true })) {
+        if (!sub.name.startsWith(".")) files[`${entry.name}/${sub.name}`] = sub.isFile() ? (0, import_node_fs5.readFileSync)((0, import_node_path6.join)(folder, entry.name, sub.name), "utf8") : "";
+      }
+    }
+  }
+  return files;
+}
+function checkProblems(dir) {
+  return (0, import_node_fs5.readdirSync)(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name).sort().map((id) => {
+    const folder = displayPath3((0, import_node_path6.join)(dir, id));
+    try {
+      const problem = problemFromFiles(id, readProblemFolder((0, import_node_path6.join)(dir, id)));
+      return { folder, loaded: true, ...validateProblem(problem) };
+    } catch (e) {
+      if (!(e instanceof ProblemFolderError)) throw e;
+      const violation = { file: e.file ?? ".", message: e.detail, ...e.line ? { line: e.line } : {} };
+      return { folder, loaded: false, id, tests: 0, starterFails: [], wrong: [], violations: [violation] };
+    }
+  });
+}
+var quote2 = (names) => names.map((n) => `"${n}"`).join(", ");
+var escape3 = (s) => s.replace(/%/g, "%25").replace(/\r?\n/g, "%0A");
+function formatProblemReports(dir, reports, style) {
+  if (style === "json") return JSON.stringify({ dir: displayPath3(dir), problems: reports }, null, 2);
+  const lines = [];
+  const where = (r, v) => v.file === "." ? r.folder : (0, import_node_path6.join)(r.folder, v.file);
+  for (const r of reports) {
+    if (style === "github") {
+      for (const v of r.violations) lines.push(`::error file=${where(r, v)},line=${v.line ?? 1},title=proschi problem ${r.id}::${escape3(v.message)}`);
+      continue;
+    }
+    const ok = r.violations.length === 0;
+    const wrong = r.wrong.length === 1 ? "1 wrong design" : `${r.wrong.length} wrong designs`;
+    lines.push(`${ok ? "\u2713" : "\u2717"} ${r.id}${r.loaded ? `: ${r.tests} tests, the starter fails ${r.starterFails.length}, ${wrong}` : ""}`);
+    for (const v of r.violations) lines.push(`    ${where(r, v)}${v.line ? `:${v.line}` : ""}: ${v.message}`);
+    for (const w of r.wrong) {
+      if (w.missing.length) continue;
+      lines.push(`    ${WRONG_DIR}/${w.name}: fails ${quote2(w.expectFail)}${w.alsoFails.length ? `; also fails ${quote2(w.alsoFails)}` : ""}`);
+    }
+  }
+  if (style === "text") {
+    const violations = reports.reduce((n, r) => n + r.violations.length, 0);
+    const wrong = reports.reduce((n, r) => n + r.wrong.length, 0);
+    const bad = reports.filter((r) => r.violations.length).length;
+    lines.push(
+      `${reports.length} problem${reports.length === 1 ? "" : "s"}, ${wrong} wrong design${wrong === 1 ? "" : "s"}: ${violations ? `${violations} violation(s) in ${bad} problem${bad === 1 ? "" : "s"}` : "no violations"}`
+    );
+  }
+  return lines.join("\n");
+}
+function problemCheck(args, out, err, cwd) {
+  let style = "text";
+  const paths = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--format") {
+      const value = args[++i];
+      if (value !== "text" && value !== "github" && value !== "json") {
+        err(`Unknown format '${value ?? ""}'; use text, github or json`);
+        return 2;
+      }
+      style = value;
+    } else if (arg.startsWith("-")) {
+      err(`Unknown option ${arg}
+
+Usage:
+${PROBLEM_USAGE}`);
+      return 2;
+    } else paths.push(arg);
+  }
+  if (paths.length > 1) {
+    err(`Give one problems directory
+
+Usage:
+${PROBLEM_USAGE}`);
+    return 2;
+  }
+  const dir = paths[0] ? (0, import_node_path6.resolve)(cwd, paths[0]) : findProblemsDir(cwd);
+  if (!dir) {
+    err(`Not inside the Proschi repository; give the problems directory
+
+Usage:
+${PROBLEM_USAGE}`);
+    return 2;
+  }
+  if (!(0, import_node_fs5.existsSync)(dir) || !(0, import_node_fs5.statSync)(dir).isDirectory()) {
+    err(`No such directory: ${paths[0] ?? dir}`);
+    return 2;
+  }
+  const reports = checkProblems(dir);
+  if (reports.length === 0) {
+    err(`No problem folders in ${displayPath3(dir)}`);
+    return 1;
+  }
+  const text = formatProblemReports(dir, reports, style);
+  if (text) out(text);
+  return reports.some((r) => r.violations.length > 0) ? 1 : 0;
+}
+function problemNew(args, out, err, cwd) {
+  let dirArg;
+  const ids = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--dir") {
+      dirArg = args[++i];
+      if (!dirArg) {
+        err("Expected a directory after --dir");
+        return 2;
+      }
+    } else if (arg.startsWith("-")) {
+      err(`Unknown option ${arg}
+
+Usage:
+${PROBLEM_USAGE}`);
+      return 2;
+    } else ids.push(arg);
+  }
+  if (ids.length !== 1) {
+    err(`Usage:
+${PROBLEM_USAGE}`);
+    return 2;
+  }
+  const id = ids[0];
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(id)) {
+    err(`The id '${id}' must be lowercase words joined by "-", e.g. url-shortener (it is the folder name and the URL)`);
+    return 2;
+  }
+  const dir = dirArg ? (0, import_node_path6.resolve)(cwd, dirArg) : findProblemsDir(cwd) ?? (0, import_node_path6.resolve)(cwd, "problems");
+  const folder = (0, import_node_path6.join)(dir, id);
+  if ((0, import_node_fs5.existsSync)(folder)) {
+    err(`${displayPath3(folder)} already exists`);
+    return 1;
+  }
+  const files = problemTemplate(id);
+  for (const [name, text] of Object.entries(files)) {
+    (0, import_node_fs5.mkdirSync)((0, import_node_path6.dirname)((0, import_node_path6.join)(folder, name)), { recursive: true });
+    (0, import_node_fs5.writeFileSync)((0, import_node_path6.join)(folder, name), text);
+  }
+  const shown = displayPath3(folder);
+  out(`Created ${shown}/
+  ${Object.keys(files).join("\n  ")}
+
+It already passes \`proschi problem check\`; now make it your problem:
+  1. problem.md: title, summary, difficulty, tags, hints, and the statement
+     (name every use case in bold and spell out the scenario names).
+  2. given.proschi: the fixed nodes, the traffic, the requirements and the
+     tests that encode the key insight. Capacity overrides go here only.
+  3. solution.proschi: a good answer that passes every test; starter.proschi:
+     a small valid start that fails at least one.
+  4. Calibrate: set the latency, cost and availability limits between the
+     reference design and brute-force designs, and prove it with wrong/
+     designs that start with "# expect-fail: <test name>".
+  5. Run: proschi problem check ${displayPath3(dir)}`);
+  return 0;
+}
+function runProblem(args, out, err, cwd = process.cwd()) {
+  const [sub, ...rest] = args;
+  if (sub === "check") return problemCheck(rest, out, err, cwd);
+  if (sub === "new") return problemNew(rest, out, err, cwd);
+  err(`${sub ? `Unknown problem command '${sub}'
+
+` : ""}Usage:
+${PROBLEM_USAGE}`);
+  return 2;
+}
+
 // src/cli.ts
-var VERSION = true ? "0.3.0" : "dev";
+var VERSION = true ? "0.5.0" : "dev";
 var USAGE = `Usage:
   proschi check [--strict] [--format text|github|json] [--openapi <node>=<spec>]... <file|dir>...
   proschi parse <file>
 ${RENDER_USAGE}
 ${FMT_USAGE}
 ${SIM_USAGE}
+${PROBLEM_USAGE}
   proschi --version
 
 check   Reports errors and warnings. Directories are searched for *.proschi files.
@@ -18204,19 +19464,20 @@ parse   Prints {"diagram", "diagnostics"} as JSON; the shape is described by
         schema/proschi-diagram.schema.json.
 ${RENDER_HELP}
 ${FMT_HELP}
-${SIM_HELP}`;
+${SIM_HELP}
+${PROBLEM_HELP}`;
 function collectFiles(paths) {
   const out = [];
   const walk = (dir) => {
-    for (const entry of (0, import_node_fs5.readdirSync)(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    for (const entry of (0, import_node_fs6.readdirSync)(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-      const full = (0, import_node_path6.join)(dir, entry.name);
+      const full = (0, import_node_path7.join)(dir, entry.name);
       if (entry.isDirectory()) walk(full);
       else if (entry.name.endsWith(".proschi")) out.push(full);
     }
   };
   for (const p of paths) {
-    if ((0, import_node_fs5.statSync)(p).isDirectory()) walk(p);
+    if ((0, import_node_fs6.statSync)(p).isDirectory()) walk(p);
     else out.push(p);
   }
   return out;
@@ -18264,6 +19525,7 @@ function run(argv, out = console.log, err = console.error) {
   if (command === "fmt") return runFmt(rest, collectFiles, out, err);
   if (command === "test") return runTest(rest, collectFiles, out, err);
   if (command === "analyze") return runAnalyze(rest, out, err);
+  if (command === "problem") return runProblem(rest, out, err);
   if (command === "check") {
     let strict = false;
     let style = "text";