proschi 0.11.0 → 0.13.0

package/dist/cli.cjs

@@ -11422,10 +11422,10 @@ var require_resolve_block_map = __commonJS({
       let offset = bm.offset;
       let commentEnd = null;
       for (const collItem of bm.items) {
-        const { start, key, sep, value } = collItem;
+        const { start, key, sep: sep2, value } = collItem;
         const keyProps = resolveProps.resolveProps(start, {
           indicator: "explicit-key-ind",
-          next: key ?? sep?.[0],
+          next: key ?? sep2?.[0],
           offset,
           onError,
           parentIndent: bm.indent,
@@ -11439,7 +11439,7 @@ var require_resolve_block_map = __commonJS({
             else if ("indent" in key && key.indent !== bm.indent)
               onError(offset, "BAD_INDENT", startColMsg);
           }
-          if (!keyProps.anchor && !keyProps.tag && !sep) {
+          if (!keyProps.anchor && !keyProps.tag && !sep2) {
             commentEnd = keyProps.end;
             if (keyProps.comment) {
               if (map.comment)
@@ -11463,7 +11463,7 @@ var require_resolve_block_map = __commonJS({
         ctx.atKey = false;
         if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
           onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
-        const valueProps = resolveProps.resolveProps(sep ?? [], {
+        const valueProps = resolveProps.resolveProps(sep2 ?? [], {
           indicator: "map-value-ind",
           next: value,
           offset: keyNode.range[2],
@@ -11479,7 +11479,7 @@ var require_resolve_block_map = __commonJS({
             if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024)
               onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep, null, valueProps, onError);
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep2, null, valueProps, onError);
           if (ctx.schema.compat)
             utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError);
           offset = valueNode.range[2];
@@ -11570,7 +11570,7 @@ var require_resolve_end = __commonJS({
       let comment = "";
       if (end) {
         let hasSpace = false;
-        let sep = "";
+        let sep2 = "";
         for (const token of end) {
           const { source: source2, type } = token;
           switch (type) {
@@ -11584,13 +11584,13 @@ var require_resolve_end = __commonJS({
               if (!comment)
                 comment = cb;
               else
-                comment += sep + cb;
-              sep = "";
+                comment += sep2 + cb;
+              sep2 = "";
               break;
             }
             case "newline":
               if (comment)
-                sep += source2;
+                sep2 += source2;
               hasSpace = true;
               break;
             default:
@@ -11633,18 +11633,18 @@ var require_resolve_flow_collection = __commonJS({
       let offset = fc.offset + fc.start.source.length;
       for (let i = 0; i < fc.items.length; ++i) {
         const collItem = fc.items[i];
-        const { start, key, sep, value } = collItem;
+        const { start, key, sep: sep2, value } = collItem;
         const props = resolveProps.resolveProps(start, {
           flow: fcName,
           indicator: "explicit-key-ind",
-          next: key ?? sep?.[0],
+          next: key ?? sep2?.[0],
           offset,
           onError,
           parentIndent: fc.indent,
           startOnNewline: false
         });
         if (!props.found) {
-          if (!props.anchor && !props.tag && !sep && !value) {
+          if (!props.anchor && !props.tag && !sep2 && !value) {
             if (i === 0 && props.comma)
               onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
             else if (i < fc.items.length - 1)
@@ -11698,8 +11698,8 @@ var require_resolve_flow_collection = __commonJS({
             }
           }
         }
-        if (!isMap && !sep && !props.found) {
-          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep, null, props, onError);
+        if (!isMap && !sep2 && !props.found) {
+          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep2, null, props, onError);
           coll.items.push(valueNode);
           offset = valueNode.range[2];
           if (isBlock(value))
@@ -11711,7 +11711,7 @@ var require_resolve_flow_collection = __commonJS({
           if (isBlock(key))
             onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
           ctx.atKey = false;
-          const valueProps = resolveProps.resolveProps(sep ?? [], {
+          const valueProps = resolveProps.resolveProps(sep2 ?? [], {
             flow: fcName,
             indicator: "map-value-ind",
             next: value,
@@ -11722,8 +11722,8 @@ var require_resolve_flow_collection = __commonJS({
           });
           if (valueProps.found) {
             if (!isMap && !props.found && ctx.options.strict) {
-              if (sep)
-                for (const st of sep) {
+              if (sep2)
+                for (const st of sep2) {
                   if (st === valueProps.found)
                     break;
                   if (st.type === "newline") {
@@ -11740,7 +11740,7 @@ var require_resolve_flow_collection = __commonJS({
             else
               onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep, null, valueProps, onError) : null;
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep2, null, valueProps, onError) : null;
           if (valueNode) {
             if (isBlock(value))
               onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
@@ -11920,7 +11920,7 @@ var require_resolve_block_scalar = __commonJS({
           chompStart = i + 1;
       }
       let value = "";
-      let sep = "";
+      let sep2 = "";
       let prevMoreIndented = false;
       for (let i = 0; i < contentStart; ++i)
         value += lines[i][0].slice(trimIndent) + "\n";
@@ -11937,24 +11937,24 @@ var require_resolve_block_scalar = __commonJS({
           indent2 = "";
         }
         if (type === Scalar.Scalar.BLOCK_LITERAL) {
-          value += sep + indent2.slice(trimIndent) + content;
-          sep = "\n";
+          value += sep2 + indent2.slice(trimIndent) + content;
+          sep2 = "\n";
         } else if (indent2.length > trimIndent || content[0] === "	") {
-          if (sep === " ")
-            sep = "\n";
-          else if (!prevMoreIndented && sep === "\n")
-            sep = "\n\n";
-          value += sep + indent2.slice(trimIndent) + content;
-          sep = "\n";
+          if (sep2 === " ")
+            sep2 = "\n";
+          else if (!prevMoreIndented && sep2 === "\n")
+            sep2 = "\n\n";
+          value += sep2 + indent2.slice(trimIndent) + content;
+          sep2 = "\n";
           prevMoreIndented = true;
         } else if (content === "") {
-          if (sep === "\n")
+          if (sep2 === "\n")
             value += "\n";
           else
-            sep = "\n";
+            sep2 = "\n";
         } else {
-          value += sep + content;
-          sep = " ";
+          value += sep2 + content;
+          sep2 = " ";
           prevMoreIndented = false;
         }
       }
@@ -12137,25 +12137,25 @@ var require_resolve_flow_scalar = __commonJS({
         trimBoth = /^[ \t]+|[ \t]+$/g;
       }
       let res = match[1].replace(trimEnd, "");
-      let sep = " ";
+      let sep2 = " ";
       let pos = line.lastIndex;
       while (match = line.exec(source2)) {
         const lm = match[1].replace(trimBoth, "");
         if (lm === "") {
-          if (sep === "\n")
-            res += sep;
+          if (sep2 === "\n")
+            res += sep2;
           else
-            sep = "\n";
+            sep2 = "\n";
         } else {
-          res += sep + lm;
-          sep = " ";
+          res += sep2 + lm;
+          sep2 = " ";
         }
         pos = line.lastIndex;
       }
       const last = /[ \t]*(.*)/sy;
       last.lastIndex = pos;
       match = last.exec(source2);
-      return res + sep + (match?.[1] ?? "");
+      return res + sep2 + (match?.[1] ?? "");
     }
     function doubleQuotedValue(source2, onError) {
       let res = "";
@@ -12965,14 +12965,14 @@ var require_cst_stringify = __commonJS({
         }
       }
     }
-    function stringifyItem({ start, key, sep, value }) {
+    function stringifyItem({ start, key, sep: sep2, value }) {
       let res = "";
       for (const st of start)
         res += st.source;
       if (key)
         res += stringifyToken(key);
-      if (sep)
-        for (const st of sep)
+      if (sep2)
+        for (const st of sep2)
           res += st.source;
       if (value)
         res += stringifyToken(value);
@@ -14139,18 +14139,18 @@ var require_parser = __commonJS({
         if (this.type === "map-value-ind") {
           const prev = getPrevProps(this.peek(2));
           const start = getFirstKeyStartProps(prev);
-          let sep;
+          let sep2;
           if (scalar2.end) {
-            sep = scalar2.end;
-            sep.push(this.sourceToken);
+            sep2 = scalar2.end;
+            sep2.push(this.sourceToken);
             delete scalar2.end;
           } else
-            sep = [this.sourceToken];
+            sep2 = [this.sourceToken];
           const map = {
             type: "block-map",
             offset: scalar2.offset,
             indent: scalar2.indent,
-            items: [{ start, key: scalar2, sep }]
+            items: [{ start, key: scalar2, sep: sep2 }]
           };
           this.onKeyLine = true;
           this.stack[this.stack.length - 1] = map;
@@ -14303,15 +14303,15 @@ var require_parser = __commonJS({
                 } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
                   const start2 = getFirstKeyStartProps(it.start);
                   const key = it.key;
-                  const sep = it.sep;
-                  sep.push(this.sourceToken);
+                  const sep2 = it.sep;
+                  sep2.push(this.sourceToken);
                   delete it.key;
                   delete it.sep;
                   this.stack.push({
                     type: "block-map",
                     offset: this.offset,
                     indent: this.indent,
-                    items: [{ start: start2, key, sep }]
+                    items: [{ start: start2, key, sep: sep2 }]
                   });
                 } else if (start.length > 0) {
                   it.sep = it.sep.concat(start, this.sourceToken);
@@ -14505,13 +14505,13 @@ var require_parser = __commonJS({
             const prev = getPrevProps(parent);
             const start = getFirstKeyStartProps(prev);
             fixFlowSeqItems(fc);
-            const sep = fc.end.splice(1, fc.end.length);
-            sep.push(this.sourceToken);
+            const sep2 = fc.end.splice(1, fc.end.length);
+            sep2.push(this.sourceToken);
             const map = {
               type: "block-map",
               offset: fc.offset,
               indent: fc.indent,
-              items: [{ start, key: fc, sep }]
+              items: [{ start, key: fc, sep: sep2 }]
             };
             this.onKeyLine = true;
             this.stack[this.stack.length - 1] = map;
@@ -15253,8 +15253,8 @@ __export(cli_exports, {
   run: () => run
 });
 module.exports = __toCommonJS(cli_exports);
-var import_node_fs11 = require("node:fs");
-var import_node_path11 = require("node:path");
+var import_node_fs14 = require("node:fs");
+var import_node_path13 = require("node:path");
 
 // src/openapi/config.ts
 var import_node_fs2 = require("node:fs");
@@ -16278,6 +16278,8 @@ function editDistance2(a, b) {
 var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
 var DEFAULT_TECH = "Rectangle";
 var DEFAULT_GROUP_TECH = "Logical Group";
+var SYSTEM_TECH = "Service";
+var STUB_HELP = "a rate, p99, latency or availability, e.g. capacity { 2k rps p99 150ms availability 99.95% }";
 var MAX_SCENARIOS = 32;
 var MAX_ALT_DEPTH = 16;
 var DIRECTIONS = ["down", "right", "up", "left"];
@@ -16321,7 +16323,7 @@ function unknownTechMessage(tech, kind, suggestion) {
 function parse(source2, options = {}) {
   return new Parser(source2, options).run();
 }
-var Parser = class {
+var Parser = class _Parser {
   // Per-file state, swapped while an imported file is read.
   lines;
   /** Path of the imported file being read; undefined for the root document. */
@@ -16342,7 +16344,12 @@ var Parser = class {
   /** Files being read, outermost first, to find import cycles. */
   chain;
   /** Diagnostics are sorted by file in the order the files were first read, the root first. */
-  fileOrder = /* @__PURE__ */ new Map([[void 0, 0]]);
+  fileOrder;
+  /** The file read as the root: undefined for a document, the path for a system's team file (its own scope). */
+  rootFile;
+  teamFiles;
+  systems = [];
+  systemById = /* @__PURE__ */ new Map();
   /** `a|b` for every connection, both directions; filled before use cases are built. */
   connected = /* @__PURE__ */ new Set();
   title;
@@ -16364,14 +16371,18 @@ var Parser = class {
   deferred = [];
   built = [];
   options;
-  constructor(source2, options) {
+  constructor(source2, options, scope2) {
     this.options = options;
     this.lines = source2.split("\n");
-    this.chain = [options.path];
+    this.chain = scope2 ? scope2.chain : [options.path];
+    this.teamFiles = scope2?.teamFiles ?? /* @__PURE__ */ new Map();
+    if (scope2) this.rootFile = this.file = options.path;
+    this.fileOrder = /* @__PURE__ */ new Map([[this.rootFile, 0]]);
     if (options.path !== void 0) this.included.add(options.path);
   }
   run() {
     this.parseFile();
+    this.resolvePorts();
     this.createImplicitNodes();
     this.resolveTags();
     for (const e of this.edges) this.connected.add(`${e.source}|${e.target}`).add(`${e.target}|${e.source}`);
@@ -16394,7 +16405,8 @@ var Parser = class {
       ...this.decisions.length ? { decisions: this.decisions } : {},
       ...this.tests.length ? { tests: this.tests } : {},
       ...this.legend.length ? { legend: this.legend } : {},
-      ...Object.keys(this.layout).length ? { layout: this.layout } : {}
+      ...Object.keys(this.layout).length ? { layout: this.layout } : {},
+      ...this.systems.length ? { systems: this.systems } : {}
     };
     const order = (d) => this.fileOrder.get(d.file) ?? 0;
     this.diagnostics.sort((a, b) => order(a) - order(b) || a.line - b.line || a.col - b.col);
@@ -16411,14 +16423,16 @@ var Parser = class {
       i = this.parseLine(i);
     }
     for (const frame of this.stack) {
-      const what = frame.kind === "group" ? `group '${frame.id}'` : frame.kind === "usecase" ? `usecase '${frame.useCase.name}'` : frame.kind === "alt" ? `alt '${frame.name}'` : frame.kind === "par" ? "par block" : sectionName(frame);
+      const what = frame.kind === "group" ? `group '${frame.id}'` : frame.kind === "usecase" ? `usecase '${frame.useCase.name}'` : frame.kind === "alt" ? `alt '${frame.name}'` : frame.kind === "par" ? "par block" : frame.kind === "system" ? `system '${frame.system.id}'` : frame.kind === "stub" ? `the capacity of system '${frame.system.id}'` : sectionName(frame);
       this.error(`Missing } to close ${what}`, frame.loc);
+      if (frame.kind === "system") this.finishSystem(frame);
     }
   }
   /** Parses the line at `index` and returns the index of the last line it consumed. */
   parseLine(index) {
     const line = index + 1;
-    const { tokens, diagnostics } = tokenizeLine(this.lines[index], line);
+    const { tokens: lexed, diagnostics } = tokenizeLine(this.lines[index], line);
+    const tokens = qualify(lexed);
     this.diagnostics.push(...diagnostics.map((d) => ({ ...d, ...this.fileField() })));
     if (tokens.length === 0 || diagnostics.some((d) => d.severity === "error")) return index;
     const [first, second, third] = tokens;
@@ -16439,13 +16453,17 @@ var Parser = class {
       if (first.kind === "rbrace") {
         this.stack.pop();
         if (!top.discard) this.closeSection(top);
-        if (!top.discard && this.file === void 0) this.blocks.push({ kind: top.section, start: top.loc.line, end: line });
+        if (!top.discard && this.file === this.rootFile) this.blocks.push({ kind: top.section, start: top.loc.line, end: line });
         if (second) this.error("Unexpected input after }", loc(second));
       } else if (!top.discard) {
         this.parseSectionLine(top, tokens, line);
       }
       return index;
     }
+    if (top?.kind === "system" || top?.kind === "stub") {
+      this.parseSystemLine(top, tokens, line);
+      return index;
+    }
     if (first.kind === "rbrace") {
       if (this.stack.length === 0) this.error("Unmatched }", loc(first));
       else this.closeFrame();
@@ -16467,6 +16485,11 @@ var Parser = class {
       case "group":
         this.parseGroup(tokens, line);
         break;
+      // A keyword only as `system id … {`, so a node may still be called system.
+      case "system":
+        if (second?.kind === "ident" && tokens[tokens.length - 1].kind === "lbrace") this.parseSystem(tokens, line);
+        else this.parseNode(tokens, line);
+        break;
       case "usecase":
         this.parseUseCase(tokens, line);
         break;
@@ -16521,7 +16544,7 @@ var Parser = class {
       return;
     }
     const summary = tokens[2]?.kind === "string" ? tokens[2] : void 0;
-    if (this.file === void 0) {
+    if (this.file === this.rootFile) {
       this.title = value.value;
       if (summary) this.summary = summary.value;
     }
@@ -16553,7 +16576,7 @@ var Parser = class {
       this.error("direction is only allowed at the top level or inside a group", this.locOf(keyword, line));
       return;
     }
-    if (this.file !== void 0) return;
+    if (this.file !== this.rootFile) return;
     if (this.layoutLocs.direction) {
       this.warning(`direction is already set ${this.where(this.layoutLocs.direction, loc)}; this one is ignored`, this.locOf(keyword, line));
       return;
@@ -16573,7 +16596,7 @@ var Parser = class {
       this.error("layout ordered applies to the whole diagram; write it at the top level", this.locOf(keyword, line));
       return;
     }
-    if (this.file !== void 0) return;
+    if (this.file !== this.rootFile) return;
     if (this.layoutLocs.ordered) {
       this.warning(`layout ordered is already set ${this.where(this.layoutLocs.ordered, loc)}`, this.locOf(keyword, line));
       return;
@@ -16628,16 +16651,8 @@ var Parser = class {
       this.warning(`Imports are not resolved in this context; '${path}' was not loaded`, loc);
       return;
     }
-    let target;
-    try {
-      target = resolve8(path, this.file ?? this.options.path);
-    } catch {
-      target = void 0;
-    }
-    if (!target) {
-      this.error(`Cannot find '${path}'`, loc);
-      return;
-    }
+    const target = this.resolveFile(path, loc);
+    if (!target) return;
     entry.resolved = target.path;
     const cycleStart = this.chain.indexOf(target.path);
     if (cycleStart !== -1) {
@@ -16657,6 +16672,25 @@ var Parser = class {
     this.chain.pop();
     ({ lines: this.lines, file: this.file, stack: this.stack } = outer);
   }
+  /**
+   * Loads `path` through the resolver, relative to the file being read. A
+   * resolver error named `ImportError` (outside the project root, not synced,
+   * …) is reported with its own message; anything else is "Cannot find".
+   */
+  resolveFile(path, loc) {
+    let target;
+    try {
+      target = this.options.resolve?.(path, this.file ?? this.options.path);
+    } catch (e) {
+      if (e instanceof Error && e.name === "ImportError") {
+        this.error(e.message, loc);
+        return void 0;
+      }
+      target = void 0;
+    }
+    if (!target) this.error(`Cannot find '${path}'`, loc);
+    return target;
+  }
   parseGroup(tokens, line) {
     const keyword = tokens[0];
     const top = this.top();
@@ -16716,6 +16750,273 @@ var Parser = class {
     this.addNode(group);
     this.stack.push({ kind: "group", id: idToken.value, loc });
   }
+  // ---- Systems: a team's design behind a contract (docs/design/team-systems-and-imports.md) ----
+  /** `system id ["Name"] [@team] [pos x,y] [color c] [.tag] [rank N] {` */
+  parseSystem(tokens, line) {
+    const [keyword, idToken] = tokens;
+    const top = this.top();
+    if (top && top.kind !== "group") {
+      this.error("A system is declared at the top level or inside a group", this.locOf(keyword, line));
+      this.skipSection("test", tokens, line);
+      return;
+    }
+    const loc = this.locOf(idToken, line);
+    const node = { id: idToken.value, kind: "system", name: idToken.value, type: "service", techStack: SYSTEM_TECH, parent: this.currentGroup(), loc };
+    const style = {};
+    let named = false;
+    let i = 2;
+    while (i < tokens.length - 1) {
+      const t = tokens[i];
+      const styleUsed = this.readStylePart(tokens, i, line, style, false);
+      const used2 = styleUsed === 0 ? this.readRank(tokens, i, line, node) : styleUsed;
+      if (used2 === void 0) return this.skipSection("test", tokens, line);
+      if (used2 > 0) {
+        i += used2;
+        continue;
+      }
+      if (t.kind === "string" && !named) {
+        node.name = t.value;
+        named = true;
+      } else if (t.kind === "string" && node.description === void 0) {
+        node.description = t.value;
+      } else if (t.kind === "team") {
+        node.ownerTeam = t.value;
+      } else if (isWord(t, "pos")) {
+        const [x, comma, y] = [tokens[i + 1], tokens[i + 2], tokens[i + 3]];
+        if (x?.kind !== "number" || comma?.kind !== "comma" || y?.kind !== "number") {
+          this.error("Expected pos x,y", this.locOf(t, line));
+          return this.skipSection("test", tokens, line);
+        }
+        node.position = { x: Number(x.value), y: Number(y.value) };
+        i += 3;
+      } else {
+        this.error(`Unexpected ${describe(t)} in system header; write system id "Name" @Team {`, this.locOf(t, line));
+        return this.skipSection("test", tokens, line);
+      }
+      i++;
+    }
+    this.applyStyle(node, style);
+    const system = { id: node.id, entries: [], loc };
+    if (!this.nodes.has(node.id)) {
+      this.systems.push(system);
+      this.systemById.set(system.id, system);
+    }
+    this.addNode(node);
+    this.stack.push({ kind: "system", system, useCaseLocs: /* @__PURE__ */ new Map(), loc });
+  }
+  /** A line inside `system … { }` or its multi-line `capacity { }`. */
+  parseSystemLine(frame, tokens, line) {
+    const [first, second] = tokens;
+    const { system } = frame;
+    if (first.kind === "rbrace") {
+      this.stack.pop();
+      if (frame.kind === "system") this.finishSystem(frame);
+      if (second) this.error("Unexpected input after }", this.locOf(second, line));
+      return;
+    }
+    if (frame.kind === "stub") {
+      this.readStub(system.stub, tokens, 0, tokens.length, line);
+      return;
+    }
+    if (isWord(first, "from")) {
+      if (second?.kind !== "string" || !second.value.trim()) {
+        this.error('Expected the team file, e.g. from "teams/orders.proschi"', this.locOf(second ?? first, line));
+        return;
+      }
+      if (system.from !== void 0) {
+        this.error(`System '${system.id}' already has from "${system.from}"`, this.locOf(first, line));
+        return;
+      }
+      this.expectEnd(tokens, 2, line);
+      system.from = second.value;
+      frame.fromLoc = this.locOf(second, line);
+      return;
+    }
+    if (isWord(first, "expose")) return this.parseExpose(frame, tokens, line);
+    if (isWord(first, "capacity") && second?.kind === "lbrace") {
+      const opens = tokens[tokens.length - 1].kind !== "rbrace";
+      if (system.stub) {
+        this.error(`System '${system.id}' already has a capacity`, this.locOf(first, line));
+        if (opens) this.stack.push({ kind: "section", section: "capacity", discard: true, loc: this.locOf(first, line) });
+        return;
+      }
+      const stub = { loc: this.lineLoc(tokens, line) };
+      system.stub = stub;
+      this.readStub(stub, tokens, 2, opens ? tokens.length : tokens.length - 1, line);
+      if (opens) this.stack.push({ kind: "stub", system, loc: this.locOf(first, line) });
+      return;
+    }
+    this.error('Inside a system, write from "file", expose <id> "Name" -> "Use case" or capacity { \u2026 }', this.locOf(first, line));
+    if (tokens[tokens.length - 1].kind === "lbrace") this.stack.push({ kind: "section", section: "test", discard: true, loc: this.locOf(first, line) });
+  }
+  /** `expose id ["Name"] [-> "Use case"]` */
+  parseExpose(frame, tokens, line) {
+    const [keyword, idToken] = tokens;
+    if (idToken?.kind !== "ident") {
+      this.error('Expected an entry point id, e.g. expose api "Orders API" -> "Place order"', this.locOf(idToken ?? keyword, line));
+      return;
+    }
+    const entry = { id: idToken.value, name: idToken.value, loc: this.locOf(idToken, line) };
+    let i = 2;
+    if (tokens[i]?.kind === "string") entry.name = tokens[i++].value;
+    if (tokens[i]?.kind === "arrow") {
+      const useCase = tokens[i + 1];
+      if (tokens[i].value !== "->" || useCase?.kind !== "string" && useCase?.kind !== "ident") {
+        this.error('Expected -> "Use case" after the entry point', this.locOf(useCase ?? tokens[i], line));
+        return;
+      }
+      entry.useCase = useCase.value;
+      frame.useCaseLocs.set(entry, this.locOf(useCase, line));
+      i += 2;
+    }
+    if (!this.expectEnd(tokens, i, line)) return;
+    if (frame.system.entries.some((e) => e.id === entry.id)) {
+      this.error(`System '${frame.system.id}' already exposes '${entry.id}'`, entry.loc);
+      return;
+    }
+    frame.system.entries.push(entry);
+  }
+  /** The parts of a system's `capacity { … }` in `tokens[from, to)`. */
+  readStub(stub, tokens, from, to, line) {
+    for (let i = from; i < to; ) {
+      const t = tokens[i];
+      if (t.kind === "quantity" || t.kind === "number") {
+        const rps = this.quantityOf(t, "rps", t, line);
+        if (rps === void 0) return;
+        stub.rps = rps;
+        i++;
+      } else if (isWord(t, "p99") || isWord(t, "latency") || isWord(t, "availability")) {
+        const value = this.quantityOf(i + 1 < to ? tokens[i + 1] : void 0, t.value === "availability" ? "%" : "ms", t, line);
+        if (value === void 0) return;
+        if (t.value === "p99") stub.p99Ms = value;
+        else if (t.value === "latency") stub.latencyMs = value;
+        else stub.availability = value;
+        i += 2;
+      } else {
+        this.error(`Expected ${STUB_HELP}`, this.locOf(t, line));
+        return;
+      }
+    }
+  }
+  /** At the system's `}`: loads the team file and checks the entry points against its use cases. */
+  finishSystem(frame) {
+    const { system } = frame;
+    if (system.from !== void 0) {
+      const team2 = this.loadTeam(system.from, frame.fromLoc ?? system.loc);
+      if (team2) {
+        system.resolved = team2.path;
+        system.diagram = team2.diagram;
+      }
+      if (system.stub) {
+        this.warning(`System '${system.id}' has a from file, which sets its contract; this capacity is ignored`, system.stub.loc);
+        if (team2) delete system.stub;
+      }
+    } else if (!system.stub) {
+      this.warning(`System '${system.id}' has no from "file" and no capacity { \u2026 }; it is drawn but not simulated`, system.loc);
+    }
+    const team = system.diagram;
+    if (!team) return;
+    const name = fileName(system.resolved ?? "");
+    for (const entry of system.entries) {
+      const wanted = entry.useCase;
+      if (wanted !== void 0) {
+        const u = findUseCaseIn(team, wanted);
+        if (u) entry.useCaseId = u.id;
+        else {
+          const near = team.useCases.find((x) => editDistance2(x.name.toLowerCase(), wanted.toLowerCase()) <= Math.max(1, Math.floor(wanted.length / 4)));
+          const all = team.useCases.map((x) => `"${x.name}"`).join(", ");
+          const help = near ? ` Did you mean "${near.name}"?` : all ? ` Its use cases are ${all}` : "";
+          this.error(`${name} has no use case "${wanted}".${help}`, frame.useCaseLocs.get(entry) ?? entry.loc);
+        }
+      } else if (team.useCases.length === 1) {
+        entry.useCaseId = team.useCases[0].id;
+      } else if (team.useCases.length === 0) {
+        this.error(`${name} has no use case for '${entry.id}' to enter`, entry.loc);
+      } else {
+        this.error(`Say which use case '${entry.id}' enters, e.g. expose ${entry.id} -> "${team.useCases[0].name}"`, entry.loc);
+      }
+    }
+    if (system.entries.length === 0) this.warning(`System '${system.id}' exposes no entry point; add expose <id> -> "Use case" so others can call it`, system.loc);
+  }
+  /** Parses a team file in its own scope (once per root parse), through the import resolver. */
+  loadTeam(path, loc) {
+    if (!this.options.resolve) {
+      this.warning(`Files are not resolved in this context; '${path}' was not loaded`, loc);
+      return void 0;
+    }
+    const target = this.resolveFile(path, loc);
+    if (!target) return void 0;
+    const cycleStart = this.chain.indexOf(target.path);
+    if (cycleStart !== -1) {
+      const names = [...this.chain.slice(cycleStart), target.path].map((p) => fileName(p ?? ""));
+      this.error(`System cycle: ${names.join(" \u2192 ")}`, loc);
+      return void 0;
+    }
+    let result = this.teamFiles.get(target.path);
+    if (!result) {
+      const scope2 = { chain: [...this.chain, target.path], teamFiles: this.teamFiles };
+      result = new _Parser(target.source, { path: target.path, resolve: this.options.resolve }, scope2).run();
+      this.teamFiles.set(target.path, result);
+      for (const d of result.diagnostics) {
+        if (!this.fileOrder.has(d.file)) this.fileOrder.set(d.file, this.fileOrder.size);
+        this.diagnostics.push(d);
+      }
+    }
+    return { path: target.path, diagram: result.diagram };
+  }
+  /**
+   * Resolves `orders.api` references once every file is read: the entry point
+   * `api` of system `orders`. Edges and references then name the system, with
+   * the entry point in `sourcePort` / `targetPort`. On a connection to a
+   * non-system, `b.planned` stays what it always was: `b` with a tag.
+   */
+  resolvePorts() {
+    for (const ref of this.references) {
+      const dot = ref.id.indexOf(".");
+      if (dot === -1) continue;
+      const prefix = ref.id.slice(0, dot);
+      const port = ref.id.slice(dot + 1);
+      const system = this.systemById.get(prefix);
+      if (system) {
+        if (!system.entries.some((e) => e.id === port)) this.error(this.unexposedMessage(system, port), ref.loc);
+      } else if (ref.edgeTarget) {
+        ref.edgeTarget.tag = port;
+        this.tagRefs.push({ tag: port, loc: { ...ref.loc, col: ref.loc.col + dot, length: ref.loc.length - dot }, target: ref.edgeTarget });
+      } else {
+        this.error(`'${prefix}' is not a system, so '${ref.id}' names nothing; write ${prefix}, or declare system ${prefix} { \u2026 }`, ref.loc);
+      }
+      ref.id = prefix;
+    }
+    for (const edge of this.edges) {
+      const [source2, sourcePort] = this.splitRef(edge.source);
+      const [target, targetPort] = this.splitRef(edge.target);
+      edge.source = source2;
+      edge.target = target;
+      if (sourcePort !== void 0) edge.sourcePort = sourcePort;
+      if (targetPort !== void 0) edge.targetPort = targetPort;
+    }
+  }
+  unexposedMessage(system, port) {
+    const entries2 = system.entries.map((e) => `${system.id}.${e.id}`);
+    const known = entries2.length ? `; connect to ${entries2.join(" or ")}` : "";
+    const internal = system.diagram?.nodes.some((n) => n.id === port);
+    return internal ? `'${port}' is inside system '${system.id}' but is not an entry point; only entry points are reachable from outside: add expose ${port} -> "Use case"${known}` : `System '${system.id}' has no entry point '${port}'${known}`;
+  }
+  /** `orders.api` → `['orders', 'api']` when `orders` is a system; else the id up to its dot, without a port. */
+  splitRef(id) {
+    const dot = id.indexOf(".");
+    if (dot === -1) return [id, void 0];
+    const prefix = id.slice(0, dot);
+    return [prefix, this.systemById.has(prefix) ? id.slice(dot + 1) : void 0];
+  }
+  /** A step to a whole system enters its only entry point; with several it must name one. */
+  onlyEntry(id, loc) {
+    const system = this.systemById.get(id);
+    if (!system || system.entries.length === 0) return void 0;
+    if (system.entries.length === 1) return system.entries[0].id;
+    this.errorOnce(`Say which entry point of '${id}' this step enters: ${system.entries.map((e) => `${id}.${e.id}`).join(" or ")}`, loc);
+    return void 0;
+  }
   parseUseCase(tokens, line) {
     const keyword = tokens[0];
     if (this.stack.length > 0) {
@@ -16905,7 +17206,8 @@ var Parser = class {
     const from = fromToken.value;
     const to = toToken.value;
     const arrow = arrowToken.value;
-    this.references.push({ id: from, loc: this.locOf(fromToken, line) }, { id: to, loc: this.locOf(toToken, line) });
+    const toRef = { id: to, loc: this.locOf(toToken, line) };
+    this.references.push({ id: from, loc: this.locOf(fromToken, line) }, toRef);
     const top = this.top();
     const inUseCase = top?.kind === "usecase" || top?.kind === "alt" || top?.kind === "par";
     if (tagToken && inUseCase) {
@@ -16940,6 +17242,7 @@ var Parser = class {
         edge.tag = tagToken.value;
         this.tagRefs.push({ tag: tagToken.value, loc: this.locOf(tagToken, line), target: edge });
       }
+      if (!tagToken) toRef.edgeTarget = edge;
       this.edges.push(edge);
     }
     return lastLine;
@@ -17850,7 +18153,9 @@ var Parser = class {
     for (const step of raw) {
       this.checkConnection(step);
       if (step.arrow === "-->") {
-        const request2 = [...steps2].reverse().find((s) => s.fromServiceId === step.to && s.toServiceId === step.from && !answered.has(s) && !s.failed);
+        const [respFrom] = this.splitRef(step.from);
+        const [respTo] = this.splitRef(step.to);
+        const request2 = [...steps2].reverse().find((s) => s.fromServiceId === respTo && s.toServiceId === respFrom && !answered.has(s) && !s.failed);
         if (!request2) {
           this.warning(`Response has no matching request from '${step.to}' to '${step.from}'`, step.loc);
           continue;
@@ -17869,14 +18174,17 @@ var Parser = class {
         continue;
       }
       const label = parseStepLabel(step.label);
-      const target = this.nodes.get(step.to);
+      const [from, fromPort] = this.splitRef(step.from);
+      const [to, toPort] = this.splitRef(step.to);
+      const port = toPort ?? this.onlyEntry(to, step.loc);
+      const target = this.nodes.get(to);
       const isAsync = step.arrow === "->>";
       steps2.push({
         id: `${prefix}-${steps2.length + 1}`,
         stepOrder: steps2.length,
         stepName: label.name || `${step.from} \u2192 ${step.to}`,
-        fromServiceId: step.from,
-        toServiceId: step.to,
+        fromServiceId: from,
+        toServiceId: to,
         protocol: inferProtocol(isAsync, label.method, target),
         httpMethod: label.method ?? "",
         endpoint: label.endpoint ?? "",
@@ -17892,7 +18200,9 @@ var Parser = class {
         loc: step.loc,
         ...step.multiplier !== void 0 ? { multiplier: step.multiplier } : {},
         ...step.sizeBytes !== void 0 ? { sizeBytes: step.sizeBytes } : {},
-        access: accessOf(label.method, step.label)
+        access: accessOf(label.method, step.label),
+        ...port !== void 0 ? { toPort: port } : {},
+        ...fromPort !== void 0 ? { fromPort } : {}
       });
     }
     return steps2;
@@ -17902,8 +18212,10 @@ var Parser = class {
    * Documents without any connection are use-case-only sketches; they are left alone.
    */
   checkConnection(step) {
-    if (this.edges.length === 0 || step.from === step.to || this.connected.has(`${step.from}|${step.to}`)) return;
-    const [from, to] = step.arrow === "-->" ? [step.to, step.from] : [step.from, step.to];
+    const [a] = this.splitRef(step.from);
+    const [b] = this.splitRef(step.to);
+    if (this.edges.length === 0 || a === b || this.connected.has(`${a}|${b}`)) return;
+    const [from, to] = step.arrow === "-->" ? [b, a] : [a, b];
     this.warning(`No connection between '${from}' and '${to}' in the architecture; add '${from} -> ${to}'`, step.loc);
   }
   createImplicitNodes() {
@@ -17999,6 +18311,17 @@ var Parser = class {
   error(message, loc) {
     this.diagnostics.push({ severity: "error", message, ...loc });
   }
+  /** An error for a step that every scenario sharing it would report again. */
+  errorOnce(message, loc) {
+    const key = `error
+${loc.file ?? ""}
+${loc.line}
+${loc.col}
+${message}`;
+    if (this.warned.has(key)) return;
+    this.warned.add(key);
+    this.error(message, loc);
+  }
   warning(message, loc) {
     const key = `${loc.file ?? ""}
 ${loc.line}
@@ -18034,6 +18357,23 @@ function expand(items) {
   }
   return paths;
 }
+function qualify(tokens) {
+  let out;
+  for (let i = 0; i < tokens.length; i++) {
+    const [t, next] = [tokens[i], tokens[i + 1]];
+    const joined = t.kind === "ident" && next?.kind === "tag" && next.col === t.col + t.length;
+    if (joined && (tokens[i + 2]?.kind === "arrow" || tokens[i - 1]?.kind === "arrow")) {
+      out ??= tokens.slice(0, i);
+      out.push({ ...t, value: `${t.value}.${next.value}`, length: t.length + next.length });
+      i++;
+    } else out?.push(t);
+  }
+  return out ?? tokens;
+}
+function findUseCaseIn(diagram, name) {
+  const lower = name.toLowerCase();
+  return diagram.useCases.find((u) => u.name === name) ?? diagram.useCases.find((u) => u.name.toLowerCase() === lower) ?? diagram.useCases.find((u) => u.id === name);
+}
 function isWord(token, word) {
   return token?.kind === "ident" && token.value === word;
 }
@@ -18701,13 +19041,17 @@ function openApiDiagnostics(file, diagram, overrides = {}) {
 }
 
 // src/render/usage.ts
-var RENDER_USAGE = `  proschi render [--out <dir>] [--format svg|md|html|hld-md|hld-html] <file>`;
+var RENDER_USAGE = `  proschi render [--out <dir>] [--format svg|md|html|hld-md|hld-html] [--expand <id>[,<id>\u2026]] [--focus <id>] <file>`;
 var RENDER_HELP = `render  Writes the diagram as static files into --out (default: the current
         directory). svg (default): architecture.svg and <usecase>--<scenario>.svg
         per scenario; md: <file>.md with Mermaid blocks; html: <file>.html with
         the SVGs; hld-md / hld-html: <file>.hld.md / <file>.hld.html, the
         high-level design document (overview, requirements, capacity,
         components, data model, APIs, scenarios, decisions, risks).
+        Systems are drawn as one box each, with the team's promise and what
+        they are sent against their headroom; --expand opens them in place
+        (orders.warehouse names one inside another), --focus draws one
+        system's design alone. An id that names no system exits with 2.
         Refuses (exit 1) when the document has errors.`;
 
 // src/fmt.ts
@@ -19090,6 +19434,340 @@ function formatUsd(usd) {
   return `$${Math.round(usd).toLocaleString("en-US")}/month`;
 }
 
+// ../frontend/src/sim/overlay.ts
+function flowsOf(diagram, traffic) {
+  const flows = /* @__PURE__ */ new Map();
+  for (const t of traffic) {
+    const u = findUseCase(diagram, t.useCase);
+    if (!u || t.rps <= 0) continue;
+    for (const sc of u.scenarios) {
+      const share = t.mix ? t.mix.find((m) => m.scenario === sc.name)?.share ?? 0 : sc === u.scenarios[0] ? 1 : 0;
+      if (share <= 0) continue;
+      for (const step of sc.steps) {
+        if (step.failed) continue;
+        const key = `${step.fromServiceId}>${step.toServiceId}`;
+        const f = flows.get(key) ?? { from: step.fromServiceId, to: step.toServiceId, rps: 0, async: step.executionType !== "SYNC_REQUEST_RESPONSE" };
+        f.rps += t.rps * share * (step.multiplier ?? 1);
+        flows.set(key, f);
+      }
+    }
+  }
+  return [...flows.values()];
+}
+function analysisOverlay(diagram, analysis) {
+  const nodes = {};
+  for (const n of analysis.nodes) {
+    const works = Number.isFinite(n.capacityRps) && n.kind !== "client";
+    nodes[n.id] = {
+      ...works ? { utilization: n.utilization, saturated: n.saturated } : {},
+      ...n.replicas > 1 ? { replicas: n.replicas } : {},
+      ...n.shards > 1 ? { shards: n.shards } : {}
+    };
+  }
+  return { nodes, flows: flowsOf(diagram, diagram.traffic ?? []) };
+}
+
+// ../frontend/src/sim/systems.ts
+var teamKey = (s) => s.resolved ?? s.diagram;
+var contracts = /* @__PURE__ */ new WeakMap();
+function contractOf(system, options = {}) {
+  let contract = contracts.get(system);
+  if (!contract) {
+    contract = system.diagram ? designContract(system, system.diagram, options) : stubContract(system);
+    contracts.set(system, contract);
+  }
+  return contract;
+}
+function stubContract(system) {
+  const stub = system.stub;
+  if (!stub) return { source: "none", entries: system.entries.map((e) => emptyEntry(e.id, e.name)) };
+  const rps = stub.rps ?? Infinity;
+  return {
+    source: "stub",
+    entries: system.entries.map((e) => ({
+      ...emptyEntry(e.id, e.name),
+      latency: stub.p99Ms !== void 0 ? [{ percentile: 99, maxMs: stub.p99Ms }] : [],
+      ...stub.availability !== void 0 ? { availabilityPercent: stub.availability } : {},
+      saturatesAtRps: rps,
+      hotAtRps: rps * HOT
+    }))
+  };
+}
+var emptyEntry = (entry, name) => ({ entry, name, ownRps: 0, latency: [], saturatesAtRps: Infinity, hotAtRps: Infinity });
+function designContract(system, team, options) {
+  const traffic = resolveTraffic(team);
+  const base = computeLoad(team, traffic);
+  const baseBytes = computeBytesPerSecond(team, traffic);
+  const profiles = profilesOf(team);
+  const nodes = components(team);
+  const entries2 = system.entries.map((e) => {
+    const u = team.useCases.find((x) => x.id === e.useCaseId);
+    if (!u) return emptyEntry(e.id, e.name);
+    const own = traffic.get(u.id);
+    const unit = /* @__PURE__ */ new Map([[u.id, { rps: 1, shares: own.shares }]]);
+    const delta = computeLoad(team, unit);
+    const deltaBytes = computeBytesPerSecond(team, unit);
+    const result = { ...emptyEntry(e.id, e.name), useCase: u.name, ownRps: own.rps };
+    for (const n of nodes) {
+      const d = delta.get(n.id);
+      const db = deltaBytes.get(n.id) ?? 0;
+      if (!d && !db) continue;
+      const p = profiles.get(n.id);
+      const replicas = replicasOf(n);
+      const b = base.get(n.id) ?? { read: 0, write: 0 };
+      const bb = baseBytes.get(n.id) ?? 0;
+      const u0 = usageOf(p, replicas, b.read, b.write, bb);
+      const u1 = usageOf(p, replicas, b.read + (d?.read ?? 0), b.write + (d?.write ?? 0), bb + db);
+      const sat = crossing(u0, u1, 1);
+      const hot = crossing(u0, u1, HOT);
+      if (sat < result.saturatesAtRps) {
+        result.saturatesAtRps = sat;
+        result.bottleneck = n.id;
+      }
+      if (hot < result.hotAtRps) {
+        result.hotAtRps = hot;
+        result.hotNode = n.id;
+      }
+    }
+    for (const r of team.requirements ?? []) {
+      if (r.kind !== "latency" && r.kind !== "availability") continue;
+      if (r.useCase !== void 0 && findUseCase(team, r.useCase) !== u) continue;
+      if (r.kind === "latency") result.latency.push({ percentile: r.percentile, maxMs: r.maxMs, ...r.scenario !== void 0 ? { scenario: r.scenario } : {} });
+      else result.availabilityPercent = Math.max(result.availabilityPercent ?? 0, r.minPercent);
+    }
+    return result;
+  });
+  return { source: "design", entries: entries2, baseline: analyze(team, { timeoutMs: options.timeoutMs }) };
+}
+function crossing(u0, u1, theta) {
+  const terms = u0.writeScaling === "shards" ? [
+    [u0.readUtilization, u1.readUtilization],
+    [u0.writeUtilization, u1.writeUtilization]
+  ] : [[u0.requestUtilization, u1.requestUtilization]];
+  terms.push([u0.bandwidthUtilization, u1.bandwidthUtilization]);
+  let best = Infinity;
+  for (const [a, b] of terms) {
+    const slope = b - a;
+    if (slope <= 1e-15) continue;
+    if (a >= theta) return 0;
+    best = Math.min(best, (theta - a) / slope);
+  }
+  return best;
+}
+function inboundLoad(diagram, traffic) {
+  const result = /* @__PURE__ */ new Map();
+  forEachStepRate(diagram, traffic, (step, rate) => {
+    if (step.toPort === void 0) return;
+    const ports = result.get(step.toServiceId) ?? /* @__PURE__ */ new Map();
+    ports.set(step.toPort, (ports.get(step.toPort) ?? 0) + rate * multiplierOf(step));
+    result.set(step.toServiceId, ports);
+  });
+  return result;
+}
+function hopFrom(p50, p99) {
+  const l50 = tailFactor(0.5);
+  const l99 = tailFactor(0.99);
+  let tailMs = Math.max(0, (p99 - p50) / (l99 - l50));
+  let fixedMs = p50 - tailMs * l50;
+  if (fixedMs < 0) {
+    fixedMs = 0;
+    tailMs = p99 / l99;
+  }
+  return { fixedMs, tailMs, waitProbability: 0 };
+}
+function analyzeSystems(diagram, traffic, options = {}) {
+  const inbound = inboundLoad(diagram, traffic);
+  if (!options.sharedSystems) options = { ...options, sharedSystems: sharedLoad(diagram, inbound) };
+  const hops = /* @__PURE__ */ new Map();
+  const availabilities = /* @__PURE__ */ new Map();
+  const key = (id, port) => `${id}
+${port}`;
+  const systems = (diagram.systems ?? []).map((system) => {
+    const result = analyzeSystem(system, inbound.get(system.id) ?? /* @__PURE__ */ new Map(), options);
+    for (const e of result.entries) {
+      hops.set(key(system.id, e.entry), hopFrom(e.p50Ms, e.p99Ms));
+      availabilities.set(key(system.id, e.entry), e.availability);
+    }
+    return result;
+  });
+  return {
+    systems,
+    hop: (id, port) => port === void 0 ? void 0 : hops.get(key(id, port)),
+    availability: (id, port) => port === void 0 ? void 0 : availabilities.get(key(id, port))
+  };
+}
+function sentByUseCase(system, sent, into) {
+  let total = 0;
+  for (const e of system.entries) {
+    const rps = sent.get(e.id) ?? 0;
+    if (rps <= 0 || e.useCaseId === void 0) continue;
+    into.set(e.useCaseId, (into.get(e.useCaseId) ?? 0) + rps);
+    total += rps;
+  }
+  return total;
+}
+function sharedLoad(root, rootInbound) {
+  const byFile = /* @__PURE__ */ new Map();
+  const designs = /* @__PURE__ */ new Map();
+  const order = [];
+  const visit = (d, prefix) => {
+    for (const s of d.systems ?? []) {
+      if (!s.diagram) continue;
+      const key = teamKey(s);
+      if (designs.has(key)) continue;
+      const path = prefix ? `${prefix}.${s.id}` : s.id;
+      designs.set(key, { diagram: s.diagram, path, loc: s.loc });
+      visit(s.diagram, path);
+      order.push(key);
+    }
+  };
+  visit(root, "");
+  const send = (d, prefix, inbound) => {
+    for (const s of d.systems ?? []) {
+      if (!s.diagram) continue;
+      const key = teamKey(s);
+      const load = byFile.get(key) ?? { useCases: /* @__PURE__ */ new Map(), callers: [] };
+      byFile.set(key, load);
+      const rps = sentByUseCase(s, inbound.get(s.id) ?? /* @__PURE__ */ new Map(), load.useCases);
+      if (rps > 0) load.callers.push({ path: prefix ? `${prefix}.${s.id}` : s.id, ...d.title !== void 0 ? { from: d.title } : {}, rps });
+    }
+  };
+  send(root, "", rootInbound);
+  for (const key of order.reverse()) {
+    const { diagram, path, loc } = designs.get(key);
+    if (!diagram.systems?.length) continue;
+    const combined = withExtraTraffic(diagram, byFile.get(key)?.useCases ?? /* @__PURE__ */ new Map(), loc);
+    send(diagram, path, inboundLoad(combined, resolveTraffic(combined)));
+  }
+  return { byFile, analyses: /* @__PURE__ */ new Map() };
+}
+function analyzeSystem(system, sent, options) {
+  const contract = contractOf(system, options);
+  const inbound = system.entries.map((e) => ({ entry: e.id, rps: sent.get(e.id) ?? 0 }));
+  const totalInboundRps = inbound.reduce((sum, e) => sum + e.rps, 0);
+  const result = { id: system.id, contract, inbound, totalInboundRps, utilization: 0, saturated: false, hot: false, breaches: [], entries: [], warnings: [] };
+  const shared = system.diagram ? options.sharedSystems?.byFile.get(teamKey(system)) : void 0;
+  const sending = inbound.filter((e) => e.rps > 0).map((e) => {
+    const c = contract.entries.find((x) => x.entry === e.entry);
+    const useCaseId = system.entries.find((x) => x.id === e.entry)?.useCaseId;
+    const gets = useCaseId !== void 0 ? shared?.useCases.get(useCaseId) ?? 0 : 0;
+    const rps = gets > e.rps * (1 + 1e-9) ? `${formatRps(e.rps).replace(/ rps$/, "")} of the ${formatRps(gets)} it gets` : formatRps(e.rps);
+    return `${rps} into ${c?.useCase ? `"${c.useCase}" (${system.id}.${e.entry})` : `${system.id}.${e.entry}`}`;
+  }).join(" and ");
+  const label = `'${system.id}'`;
+  if (contract.source === "stub") {
+    const stub = system.stub;
+    const rps = stub.rps ?? Infinity;
+    result.utilization = Number.isFinite(rps) && rps > 0 ? totalInboundRps / rps : 0;
+    result.saturated = result.utilization >= 1;
+    result.hot = !result.saturated && result.utilization > HOT;
+    const base = stub.latencyMs ?? (stub.p99Ms !== void 0 ? stub.p99Ms / (1 - SERVICE_SPREAD + SERVICE_SPREAD * tailFactor(0.99)) : 0);
+    const hop = hopModel(base, 0);
+    const at = (p) => hop.fixedMs + hop.tailMs * tailFactor(p);
+    const availability2 = stub.availability !== void 0 ? stub.availability / 100 : 1;
+    result.entries = system.entries.map((e) => ({ entry: e.id, p50Ms: at(0.5), p99Ms: at(0.99), availability: availability2 }));
+    if (result.saturated) {
+      result.warnings.push(`${label} cannot take what it is sent: you send ${sending}; it takes at most ${formatRps(rps)}.`);
+      if (stub.p99Ms !== void 0) result.breaches.push({ requirement: `p99 < ${formatMs(stub.p99Ms)}`, message: `p99 is not held past ${formatRps(rps)}` });
+    } else if (result.hot) result.warnings.push(`${label} runs hot under what it is sent: you send ${sending}; it runs hot past ${formatRps(rps * HOT)} and takes at most ${formatRps(rps)}.`);
+    return result;
+  }
+  if (contract.source === "none" || !system.diagram) {
+    result.entries = system.entries.map((e) => ({ entry: e.id, p50Ms: 0, p99Ms: 0, availability: 1 }));
+    return result;
+  }
+  const team = system.diagram;
+  const key = teamKey(system);
+  const sentToTeam = shared?.useCases ?? /* @__PURE__ */ new Map();
+  if (!shared) sentByUseCase(system, sent, sentToTeam);
+  const sharedInboundRps = [...sentToTeam.values()].reduce((sum, rps) => sum + rps, 0);
+  result.callers = shared?.callers ?? (totalInboundRps > 0 ? [{ path: system.id, rps: totalInboundRps }] : []);
+  result.sharedInboundRps = sharedInboundRps;
+  let cached = options.sharedSystems?.analyses.get(key);
+  if (!cached) {
+    const combined = sharedInboundRps > 0 ? withExtraTraffic(team, sentToTeam, system.loc) : team;
+    const nested = { timeoutMs: options.timeoutMs, ...options.sharedSystems ? { sharedSystems: options.sharedSystems } : {} };
+    cached = { combined, analysis: sharedInboundRps > 0 ? analyze(combined, nested) : contract.baseline };
+    options.sharedSystems?.analyses.set(key, cached);
+  }
+  const { analysis } = cached;
+  result.analysis = analysis;
+  result.overlay = analysisOverlay(cached.combined, analysis);
+  const busiest = analysis.nodes.reduce((best, n) => !best || n.utilization > best.utilization ? n : best, void 0);
+  result.utilization = busiest?.utilization ?? 0;
+  result.busiest = busiest?.id;
+  result.saturated = !!busiest?.saturated;
+  result.hot = !result.saturated && result.utilization > HOT;
+  const byId = new Map(analysis.useCases.map((u) => [u.id, u]));
+  result.entries = system.entries.map((e) => {
+    const u = e.useCaseId !== void 0 ? byId.get(e.useCaseId) : void 0;
+    return { entry: e.id, p50Ms: u?.percentiles.p50 ?? 0, p99Ms: u?.percentiles.p99 ?? 0, availability: u?.availability ?? 1 };
+  });
+  if (totalInboundRps === 0) return result;
+  result.breaches = breachesOf(team, sentToTeam, analysis);
+  const first = contract.entries.find((c) => inbound.some((e) => e.entry === c.entry && e.rps > 0));
+  if (result.saturated && busiest) {
+    const onOwn = first && first.saturatesAtRps === 0;
+    const limit = first && Number.isFinite(first.saturatesAtRps) ? `; it takes at most ${formatRps(first.saturatesAtRps)} before its ${first.bottleneck} saturates` : "";
+    result.warnings.push(
+      onOwn ? `${label} is saturated on its own traffic, before what it is sent: its ${busiest.id} is at ${usageText(busiest)}.` : `${label} cannot take what it is sent: you send ${sending}${limit}. Its ${busiest.id} is at ${usageText(busiest)}.`
+    );
+  } else if (result.hot && busiest) {
+    const limit = first && Number.isFinite(first.hotAtRps) ? `; it runs hot past ${formatRps(first.hotAtRps)}` : "";
+    result.warnings.push(`${label} runs hot under what it is sent: you send ${sending}${limit}. Its ${busiest.id} is at ${usageText(busiest)}.`);
+  }
+  for (const b of result.breaches) result.warnings.push(`${label} breaks its SLA under what it is sent: ${b.message}.`);
+  return result;
+}
+function withExtraTraffic(team, extra, loc) {
+  const traffic = [...team.traffic ?? []];
+  for (const [id, rps] of extra) {
+    const u = team.useCases.find((x) => x.id === id);
+    if (!u || rps <= 0) continue;
+    const i = traffic.findIndex((t) => findUseCase(team, t.useCase) === u);
+    if (i >= 0) traffic[i] = { ...traffic[i], rps: traffic[i].rps + rps };
+    else traffic.push({ useCase: u.name, rps, loc });
+  }
+  return { ...team, traffic };
+}
+function breachesOf(team, sent, analysis) {
+  const entered = /* @__PURE__ */ new Set();
+  for (const [id, rps] of sent) {
+    const u = team.useCases.find((x) => x.id === id);
+    if (u && rps > 0) entered.add(u);
+  }
+  const nodes = new Map(analysis.nodes.map((n) => [n.id, n]));
+  const results = new Map(analysis.useCases.map((u) => [u.id, u]));
+  const breaches = [];
+  for (const r of team.requirements ?? []) {
+    if (r.kind !== "latency" && r.kind !== "availability") continue;
+    const targets2 = r.useCase === void 0 ? [...entered] : [findUseCase(team, r.useCase)].filter((u) => !!u && entered.has(u));
+    for (const u of targets2) {
+      const ua = results.get(u.id);
+      const under = `under ${formatRps(ua.rps)}`;
+      if (r.kind === "availability") {
+        const name2 = `availability of "${u.name}" \u2265 ${r.minPercent}%`;
+        if (ua.availability * 100 < r.minPercent - 1e-9) breaches.push({ requirement: name2, message: `availability of "${u.name}" is ${formatAvailability(ua.availability)} ${under} (limit ${r.minPercent}%)` });
+        continue;
+      }
+      const key = PERCENTILE_KEYS[r.percentile];
+      const scenario = r.scenario !== void 0 ? findScenario2(u, r.scenario) : void 0;
+      if (r.scenario !== void 0 && !scenario) continue;
+      const what = `${key} of "${u.name}"${scenario ? ` scenario "${scenario.name}"` : ""}`;
+      const name = `${what} < ${formatMs(r.maxMs)}`;
+      const steps2 = scenario ? scenario.steps : u.scenarios.flatMap((s) => s.steps);
+      const saturated = steps2.map((s) => nodes.get(s.toServiceId)).reduce((best, n) => n?.saturated && (!best || n.utilization > best.utilization) ? n : best, void 0);
+      if (saturated) {
+        breaches.push({ requirement: name, message: `${what}: ${saturated.id} is saturated (${usageText(saturated)}) ${under} (limit ${formatMs(r.maxMs)})` });
+        continue;
+      }
+      const ms = scenario ? ua.scenarios[u.scenarios.indexOf(scenario)].percentiles[key] : ua.percentiles[key];
+      if (ms >= r.maxMs) breaches.push({ requirement: name, message: `${what} is ${formatMs(ms)} ${under} (limit ${formatMs(r.maxMs)})` });
+    }
+  }
+  return breaches;
+}
+
 // ../frontend/src/sim/analyze.ts
 var DEFAULT_TIMEOUT_MS = 1e3;
 var HOT = 0.7;
@@ -19247,6 +19925,7 @@ function usageText(n) {
     return `bandwidth ${mb(n.bandwidthLoadMBps)} of ${mb(n.bandwidthCapacityMBps)}, ${formatPercent(n.bandwidthUtilization)}`;
   }
   if (n.writeScaling === "shards" && n.writeLoadRps > 0) {
+    if (n.readLoadRps <= 0) return `writes ${part(n.writeLoadRps, n.writeCapacityRps, n.writeUtilization)}`;
     return `reads ${part(n.readLoadRps, n.readCapacityRps, n.readUtilization)}; writes ${part(n.writeLoadRps, n.writeCapacityRps, n.writeUtilization)}`;
   }
   return part(n.loadRps, n.capacityRps, n.requestUtilization);
@@ -19332,6 +20011,7 @@ function analyze(diagram, options = {}) {
   const load = computeLoad(diagram, traffic);
   const egress = computeEgressGb(diagram, traffic, kindOf2);
   const bytes = computeBytesPerSecond(diagram, traffic);
+  const systems = diagram.systems?.length ? analyzeSystems(diagram, traffic, options) : void 0;
   const hops = /* @__PURE__ */ new Map();
   const nodeResults = nodes.map((n) => {
     const p = profiles.get(n.id);
@@ -19370,12 +20050,13 @@ function analyze(diagram, options = {}) {
     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}.`);
   }
+  for (const s of systems?.systems ?? []) warnings.push(...s.warnings);
   const access = accessIn(diagram);
   const pathOf = (hopsOfPath) => ({
     parts: hopsOfPath.map(
       (part) => part.map((h) => {
         if (h.failed) return { fixedMs: timeoutOf(h.target), tailMs: 0 };
-        const hop = hops.get(h.target) ?? { fixedMs: 0, tailMs: 0 };
+        const hop = systems?.hop(h.target, h.step.toPort) ?? hops.get(h.target) ?? { fixedMs: 0, tailMs: 0 };
         return { fixedMs: transferMs(h.step, bandwidthOf) + hop.fixedMs, tailMs: hop.tailMs };
       })
     )
@@ -19405,6 +20086,7 @@ function analyze(diagram, options = {}) {
     const writes = mainWrites(u, shares, (step) => access(step) === "write");
     const availabilityOf = (id) => {
       const n = nodeById.get(id);
+      if (!n && systems) return systemAvailability(u, id, systems.availability);
       return !n ? 1 : writes.has(id) ? n.writeAvailability : n.availability;
     };
     return { id: u.id, name: u.name, rps, scenarios, percentiles, tailScenario, availability: useCaseAvailability(u, shares, availabilityOf) };
@@ -19415,9 +20097,15 @@ function analyze(diagram, options = {}) {
     totalCostUsd: nodeResults.reduce((sum, n) => sum + n.costUsd, 0),
     totalEgressUsd: nodeResults.reduce((sum, n) => sum + n.egressUsd, 0),
     singlePointsOfFailure: singlePointsOfFailure(diagram),
-    warnings
+    warnings,
+    ...systems ? { systems: systems.systems } : {}
   };
 }
+function systemAvailability(u, id, availability2) {
+  let result = 1;
+  for (const s of u.scenarios) for (const step of s.steps) if (step.toServiceId === id) result = Math.min(result, availability2(id, step.toPort) ?? 1);
+  return result;
+}
 function mainWrites(useCase, shares, isWrite) {
   if (useCase.scenarios.length === 0) return /* @__PURE__ */ new Set();
   const path = criticalPath(useCase, useCase.scenarios[mainScenarioIndex(shares)]).flat();
@@ -19467,6 +20155,7 @@ function runTests(diagram, analysis = analyze(diagram), options = {}) {
     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 };
   });
+  results.push(...systemResults(diagram, analysis));
   const names = /* @__PURE__ */ new Map();
   for (const test of diagram.tests ?? []) {
     const n = (names.get(test.name) ?? 0) + 1;
@@ -19475,6 +20164,26 @@ function runTests(diagram, analysis = analyze(diagram), options = {}) {
   }
   return results.map(({ hint, ...r }) => r.passed || !hint ? r : { ...r, hint });
 }
+function systemResults(diagram, analysis) {
+  return (analysis.systems ?? []).filter((s) => s.totalInboundRps > 0 && s.contract.source !== "none").map((s) => {
+    const system = diagram.systems?.find((x) => x.id === s.id);
+    const node = diagram.nodes.find((n) => n.id === s.id);
+    const team = node?.ownerTeam ? `the ${node.ownerTeam} team` : `the owners of ${s.id}`;
+    const problem = s.warnings.find((w) => !w.includes(" runs hot "));
+    const sat = s.contract.entries.find((e) => s.inbound.some((i) => i.entry === e.entry && i.rps > 0));
+    const room = sat && Number.isFinite(sat.saturatesAtRps) ? `; it takes at most ${formatRps(sat.saturatesAtRps)}` : "";
+    const bottleneck = s.saturated && s.busiest ? ` (their bottleneck is ${s.busiest})` : "";
+    return {
+      id: `system:${s.id}`,
+      name: `${s.id} takes what it is sent`,
+      category: s.breaches.some((b) => b.requirement.startsWith("availability")) && !s.saturated ? "availability" : "latency",
+      passed: !problem,
+      message: problem ?? `'${s.id}' takes ${formatRps(s.totalInboundRps)}${(s.sharedInboundRps ?? 0) > s.totalInboundRps * (1 + 1e-9) ? ` (of the ${formatRps(s.sharedInboundRps)} it gets)` : ""}${s.contract.source === "stub" ? "" : " on top of its own traffic"} and holds its requirements${room}`,
+      ...problem ? { hint: `Send it less, or ask ${team} to add capacity for it${bottleneck}` } : {},
+      ...system ? { loc: system.loc } : {}
+    };
+  });
+}
 var CATEGORY = {
   latency: "latency",
   availability: "availability",
@@ -20049,8 +20758,126 @@ function displayPath2(file) {
 }
 
 // src/imports.ts
-var import_node_fs4 = require("node:fs");
-var import_node_path5 = require("node:path");
+var import_node_fs5 = require("node:fs");
+var import_node_path6 = require("node:path");
+
+// ../frontend/src/dsl/imports.ts
+var ImportError = class extends Error {
+  name = "ImportError";
+};
+var MAX_SPEC_LENGTH = 1024;
+var SEGMENT = /^[A-Za-z0-9_][A-Za-z0-9._ +-]*$/;
+var HOST = /^[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?)*(?::\d{1,5})?$/;
+var REPO_SEGMENT = /^[A-Za-z0-9_][A-Za-z0-9._-]*$/;
+var REF = /^[A-Za-z0-9_][A-Za-z0-9._/-]*$/;
+var SCHEME = /^([A-Za-z][A-Za-z0-9+.-]+):/;
+function isRemoteSpec(spec) {
+  return SCHEME.test(spec);
+}
+function isAbsolutePath(path) {
+  return /^[\\/]/.test(path) || /^[A-Za-z]:/.test(path);
+}
+function checkRef(ref, spec) {
+  if (!REF.test(ref) || ref.length > 200 || ref.includes("..") || ref.includes("//") || ref.endsWith("/") || ref.endsWith(".") || ref.endsWith(".lock") || ref.split("/").some((p) => p.startsWith("."))) {
+    throw new ImportError(`'${spec}' has an invalid ref '${ref}'; use a tag, branch or commit made of letters, digits, '.', '_', '-' and '/'`);
+  }
+}
+function repoPathSegments(path, spec) {
+  const parts = path.split("/");
+  if (!path || parts.some((p) => !SEGMENT.test(p) || p === "." || p === "..")) {
+    throw new ImportError(`'${spec}' has an invalid path in the repository; use a relative path like dir/file.proschi, without '..'`);
+  }
+  return parts;
+}
+function parseRemoteSpec(spec) {
+  const scheme = SCHEME.exec(spec)?.[1].toLowerCase();
+  if (!scheme) return void 0;
+  if (spec.length > MAX_SPEC_LENGTH) throw new ImportError(`Import source is longer than ${MAX_SPEC_LENGTH} characters`);
+  if (/[\s\0\\]/.test(spec)) throw new ImportError(`'${spec}' contains whitespace or a backslash`);
+  if (scheme === "git") {
+    const body = spec.slice(4);
+    const at = body.lastIndexOf("@");
+    const split2 = body.indexOf("//");
+    if (at === -1 || split2 === -1 || split2 > at) {
+      throw new ImportError(`'${spec}' is not a git source; write git:<host>/<org>/<repo>//<path/in/repo>@<ref>`);
+    }
+    const repo = body.slice(0, split2);
+    const path = body.slice(split2 + 2, at);
+    const ref = body.slice(at + 1);
+    const [host, ...names] = repo.split("/");
+    if (!HOST.test(host) || names.length < 2 || names.some((n) => !REPO_SEGMENT.test(n) || n.endsWith("."))) {
+      throw new ImportError(`'${spec}' names an invalid repository '${repo}'; write <host>/<org>/<repo>`);
+    }
+    repoPathSegments(path, spec);
+    checkRef(ref, spec);
+    return { kind: "git", repo, path, ref };
+  }
+  if (scheme === "http") throw new ImportError(`'${spec}' uses http://; only https:// imports are allowed`);
+  if (scheme !== "https") throw new ImportError(`'${spec}' is not a supported import source; use a relative path, git: or https://`);
+  let url;
+  try {
+    url = new URL(spec);
+  } catch {
+    throw new ImportError(`'${spec}' is not a valid URL`);
+  }
+  if (url.username || url.password) throw new ImportError(`'${spec}' contains credentials; git and https imports use your own credentials, never ones in the diagram`);
+  if (url.hash) throw new ImportError(`'${spec}' has a #fragment; remove it`);
+  if (!HOST.test(url.host)) throw new ImportError(`'${spec}' has an invalid host`);
+  return { kind: "https", url: url.href };
+}
+function formatRemoteSpec(spec) {
+  return spec.kind === "git" ? `git:${spec.repo}//${spec.path}@${spec.ref}` : spec.url;
+}
+function resolveImportPath(fromPath, importPath) {
+  if (importPath.includes("\0")) throw new ImportError(`'${importPath.replace(/\0/g, "")}' contains a NUL character`);
+  const remote = parseRemoteSpec(importPath);
+  if (remote) return formatRemoteSpec(remote);
+  if (isAbsolutePath(importPath)) throw new ImportError(`'${importPath}' is an absolute path; imports must be relative to the importing file`);
+  const from = fromPath && isRemoteSpec(fromPath) ? parseRemoteSpec(fromPath) : void 0;
+  if (from?.kind === "git") {
+    const parts2 = from.path.split("/").slice(0, -1);
+    for (const part of importPath.split("/")) {
+      if (part === "" || part === ".") continue;
+      if (part !== "..") parts2.push(part);
+      else if (parts2.length > 0) parts2.pop();
+      else throw new ImportError(`'${importPath}' leaves the repository ${from.repo}`);
+    }
+    repoPathSegments(parts2.join("/"), importPath);
+    return formatRemoteSpec({ ...from, path: parts2.join("/") });
+  }
+  if (from?.kind === "https") {
+    const base = new URL(from.url);
+    const url = new URL(importPath, base);
+    if (url.origin !== base.origin) throw new ImportError(`'${importPath}' leaves ${base.origin}`);
+    return formatRemoteSpec(parseRemoteSpec(url.href));
+  }
+  const parts = !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 joinImportPath(fromPath, importPath) {
+  try {
+    return resolveImportPath(fromPath, importPath);
+  } catch (e) {
+    if (e instanceof ImportError) return void 0;
+    throw e;
+  }
+}
+function mapResolver(files) {
+  const paths = Object.keys(files).filter((p) => !isRemoteSpec(p));
+  return (importPath, fromPath) => {
+    const path = resolveImportPath(fromPath, importPath);
+    if (Object.prototype.hasOwnProperty.call(files, path)) return { path, source: files[path] };
+    if (isRemoteSpec(path)) return void 0;
+    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;
+  };
+}
 
 // src/simulation.ts
 var SIM_USAGE = `  proschi test [--format text|github|json] <file|dir>...
@@ -20217,21 +21044,201 @@ function capacityReport(diagram, analysis, file) {
   return lines.join("\n");
 }
 
+// src/lock.ts
+var import_node_crypto = require("node:crypto");
+var import_node_fs4 = require("node:fs");
+var import_node_path5 = require("node:path");
+
+// src/lockFormat.ts
+var LOCK_FILE = "proschi.lock";
+var CACHE_DIR = ".proschi/cache";
+var HASH = /^[0-9a-f]{64}$/;
+var COMMIT = /^[0-9a-f]{40}([0-9a-f]{24})?$/;
+var emptyLock = () => ({ version: 1, git: {}, https: {} });
+var gitKey = (repo, ref) => `${repo}@${ref}`;
+var remoteError = {
+  noLock: (spec) => new ImportError(`'${spec}' is a remote import and there is no ${LOCK_FILE}; run proschi imports sync`),
+  notLocked: (spec) => new ImportError(`'${spec}' is not in ${LOCK_FILE}; run proschi imports sync`),
+  notCached: (spec) => new ImportError(`'${spec}' is not in the import cache (${CACHE_DIR}); run proschi imports sync`),
+  altered: (spec) => new ImportError(`The cached copy of '${spec}' does not match its hash in ${LOCK_FILE}; run proschi imports sync`)
+};
+var isRecord = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+function parseLock(text) {
+  const invalid = (why) => new ImportError(`Invalid ${LOCK_FILE}: ${why}; delete it and run proschi imports sync`);
+  let json2;
+  try {
+    json2 = JSON.parse(text);
+  } catch (e) {
+    throw invalid(e.message);
+  }
+  if (!isRecord(json2) || json2.version !== 1) throw invalid('expected {"version": 1, \u2026}');
+  const lock = emptyLock();
+  const git = json2.git ?? {};
+  const https = json2.https ?? {};
+  if (!isRecord(git) || !isRecord(https)) throw invalid('"git" and "https" must be objects');
+  for (const [key, entry] of Object.entries(git)) {
+    const at = key.lastIndexOf("@");
+    const valid = at > 0 && isRecord(entry) && typeof entry.commit === "string" && COMMIT.test(entry.commit) && isRecord(entry.files) && Object.entries(entry.files).every(([path, hash]) => typeof hash === "string" && HASH.test(hash) && isGitSpec(`git:${key.slice(0, at)}//${path}@${key.slice(at + 1)}`));
+    if (!valid) throw invalid(`bad git entry '${key}'`);
+    lock.git[key] = { commit: entry.commit, files: { ...entry.files } };
+  }
+  for (const [url, hash] of Object.entries(https)) {
+    if (typeof hash !== "string" || !HASH.test(hash) || parseRemoteSpec(url)?.kind !== "https") throw invalid(`bad https entry '${url}'`);
+    lock.https[url] = hash;
+  }
+  return lock;
+}
+function isGitSpec(spec) {
+  try {
+    return parseRemoteSpec(spec)?.kind === "git";
+  } catch {
+    return false;
+  }
+}
+function lockedHash(lock, spec) {
+  const remote = parseRemoteSpec(spec);
+  if (remote?.kind === "git") return lock.git[gitKey(remote.repo, remote.ref)]?.files[remote.path];
+  if (remote?.kind === "https") return lock.https[remote.url];
+  return void 0;
+}
+
+// src/lock.ts
+var sha256 = (bytes) => (0, import_node_crypto.createHash)("sha256").update(bytes).digest("hex");
+function readLock(root) {
+  const file = (0, import_node_path5.join)(root, LOCK_FILE);
+  return (0, import_node_fs4.existsSync)(file) ? parseLock((0, import_node_fs4.readFileSync)(file, "utf8")) : void 0;
+}
+var sorted = (o, map = (v) => v) => Object.fromEntries(Object.keys(o).sort().map((k) => [k, map(o[k])]));
+function formatLock(lock) {
+  return JSON.stringify({ version: 1, git: sorted(lock.git, (e) => ({ commit: e.commit, files: sorted(e.files) })), https: sorted(lock.https) }, null, 2) + "\n";
+}
+function writeLock(root, lock) {
+  (0, import_node_fs4.writeFileSync)((0, import_node_path5.join)(root, LOCK_FILE), formatLock(lock));
+}
+var cacheFile = (root, hash) => (0, import_node_path5.join)(root, CACHE_DIR, hash);
+function readCached(root, hash, spec) {
+  if (!HASH.test(hash)) return void 0;
+  const file = cacheFile(root, hash);
+  if (!(0, import_node_fs4.existsSync)(file)) return void 0;
+  const bytes = (0, import_node_fs4.readFileSync)(file);
+  if (sha256(bytes) !== hash) throw remoteError.altered(spec);
+  return bytes;
+}
+function writeCached(root, bytes) {
+  const hash = sha256(bytes);
+  const dir = (0, import_node_path5.join)(root, CACHE_DIR);
+  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+  const tmp = (0, import_node_path5.join)(dir, `${hash}.${process.pid}.tmp`);
+  (0, import_node_fs4.writeFileSync)(tmp, bytes);
+  (0, import_node_fs4.renameSync)(tmp, cacheFile(root, hash));
+  return hash;
+}
+
 // src/imports.ts
 function displayPath3(file, cwd = process.cwd()) {
-  const abs = (0, import_node_path5.resolve)(cwd, file);
-  const rel = (0, import_node_path5.relative)(cwd, abs);
-  return rel && !rel.startsWith("..") && !(0, import_node_path5.isAbsolute)(rel) ? rel : abs;
-}
-function fileResolver(read = () => void 0, toPath = (p) => p) {
-  return (importPath, fromPath) => {
-    const abs = (0, import_node_path5.resolve)(fromPath ? (0, import_node_path5.dirname)(fromPath) : process.cwd(), importPath);
-    const text = read(abs) ?? ((0, import_node_fs4.existsSync)(abs) && (0, import_node_fs4.statSync)(abs).isFile() ? (0, import_node_fs4.readFileSync)(abs, "utf8") : void 0);
-    return text === void 0 ? void 0 : { path: toPath(abs), source: text };
+  const abs = (0, import_node_path6.resolve)(cwd, file);
+  const rel = (0, import_node_path6.relative)(cwd, abs);
+  return rel && !rel.startsWith("..") && !(0, import_node_path6.isAbsolute)(rel) ? rel : abs;
+}
+var MAX_IMPORT_BYTES = 1e6;
+var MAX_IMPORT_FILES = 500;
+var MAX_IMPORT_DEPTH = 32;
+function projectRoot(entry) {
+  const dir = (0, import_node_path6.dirname)((0, import_node_path6.resolve)(entry));
+  const config = findConfigFile(dir);
+  if (config) return (0, import_node_fs5.realpathSync)((0, import_node_path6.dirname)(config));
+  for (let current = dir; ; current = (0, import_node_path6.dirname)(current)) {
+    if ((0, import_node_fs5.existsSync)((0, import_node_path6.join)(current, ".git"))) return (0, import_node_fs5.realpathSync)(current);
+    if ((0, import_node_path6.dirname)(current) === current) break;
+  }
+  return (0, import_node_fs5.realpathSync)((0, import_node_fs5.existsSync)(dir) ? dir : process.cwd());
+}
+var isInside = (root, path) => {
+  const rel = (0, import_node_path6.relative)(root, path);
+  return rel === "" || rel !== ".." && !rel.startsWith(`..${import_node_path6.sep}`) && !(0, import_node_path6.isAbsolute)(rel);
+};
+function realLocation(path) {
+  let existing = path;
+  while (!(0, import_node_fs5.existsSync)(existing) && (0, import_node_path6.dirname)(existing) !== existing) existing = (0, import_node_path6.dirname)(existing);
+  return (0, import_node_path6.join)((0, import_node_fs5.realpathSync)(existing), (0, import_node_path6.relative)(existing, path));
+}
+var tooLarge = (what) => new ImportError(`'${what}' is larger than ${MAX_IMPORT_BYTES / 1e6} MB`);
+function fileResolver({ entry, read = () => void 0, toPath = (p) => p, remote } = {}) {
+  const root = projectRoot(entry ?? (0, import_node_path6.join)(process.cwd(), "stdin.proschi"));
+  const errors = /* @__PURE__ */ new Map();
+  const levels = /* @__PURE__ */ new Map();
+  let lock = null;
+  const fromCache = (spec) => {
+    if (lock === null) lock = readLock(root);
+    if (!lock) throw remoteError.noLock(spec);
+    const hash = lockedHash(lock, spec);
+    if (!hash) throw remoteError.notLocked(spec);
+    const bytes = readCached(root, hash, spec);
+    if (!bytes) throw remoteError.notCached(spec);
+    return bytes.toString("utf8");
   };
+  const loadRemote = remote ?? fromCache;
+  const found = (path, source2, level) => {
+    if (!levels.has(path)) {
+      if (levels.size >= MAX_IMPORT_FILES) throw new ImportError(`More than ${MAX_IMPORT_FILES} imported files; split the diagram`);
+      levels.set(path, level);
+    }
+    return { path, source: source2 };
+  };
+  const resolveOne = (importPath, fromPath) => {
+    const level = (fromPath === void 0 ? 0 : levels.get(fromPath) ?? 0) + 1;
+    if (level > MAX_IMPORT_DEPTH) throw new ImportError(`Imports nest more than ${MAX_IMPORT_DEPTH} files deep`);
+    if (isRemoteSpec(importPath) || fromPath !== void 0 && isRemoteSpec(fromPath)) {
+      const spec = resolveImportPath(fromPath, importPath);
+      const source2 = loadRemote(spec);
+      if (source2 === void 0) return void 0;
+      if (Buffer.byteLength(source2) > MAX_IMPORT_BYTES) throw tooLarge(spec);
+      return found(spec, source2, level);
+    }
+    resolveImportPath(void 0, importPath);
+    const abs = (0, import_node_path6.resolve)(fromPath ? (0, import_node_path6.dirname)((0, import_node_path6.resolve)(fromPath)) : root, importPath);
+    if (!isInside(root, realLocation(abs))) {
+      const link = (0, import_node_fs5.existsSync)(abs) && (0, import_node_fs5.lstatSync)(abs).isSymbolicLink();
+      throw new ImportError(
+        link ? `'${importPath}' is a symlink to a file outside the project root ${displayPath3(root)}` : `'${importPath}' is outside the project root ${displayPath3(root)}; imports must stay inside the folder of proschi.json (else the git root)`
+      );
+    }
+    const text = read(abs);
+    if (text !== void 0) {
+      if (Buffer.byteLength(text) > MAX_IMPORT_BYTES) throw tooLarge(importPath);
+      return found(toPath(abs), text, level);
+    }
+    if (!(0, import_node_fs5.existsSync)(abs)) return void 0;
+    const stat = (0, import_node_fs5.statSync)(abs);
+    if (!stat.isFile()) return void 0;
+    if (stat.size > MAX_IMPORT_BYTES) throw tooLarge(importPath);
+    return found(toPath(abs), (0, import_node_fs5.readFileSync)((0, import_node_fs5.realpathSync)(abs), "utf8"), level);
+  };
+  const resolver = ((importPath, fromPath) => {
+    try {
+      return resolveOne(importPath, fromPath);
+    } catch (e) {
+      if (e instanceof ImportError) errors.set(`${fromPath ?? ""}\0${importPath}`, e.message);
+      throw e;
+    }
+  });
+  resolver.root = root;
+  resolver.errors = errors;
+  resolver.explain = (result) => {
+    for (const i of result.imports ?? []) {
+      if (i.resolved !== void 0) continue;
+      const reason = errors.get(`${i.loc.file ?? entry ?? ""}\0${i.path}`);
+      const d = reason && result.diagnostics.find((d2) => d2.file === i.loc.file && d2.line === i.loc.line && d2.col === i.loc.col && d2.message === `Cannot find '${i.path}'`);
+      if (d) d.message = reason;
+    }
+    return result;
+  };
+  return resolver;
 }
 function parseFile(file) {
-  return parse((0, import_node_fs4.readFileSync)(file, "utf8"), { path: displayPath3(file), resolve: fileResolver(void 0, (p) => displayPath3(p)) });
+  const path = displayPath3(file);
+  const resolver = fileResolver({ entry: path, toPath: (p) => displayPath3(p) });
+  return resolver.explain(parse((0, import_node_fs5.readFileSync)(file, "utf8"), { path, resolve: resolver }));
 }
 function checkFiles(files, extra) {
   const byFile = /* @__PURE__ */ new Map();
@@ -20253,8 +21260,8 @@ function checkFiles(files, extra) {
 }
 
 // src/problem.ts
-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");
 
 // ../frontend/src/practice/frontMatter.ts
 var FrontMatterError = class extends Error {
@@ -20370,27 +21377,6 @@ function parseFrontMatter(text) {
   return { data, body: lines.slice(end + 1).join("\n").trim() };
 }
 
-// ../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 resolve8 = mapResolver(files);
@@ -21276,7 +22262,7 @@ function readTopics(text, file = "tags.json") {
     return { id: topic.id, title: topic.title, summary: topic.summary };
   });
 }
-function readLock(text) {
+function readLock2(text) {
   const ids = [];
   const lines = /* @__PURE__ */ new Map();
   text.split("\n").forEach((raw, i) => {
@@ -21291,7 +22277,7 @@ var LOCK_HEADER = `# Every card id ever published, sorted. Review history is sto
 # id is never deleted or reused: retire a card with \`status: retired\` instead.
 # \`proschi cards lock\` adds new cards' ids (docs/CARDS.md).
 `;
-function writeLock(existing, ids) {
+function writeLock2(existing, ids) {
   return LOCK_HEADER + [.../* @__PURE__ */ new Set([...existing, ...ids])].sort().join("\n") + "\n";
 }
 function compareCards(a, b) {
@@ -21729,43 +22715,43 @@ var PROBLEM_HELP = `problem Practice problems, one folder each (docs/PRACTICE.md
         passes).
         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");
+var REPO_PROBLEMS = (0, import_node_path7.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;
+  for (let dir = (0, import_node_path7.resolve)(cwd); ; dir = (0, import_node_path7.dirname)(dir)) {
+    const candidate = (0, import_node_path7.join)(dir, REPO_PROBLEMS);
+    if ((0, import_node_fs6.existsSync)(candidate) && (0, import_node_fs6.statSync)(candidate).isDirectory()) return candidate;
+    if ((0, import_node_path7.dirname)(dir) === dir) return void 0;
   }
 }
 function readProblemFolder(folder) {
   const files = {};
-  for (const entry of (0, import_node_fs5.readdirSync)(folder, { withFileTypes: true })) {
+  for (const entry of (0, import_node_fs6.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");
+    if (entry.isFile()) files[entry.name] = (0, import_node_fs6.readFileSync)((0, import_node_path7.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") : "";
+      for (const sub of (0, import_node_fs6.readdirSync)((0, import_node_path7.join)(folder, entry.name), { withFileTypes: true })) {
+        if (!sub.name.startsWith(".")) files[`${entry.name}/${sub.name}`] = sub.isFile() ? (0, import_node_fs6.readFileSync)((0, import_node_path7.join)(folder, entry.name, sub.name), "utf8") : "";
       }
     }
   }
   return files;
 }
 function siblingCardIds(problemsDir) {
-  const cards = (0, import_node_path6.join)(problemsDir, "..", "cards");
-  if (!(0, import_node_fs5.existsSync)((0, import_node_path6.join)(cards, "tags.json"))) return void 0;
+  const cards = (0, import_node_path7.join)(problemsDir, "..", "cards");
+  if (!(0, import_node_fs6.existsSync)((0, import_node_path7.join)(cards, "tags.json"))) return void 0;
   const ids = /* @__PURE__ */ new Set();
-  for (const topic of (0, import_node_fs5.readdirSync)(cards, { withFileTypes: true })) {
+  for (const topic of (0, import_node_fs6.readdirSync)(cards, { withFileTypes: true })) {
     if (!topic.isDirectory()) continue;
-    for (const file of (0, import_node_fs5.readdirSync)((0, import_node_path6.join)(cards, topic.name))) if (file.endsWith(".md")) ids.add(file.slice(0, -".md".length));
+    for (const file of (0, import_node_fs6.readdirSync)((0, import_node_path7.join)(cards, topic.name))) if (file.endsWith(".md")) ids.add(file.slice(0, -".md".length));
   }
   return ids;
 }
 function checkProblems(dir) {
   const cardIds = siblingCardIds(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));
+  return (0, import_node_fs6.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_path7.join)(dir, id));
     try {
-      const problem = problemFromFiles(id, readProblemFolder((0, import_node_path6.join)(dir, id)));
+      const problem = problemFromFiles(id, readProblemFolder((0, import_node_path7.join)(dir, id)));
       return { folder, loaded: true, ...validateProblem(problem, void 0, { cardIds }) };
     } catch (e) {
       if (!(e instanceof ProblemFolderError)) throw e;
@@ -21779,7 +22765,7 @@ 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);
+  const where = (r, v) => v.file === "." ? r.folder : (0, import_node_path7.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)}`);
@@ -21833,7 +22819,7 @@ Usage:
 ${PROBLEM_USAGE}`);
     return 2;
   }
-  const dir = paths[0] ? (0, import_node_path6.resolve)(cwd, paths[0]) : findProblemsDir(cwd);
+  const dir = paths[0] ? (0, import_node_path7.resolve)(cwd, paths[0]) : findProblemsDir(cwd);
   if (!dir) {
     err(`Not inside the Proschi repository; give the problems directory
 
@@ -21841,7 +22827,7 @@ Usage:
 ${PROBLEM_USAGE}`);
     return 2;
   }
-  if (!(0, import_node_fs5.existsSync)(dir) || !(0, import_node_fs5.statSync)(dir).isDirectory()) {
+  if (!(0, import_node_fs6.existsSync)(dir) || !(0, import_node_fs6.statSync)(dir).isDirectory()) {
     err(`No such directory: ${paths[0] ?? dir}`);
     return 2;
   }
@@ -21883,16 +22869,16 @@ ${PROBLEM_USAGE}`);
     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)) {
+  const dir = dirArg ? (0, import_node_path7.resolve)(cwd, dirArg) : findProblemsDir(cwd) ?? (0, import_node_path7.resolve)(cwd, "problems");
+  const folder = (0, import_node_path7.join)(dir, id);
+  if ((0, import_node_fs6.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);
+    (0, import_node_fs6.mkdirSync)((0, import_node_path7.dirname)((0, import_node_path7.join)(folder, name)), { recursive: true });
+    (0, import_node_fs6.writeFileSync)((0, import_node_path7.join)(folder, name), text);
   }
   const shown = displayPath3(folder);
   out(`Created ${shown}/
@@ -21924,12 +22910,12 @@ ${PROBLEM_USAGE}`);
 }
 
 // src/cards.ts
-var import_node_fs6 = require("node:fs");
-var import_node_path7 = require("node:path");
+var import_node_fs7 = require("node:fs");
+var import_node_path8 = require("node:path");
 
 // ../frontend/src/learn/cardCheck.ts
 var TAGS_FILE = "tags.json";
-var LOCK_FILE = "ids.lock";
+var LOCK_FILE2 = "ids.lock";
 var DUPLICATE_THRESHOLD = 0.4;
 var STOP = new Set(
   "a an the and or of to in on for with is are was be it its this that what which when why how does do you your from by as at than then into can would should".split(" ")
@@ -21980,9 +22966,9 @@ function checkCardFiles(files, options = {}) {
   const topicIds = new Set(topics.map((t) => t.id));
   const cards = [];
   for (const file of Object.keys(files).sort()) {
-    if (file === TAGS_FILE || file === LOCK_FILE) continue;
+    if (file === TAGS_FILE || file === LOCK_FILE2) continue;
     if (!/^[^/]+\/[^/]+\.md$/.test(file)) {
-      add(file, `Unexpected file: the cards folder holds ${TAGS_FILE}, ${LOCK_FILE} and <topic>/<id>.md`);
+      add(file, `Unexpected file: the cards folder holds ${TAGS_FILE}, ${LOCK_FILE2} and <topic>/<id>.md`);
       continue;
     }
     try {
@@ -22018,16 +23004,16 @@ function checkCardFiles(files, options = {}) {
   for (const card of cards) {
     for (const other of card.distinctFrom) if (!byId.has(other)) add(fileOf(card), `'distinct-from' names "${other}", which is not a card`);
   }
-  if (files[LOCK_FILE] === void 0) add(LOCK_FILE, "Missing: run `proschi cards lock` to create it");
+  if (files[LOCK_FILE2] === void 0) add(LOCK_FILE2, "Missing: run `proschi cards lock` to create it");
   else {
-    const { ids, lines } = readLock(files[LOCK_FILE]);
-    const sorted = [...new Set(ids)].sort();
-    if (ids.join("\n") !== sorted.join("\n")) add(LOCK_FILE, "Not sorted, or an id appears twice; run `proschi cards lock`");
+    const { ids, lines } = readLock2(files[LOCK_FILE2]);
+    const sorted2 = [...new Set(ids)].sort();
+    if (ids.join("\n") !== sorted2.join("\n")) add(LOCK_FILE2, "Not sorted, or an id appears twice; run `proschi cards lock`");
     for (const card of cards) {
-      if (!lines.has(card.id)) add(fileOf(card), `New card: add its id to ${LOCK_FILE} with \`proschi cards lock\``);
+      if (!lines.has(card.id)) add(fileOf(card), `New card: add its id to ${LOCK_FILE2} with \`proschi cards lock\``);
     }
     for (const id of lines.keys()) {
-      if (!byId.has(id)) add(LOCK_FILE, `"${id}" has no card file: never delete a card, set \`status: retired\` in its front matter instead`, lines.get(id));
+      if (!byId.has(id)) add(LOCK_FILE2, `"${id}" has no card file: never delete a card, set \`status: retired\` in its front matter instead`, lines.get(id));
     }
   }
   for (const { a, b, score } of overlaps(cards, options.threshold)) {
@@ -22052,34 +23038,34 @@ var CARDS_HELP = `cards   Practice cards, one Markdown file each (docs/CARDS.md)
         phone, and no two cards that ask nearly the same thing.
         Exits with 1 on any violation.
         lock adds the ids of new cards to ids.lock.`;
-var REPO_CARDS = (0, import_node_path7.join)("frontend", "src", "practice", "cards");
+var REPO_CARDS = (0, import_node_path8.join)("frontend", "src", "practice", "cards");
 function findCardsDir(cwd = process.cwd()) {
-  for (let dir = (0, import_node_path7.resolve)(cwd); ; dir = (0, import_node_path7.dirname)(dir)) {
-    const candidate = (0, import_node_path7.join)(dir, REPO_CARDS);
-    if ((0, import_node_fs6.existsSync)(candidate) && (0, import_node_fs6.statSync)(candidate).isDirectory()) return candidate;
-    if ((0, import_node_path7.dirname)(dir) === dir) return void 0;
+  for (let dir = (0, import_node_path8.resolve)(cwd); ; dir = (0, import_node_path8.dirname)(dir)) {
+    const candidate = (0, import_node_path8.join)(dir, REPO_CARDS);
+    if ((0, import_node_fs7.existsSync)(candidate) && (0, import_node_fs7.statSync)(candidate).isDirectory()) return candidate;
+    if ((0, import_node_path8.dirname)(dir) === dir) return void 0;
   }
 }
 function readCardsFolder(dir) {
   const files = {};
-  for (const entry of (0, import_node_fs6.readdirSync)(dir, { withFileTypes: true })) {
+  for (const entry of (0, import_node_fs7.readdirSync)(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".")) continue;
-    if (entry.isFile()) files[entry.name] = (0, import_node_fs6.readFileSync)((0, import_node_path7.join)(dir, entry.name), "utf8");
+    if (entry.isFile()) files[entry.name] = (0, import_node_fs7.readFileSync)((0, import_node_path8.join)(dir, entry.name), "utf8");
     else if (entry.isDirectory()) {
-      for (const sub of (0, import_node_fs6.readdirSync)((0, import_node_path7.join)(dir, entry.name), { withFileTypes: true })) {
-        if (!sub.name.startsWith(".")) files[`${entry.name}/${sub.name}`] = sub.isFile() ? (0, import_node_fs6.readFileSync)((0, import_node_path7.join)(dir, entry.name, sub.name), "utf8") : "";
+      for (const sub of (0, import_node_fs7.readdirSync)((0, import_node_path8.join)(dir, entry.name), { withFileTypes: true })) {
+        if (!sub.name.startsWith(".")) files[`${entry.name}/${sub.name}`] = sub.isFile() ? (0, import_node_fs7.readFileSync)((0, import_node_path8.join)(dir, entry.name, sub.name), "utf8") : "";
       }
     }
   }
   return files;
 }
 function problemIdsIn(problemsDir) {
-  return (0, import_node_fs6.readdirSync)(problemsDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+  return (0, import_node_fs7.readdirSync)(problemsDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
 }
 var escape4 = (s) => s.replace(/%/g, "%25").replace(/\r?\n/g, "%0A");
 function formatCardCheck(dir, check, style) {
   const shown = displayPath3(dir);
-  const where = (v) => (0, import_node_path7.join)(shown, v.file);
+  const where = (v) => (0, import_node_path8.join)(shown, v.file);
   if (style === "json") {
     return JSON.stringify({ dir: shown, cards: check.cards.length, topics: check.topics.length, violations: check.violations }, null, 2);
   }
@@ -22134,7 +23120,7 @@ ${CARDS_USAGE}`);
   return parsed;
 }
 function resolveDir(dirArg, cwd, err) {
-  const dir = dirArg ? (0, import_node_path7.resolve)(cwd, dirArg) : findCardsDir(cwd);
+  const dir = dirArg ? (0, import_node_path8.resolve)(cwd, dirArg) : findCardsDir(cwd);
   if (!dir) {
     err(`Not inside the Proschi repository; give the cards directory
 
@@ -22142,7 +23128,7 @@ Usage:
 ${CARDS_USAGE}`);
     return void 0;
   }
-  if (!(0, import_node_fs6.existsSync)(dir) || !(0, import_node_fs6.statSync)(dir).isDirectory()) {
+  if (!(0, import_node_fs7.existsSync)(dir) || !(0, import_node_fs7.statSync)(dir).isDirectory()) {
     err(`No such directory: ${dirArg ?? dir}`);
     return void 0;
   }
@@ -22153,9 +23139,9 @@ function cardsCheck(args, out, err, cwd) {
   if (!parsed) return 2;
   const dir = resolveDir(parsed.dir, cwd, err);
   if (!dir) return 2;
-  const besideCards = (0, import_node_path7.join)(dir, "..", "problems");
-  const problemsDir = parsed.problems ? (0, import_node_path7.resolve)(cwd, parsed.problems) : (0, import_node_fs6.existsSync)(besideCards) ? besideCards : findProblemsDir(cwd);
-  if (parsed.problems && !((0, import_node_fs6.existsSync)(problemsDir) && (0, import_node_fs6.statSync)(problemsDir).isDirectory())) {
+  const besideCards = (0, import_node_path8.join)(dir, "..", "problems");
+  const problemsDir = parsed.problems ? (0, import_node_path8.resolve)(cwd, parsed.problems) : (0, import_node_fs7.existsSync)(besideCards) ? besideCards : findProblemsDir(cwd);
+  if (parsed.problems && !((0, import_node_fs7.existsSync)(problemsDir) && (0, import_node_fs7.statSync)(problemsDir).isDirectory())) {
     err(`No such directory: ${parsed.problems}`);
     return 2;
   }
@@ -22180,11 +23166,11 @@ function cardsLock(args, out, err, cwd) {
       ids.push(file.slice(file.indexOf("/") + 1, -".md".length));
     }
   }
-  const lockPath = (0, import_node_path7.join)(dir, LOCK_FILE);
-  const existing = (0, import_node_fs6.existsSync)(lockPath) ? readLock((0, import_node_fs6.readFileSync)(lockPath, "utf8")).ids : [];
+  const lockPath = (0, import_node_path8.join)(dir, LOCK_FILE2);
+  const existing = (0, import_node_fs7.existsSync)(lockPath) ? readLock2((0, import_node_fs7.readFileSync)(lockPath, "utf8")).ids : [];
   const added = [...new Set(ids)].filter((id) => !existing.includes(id)).sort();
-  const text = writeLock(existing, ids);
-  if (!(0, import_node_fs6.existsSync)(lockPath) || (0, import_node_fs6.readFileSync)(lockPath, "utf8") !== text) (0, import_node_fs6.writeFileSync)(lockPath, text);
+  const text = writeLock2(existing, ids);
+  if (!(0, import_node_fs7.existsSync)(lockPath) || (0, import_node_fs7.readFileSync)(lockPath, "utf8") !== text) (0, import_node_fs7.writeFileSync)(lockPath, text);
   out(added.length ? `Added ${added.length} id${added.length === 1 ? "" : "s"} to ${displayPath3(lockPath)}:
   ${added.join("\n  ")}` : `${displayPath3(lockPath)} already lists every card`);
   return 0;
@@ -22201,8 +23187,8 @@ ${CARDS_USAGE}`);
 }
 
 // src/achievements.ts
-var import_node_fs7 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_fs8 = require("node:fs");
+var import_node_path9 = require("node:path");
 
 // ../frontend/src/learn/fsrs.ts
 var FACTOR = 19 / 81;
@@ -22282,7 +23268,7 @@ function checkAchievements(raw, context) {
     if (violations.length === before2) achievements.push(a);
   });
   if (context.lock !== void 0) {
-    const { ids: locked, lines } = readLock(context.lock);
+    const { ids: locked, lines } = readLock2(context.lock);
     if (locked.join("\n") !== [...new Set(locked)].sort().join("\n")) violations.push({ inLock: true, message: `${ACHIEVEMENTS_LOCK_FILE} is not sorted, or an id appears twice; run \`proschi achievements lock\`` });
     raw.forEach((item, index) => {
       const id = item && typeof item === "object" ? item.id : void 0;
@@ -22395,21 +23381,21 @@ var ACHIEVEMENTS_HELP = `achievements
         the file, which lists no deleted achievement (retire one with
         "retired": true instead). Exits with 1 on any violation. lock adds
         the ids of new achievements to achievements.lock.`;
-var REPO_ACHIEVEMENTS = (0, import_node_path8.join)("frontend", "src", "practice", "achievements.json");
+var REPO_ACHIEVEMENTS = (0, import_node_path9.join)("frontend", "src", "practice", "achievements.json");
 function findAchievementsFile(cwd = process.cwd()) {
-  for (let dir = (0, import_node_path8.resolve)(cwd); ; dir = (0, import_node_path8.dirname)(dir)) {
-    const candidate = (0, import_node_path8.join)(dir, REPO_ACHIEVEMENTS);
-    if ((0, import_node_fs7.existsSync)(candidate) && (0, import_node_fs7.statSync)(candidate).isFile()) return candidate;
-    if ((0, import_node_path8.dirname)(dir) === dir) return void 0;
+  for (let dir = (0, import_node_path9.resolve)(cwd); ; dir = (0, import_node_path9.dirname)(dir)) {
+    const candidate = (0, import_node_path9.join)(dir, REPO_ACHIEVEMENTS);
+    if ((0, import_node_fs8.existsSync)(candidate) && (0, import_node_fs8.statSync)(candidate).isFile()) return candidate;
+    if ((0, import_node_path9.dirname)(dir) === dir) return void 0;
   }
 }
 function problemsIn(dir) {
   const out = [];
-  for (const entry of (0, import_node_fs7.readdirSync)(dir, { withFileTypes: true })) {
-    const file = (0, import_node_path8.join)(dir, entry.name, PROBLEM_MD);
-    if (!entry.isDirectory() || entry.name.startsWith(".") || !(0, import_node_fs7.existsSync)(file)) continue;
+  for (const entry of (0, import_node_fs8.readdirSync)(dir, { withFileTypes: true })) {
+    const file = (0, import_node_path9.join)(dir, entry.name, PROBLEM_MD);
+    if (!entry.isDirectory() || entry.name.startsWith(".") || !(0, import_node_fs8.existsSync)(file)) continue;
     try {
-      const { difficulty, tags } = readProblemMd(entry.name, (0, import_node_fs7.readFileSync)(file, "utf8"));
+      const { difficulty, tags } = readProblemMd(entry.name, (0, import_node_fs8.readFileSync)(file, "utf8"));
       out.push({ id: entry.name, difficulty, tags });
     } catch {
     }
@@ -22417,7 +23403,7 @@ function problemsIn(dir) {
   return out;
 }
 function lineOf2(text, lock, v) {
-  if (v.inLock) return v.id !== void 0 && lock !== void 0 ? readLock(lock).lines.get(v.id) : void 0;
+  if (v.inLock) return v.id !== void 0 && lock !== void 0 ? readLock2(lock).lines.get(v.id) : void 0;
   if (v.id === void 0) return void 0;
   const needle = `"id": ${JSON.stringify(v.id)}`;
   const at = v.message.startsWith("Duplicate id") ? text.lastIndexOf(needle) : text.indexOf(needle);
@@ -22461,11 +23447,11 @@ ${ACHIEVEMENTS_USAGE}`);
   parsed.file = paths[0];
   return parsed;
 }
-var isDir = (p) => (0, import_node_fs7.existsSync)(p) && (0, import_node_fs7.statSync)(p).isDirectory();
+var isDir = (p) => (0, import_node_fs8.existsSync)(p) && (0, import_node_fs8.statSync)(p).isDirectory();
 function achievementsCheck(args, out, err, cwd) {
   const parsed = parseArgs3(args, err);
   if (!parsed) return 2;
-  const file = parsed.file ? (0, import_node_path8.resolve)(cwd, parsed.file) : findAchievementsFile(cwd);
+  const file = parsed.file ? (0, import_node_path9.resolve)(cwd, parsed.file) : findAchievementsFile(cwd);
   if (!file) {
     err(`Not inside the Proschi repository; give the achievements file
 
@@ -22473,26 +23459,26 @@ Usage:
 ${ACHIEVEMENTS_USAGE}`);
     return 2;
   }
-  if (!(0, import_node_fs7.existsSync)(file) || !(0, import_node_fs7.statSync)(file).isFile()) {
+  if (!(0, import_node_fs8.existsSync)(file) || !(0, import_node_fs8.statSync)(file).isFile()) {
     err(`No such file: ${parsed.file ?? file}`);
     return 2;
   }
-  const problemsDir = parsed.problems ? (0, import_node_path8.resolve)(cwd, parsed.problems) : (0, import_node_path8.join)((0, import_node_path8.dirname)(file), "problems");
-  const cardsDir = parsed.cards ? (0, import_node_path8.resolve)(cwd, parsed.cards) : (0, import_node_path8.join)((0, import_node_path8.dirname)(file), "cards");
+  const problemsDir = parsed.problems ? (0, import_node_path9.resolve)(cwd, parsed.problems) : (0, import_node_path9.join)((0, import_node_path9.dirname)(file), "problems");
+  const cardsDir = parsed.cards ? (0, import_node_path9.resolve)(cwd, parsed.cards) : (0, import_node_path9.join)((0, import_node_path9.dirname)(file), "cards");
   for (const [flag, dir] of [["--problems", problemsDir], ["--cards", cardsDir]]) {
     if (!isDir(dir)) {
       err(`No such directory: ${dir}${parsed[flag === "--problems" ? "problems" : "cards"] ? "" : ` (give ${flag} <dir>)`}`);
       return 2;
     }
   }
-  const text = (0, import_node_fs7.readFileSync)(file, "utf8");
-  const lockPath = (0, import_node_path8.join)((0, import_node_path8.dirname)(file), ACHIEVEMENTS_LOCK_FILE);
-  const lock = (0, import_node_fs7.existsSync)(lockPath) ? (0, import_node_fs7.readFileSync)(lockPath, "utf8") : void 0;
+  const text = (0, import_node_fs8.readFileSync)(file, "utf8");
+  const lockPath = (0, import_node_path9.join)((0, import_node_path9.dirname)(file), ACHIEVEMENTS_LOCK_FILE);
+  const lock = (0, import_node_fs8.existsSync)(lockPath) ? (0, import_node_fs8.readFileSync)(lockPath, "utf8") : void 0;
   let topics;
   try {
-    topics = readTopics((0, import_node_fs7.readFileSync)((0, import_node_path8.join)(cardsDir, "tags.json"), "utf8")).map((t) => t.id);
+    topics = readTopics((0, import_node_fs8.readFileSync)((0, import_node_path9.join)(cardsDir, "tags.json"), "utf8")).map((t) => t.id);
   } catch (e) {
-    err(e instanceof CardFileError ? `${(0, import_node_path8.join)(displayPath3(cardsDir), "tags.json")}: ${e.detail}` : String(e));
+    err(e instanceof CardFileError ? `${(0, import_node_path9.join)(displayPath3(cardsDir), "tags.json")}: ${e.detail}` : String(e));
     return 2;
   }
   let raw;
@@ -22535,7 +23521,7 @@ Usage:
 ${ACHIEVEMENTS_USAGE}`);
     return 2;
   }
-  const file = args[0] ? (0, import_node_path8.resolve)(cwd, args[0]) : findAchievementsFile(cwd);
+  const file = args[0] ? (0, import_node_path9.resolve)(cwd, args[0]) : findAchievementsFile(cwd);
   if (!file) {
     err(`Not inside the Proschi repository; give the achievements file
 
@@ -22543,13 +23529,13 @@ Usage:
 ${ACHIEVEMENTS_USAGE}`);
     return 2;
   }
-  if (!(0, import_node_fs7.existsSync)(file) || !(0, import_node_fs7.statSync)(file).isFile()) {
+  if (!(0, import_node_fs8.existsSync)(file) || !(0, import_node_fs8.statSync)(file).isFile()) {
     err(`No such file: ${args[0] ?? file}`);
     return 2;
   }
   let raw;
   try {
-    raw = JSON.parse((0, import_node_fs7.readFileSync)(file, "utf8"));
+    raw = JSON.parse((0, import_node_fs8.readFileSync)(file, "utf8"));
   } catch (e) {
     err(`${displayPath3(file)}: not valid JSON: ${e.message}`);
     return 1;
@@ -22559,12 +23545,12 @@ ${ACHIEVEMENTS_USAGE}`);
     return 1;
   }
   const ids = raw.flatMap((a) => a && typeof a === "object" && typeof a.id === "string" ? [a.id] : []);
-  const lockPath = (0, import_node_path8.join)((0, import_node_path8.dirname)(file), ACHIEVEMENTS_LOCK_FILE);
-  const before2 = (0, import_node_fs7.existsSync)(lockPath) ? (0, import_node_fs7.readFileSync)(lockPath, "utf8") : void 0;
-  const existing = before2 !== void 0 ? readLock(before2).ids : [];
+  const lockPath = (0, import_node_path9.join)((0, import_node_path9.dirname)(file), ACHIEVEMENTS_LOCK_FILE);
+  const before2 = (0, import_node_fs8.existsSync)(lockPath) ? (0, import_node_fs8.readFileSync)(lockPath, "utf8") : void 0;
+  const existing = before2 !== void 0 ? readLock2(before2).ids : [];
   const added = [...new Set(ids)].filter((id) => !existing.includes(id)).sort();
   const text = writeAchievementsLock(existing, ids);
-  if (before2 !== text) (0, import_node_fs7.writeFileSync)(lockPath, text);
+  if (before2 !== text) (0, import_node_fs8.writeFileSync)(lockPath, text);
   out(added.length ? `Added ${added.length} id${added.length === 1 ? "" : "s"} to ${displayPath3(lockPath)}:
   ${added.join("\n  ")}` : `${displayPath3(lockPath)} already lists every achievement`);
   return 0;
@@ -22581,8 +23567,8 @@ ${ACHIEVEMENTS_USAGE}`);
 }
 
 // src/game.ts
-var import_node_fs8 = require("node:fs");
-var import_node_path9 = require("node:path");
+var import_node_fs9 = require("node:fs");
+var import_node_path10 = require("node:path");
 
 // ../frontend/src/game/engine/compile.ts
 var BACKFILL_PREFIX = "backfill_";
@@ -24341,27 +25327,6 @@ function ownerOf(t) {
   return void 0;
 }
 
-// ../frontend/src/sim/overlay.ts
-function flowsOf(diagram, traffic) {
-  const flows = /* @__PURE__ */ new Map();
-  for (const t of traffic) {
-    const u = findUseCase(diagram, t.useCase);
-    if (!u || t.rps <= 0) continue;
-    for (const sc of u.scenarios) {
-      const share = t.mix ? t.mix.find((m) => m.scenario === sc.name)?.share ?? 0 : sc === u.scenarios[0] ? 1 : 0;
-      if (share <= 0) continue;
-      for (const step of sc.steps) {
-        if (step.failed) continue;
-        const key = `${step.fromServiceId}>${step.toServiceId}`;
-        const f = flows.get(key) ?? { from: step.fromServiceId, to: step.toServiceId, rps: 0, async: step.executionType !== "SYNC_REQUEST_RESPONSE" };
-        f.rps += t.rps * share * (step.multiplier ?? 1);
-        flows.set(key, f);
-      }
-    }
-  }
-  return [...flows.values()];
-}
-
 // ../frontend/src/game/engine/tick.ts
 var LOC = { line: 0, col: 0, length: 0 };
 var PROFILE_CACHE = /* @__PURE__ */ new Map();
@@ -25250,7 +26215,7 @@ function structuredCloneAction(a) {
 }
 
 // ../frontend/src/game/engine/check.ts
-var LOCK_FILE2 = "ids.lock";
+var LOCK_FILE3 = "ids.lock";
 function applyPlay(board, play) {
   const b = cloneBoard(board);
   for (const id of play.remove ?? []) {
@@ -25346,13 +26311,13 @@ function checkGame(files, ctx) {
   const violations = errors.map((e) => ({ file: e.file, message: e.message.replace(/^[^:]*: /, ""), ...e.line ? { line: e.line } : {} }));
   const v = (file, message) => violations.push({ file, message });
   const runs = [];
-  const lockText = files[LOCK_FILE2];
+  const lockText = files[LOCK_FILE3];
   const ids = publishedIds(content);
-  if (lockText === void 0) v(LOCK_FILE2, "Missing: run `proschi game lock`");
+  if (lockText === void 0) v(LOCK_FILE3, "Missing: run `proschi game lock`");
   else {
     const locked = new Set(lockText.split(/\r?\n/).map((l) => l.trim()).filter((l) => l && !l.startsWith("#")));
-    for (const id of ids) if (!locked.has(id)) v(LOCK_FILE2, `'${id}' is not in ids.lock: run \`proschi game lock\``);
-    for (const id of locked) if (!ids.includes(id)) v(LOCK_FILE2, `'${id}' was published and is gone: ids are never deleted (progress and replays refer to them)`);
+    for (const id of ids) if (!locked.has(id)) v(LOCK_FILE3, `'${id}' is not in ids.lock: run \`proschi game lock\``);
+    for (const id of locked) if (!ids.includes(id)) v(LOCK_FILE3, `'${id}' was published and is gone: ids are never deleted (progress and replays refer to them)`);
   }
   const learn = (file, list) => {
     for (const id of list) if (!ctx.cards.has(id)) v(file, `Review card '${id}' does not exist`);
@@ -25679,22 +26644,22 @@ var GAME_HELP = `game    Scale or Fail, the system design game (docs/GAME.md).
         sim plays a scenario's reference run (or --run) and prints every
         wave: traffic, cost, revenue, score, Trust and what broke. --basic
         plays it under the basic rules of a first run.`;
-var REPO_GAME = (0, import_node_path9.join)("frontend", "src", "game", "content");
+var REPO_GAME = (0, import_node_path10.join)("frontend", "src", "game", "content");
 function findGameDir(cwd = process.cwd()) {
-  for (let dir = (0, import_node_path9.resolve)(cwd); ; dir = (0, import_node_path9.dirname)(dir)) {
-    const candidate = (0, import_node_path9.join)(dir, REPO_GAME);
-    if ((0, import_node_fs8.existsSync)(candidate) && (0, import_node_fs8.statSync)(candidate).isDirectory()) return candidate;
-    if ((0, import_node_path9.dirname)(dir) === dir) return void 0;
+  for (let dir = (0, import_node_path10.resolve)(cwd); ; dir = (0, import_node_path10.dirname)(dir)) {
+    const candidate = (0, import_node_path10.join)(dir, REPO_GAME);
+    if ((0, import_node_fs9.existsSync)(candidate) && (0, import_node_fs9.statSync)(candidate).isDirectory()) return candidate;
+    if ((0, import_node_path10.dirname)(dir) === dir) return void 0;
   }
 }
 function readGameFolder(dir) {
   const files = {};
   const walk = (d) => {
-    for (const entry of (0, import_node_fs8.readdirSync)(d, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs9.readdirSync)(d, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) continue;
-      const full = (0, import_node_path9.join)(d, entry.name);
+      const full = (0, import_node_path10.join)(d, entry.name);
       if (entry.isDirectory()) walk(full);
-      else files[(0, import_node_path9.relative)(dir, full).split("\\").join("/")] = (0, import_node_fs8.readFileSync)(full, "utf8");
+      else files[(0, import_node_path10.relative)(dir, full).split("\\").join("/")] = (0, import_node_fs9.readFileSync)(full, "utf8");
     }
   };
   walk(dir);
@@ -25706,22 +26671,22 @@ function cardContext(dir, cwd) {
   const cards = /* @__PURE__ */ new Set();
   const topics = /* @__PURE__ */ new Set();
   if (cardsDir) {
-    for (const topic of (0, import_node_fs8.readdirSync)(cardsDir, { withFileTypes: true })) {
+    for (const topic of (0, import_node_fs9.readdirSync)(cardsDir, { withFileTypes: true })) {
       if (!topic.isDirectory()) continue;
-      for (const f of (0, import_node_fs8.readdirSync)((0, import_node_path9.join)(cardsDir, topic.name))) if (f.endsWith(".md")) cards.add(f.slice(0, -3));
+      for (const f of (0, import_node_fs9.readdirSync)((0, import_node_path10.join)(cardsDir, topic.name))) if (f.endsWith(".md")) cards.add(f.slice(0, -3));
     }
-    const tags = (0, import_node_path9.join)(cardsDir, "tags.json");
-    if ((0, import_node_fs8.existsSync)(tags)) for (const t of readTopics((0, import_node_fs8.readFileSync)(tags, "utf8"))) topics.add(t.id);
+    const tags = (0, import_node_path10.join)(cardsDir, "tags.json");
+    if ((0, import_node_fs9.existsSync)(tags)) for (const t of readTopics((0, import_node_fs9.readFileSync)(tags, "utf8"))) topics.add(t.id);
   }
-  const problems = new Set(problemsDir ? (0, import_node_fs8.readdirSync)(problemsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name) : []);
+  const problems = new Set(problemsDir ? (0, import_node_fs9.readdirSync)(problemsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name) : []);
   return { cards, topics, problems };
 }
 var escape6 = (s) => s.replace(/%/g, "%25").replace(/\r?\n/g, "%0A");
 function formatGameCheck(dir, check, style) {
   const shown = displayPath3(dir);
   if (style === "json") return JSON.stringify({ dir: shown, scenarios: check.content.scenarios.length, runs: check.runs, violations: check.violations }, null, 2);
-  if (style === "github") return check.violations.map((v) => `::error file=${(0, import_node_path9.join)(shown, v.file)},line=${v.line ?? 1},title=proschi game::${escape6(v.message)}`).join("\n");
-  const lines = check.violations.map((v) => `${(0, import_node_path9.join)(shown, v.file)}${v.line ? `:${v.line}` : ""}: ${v.message}`);
+  if (style === "github") return check.violations.map((v) => `::error file=${(0, import_node_path10.join)(shown, v.file)},line=${v.line ?? 1},title=proschi game::${escape6(v.message)}`).join("\n");
+  const lines = check.violations.map((v) => `${(0, import_node_path10.join)(shown, v.file)}${v.line ? `:${v.line}` : ""}: ${v.message}`);
   for (const r of check.runs) lines.push(`  ${r.scenario}/${r.name}: ${r.outcome ?? "running"} after ${r.waves} wave(s), score ${r.score}, ${Math.round(r.ms)} ms`);
   const c = check.content;
   lines.push(
@@ -25771,7 +26736,7 @@ ${GAME_USAGE}`);
   return a;
 }
 function resolveDir2(dirArg, cwd, err) {
-  const dir = dirArg ? (0, import_node_path9.resolve)(cwd, dirArg) : findGameDir(cwd);
+  const dir = dirArg ? (0, import_node_path10.resolve)(cwd, dirArg) : findGameDir(cwd);
   if (!dir) {
     err(`Not inside the Proschi repository; give the game content directory
 
@@ -25779,7 +26744,7 @@ Usage:
 ${GAME_USAGE}`);
     return void 0;
   }
-  if (!(0, import_node_fs8.existsSync)(dir) || !(0, import_node_fs8.statSync)(dir).isDirectory()) {
+  if (!(0, import_node_fs9.existsSync)(dir) || !(0, import_node_fs9.statSync)(dir).isDirectory()) {
     err(`No such directory: ${dirArg ?? dir}`);
     return void 0;
   }
@@ -25820,13 +26785,13 @@ function gameLock(args, out, err, cwd) {
   if (!a) return 2;
   const dir = resolveDir2(a.positional[0], cwd, err);
   if (!dir) return 2;
-  const lockPath = (0, import_node_path9.join)(dir, LOCK_FILE2);
-  const existing = (0, import_node_fs8.existsSync)(lockPath) ? (0, import_node_fs8.readFileSync)(lockPath, "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l && !l.startsWith("#")) : [];
+  const lockPath = (0, import_node_path10.join)(dir, LOCK_FILE3);
+  const existing = (0, import_node_fs9.existsSync)(lockPath) ? (0, import_node_fs9.readFileSync)(lockPath, "utf8").split(/\r?\n/).map((l) => l.trim()).filter((l) => l && !l.startsWith("#")) : [];
   const ids = contentIds(readGameFolder(dir));
   const added = ids.filter((id) => !existing.includes(id)).sort();
   const all = [.../* @__PURE__ */ new Set([...existing, ...ids])].sort();
   const text = LOCK_HEADER2 + all.join("\n") + "\n";
-  if (!(0, import_node_fs8.existsSync)(lockPath) || (0, import_node_fs8.readFileSync)(lockPath, "utf8") !== text) (0, import_node_fs8.writeFileSync)(lockPath, text);
+  if (!(0, import_node_fs9.existsSync)(lockPath) || (0, import_node_fs9.readFileSync)(lockPath, "utf8") !== text) (0, import_node_fs9.writeFileSync)(lockPath, text);
   out(added.length ? `Added ${added.length} id${added.length === 1 ? "" : "s"} to ${displayPath3(lockPath)}:
   ${added.join("\n  ")}` : `${displayPath3(lockPath)} already lists every id`);
   return 0;
@@ -25854,8 +26819,8 @@ ${GAME_USAGE}`);
     err(`No scenario '${scenario}'; there are ${content.scenarios.map((s2) => s2.id).join(", ")}`);
     return 2;
   }
-  const runPath = a.run ? (0, import_node_path9.resolve)(cwd, a.run) : void 0;
-  const text = runPath ? (0, import_node_fs8.existsSync)(runPath) ? (0, import_node_fs8.readFileSync)(runPath, "utf8") : void 0 : files[`scenarios/${scenario}/reference.json`];
+  const runPath = a.run ? (0, import_node_path10.resolve)(cwd, a.run) : void 0;
+  const text = runPath ? (0, import_node_fs9.existsSync)(runPath) ? (0, import_node_fs9.readFileSync)(runPath, "utf8") : void 0 : files[`scenarios/${scenario}/reference.json`];
   if (text === void 0) {
     err(runPath ? `No such file: ${a.run}` : `Scenario '${scenario}' has no reference.json; give one with --run`);
     return 2;
@@ -25907,8 +26872,8 @@ ${GAME_USAGE}`);
 }
 
 // src/share.ts
-var import_node_fs9 = require("node:fs");
-var import_node_path10 = require("node:path");
+var import_node_fs10 = require("node:fs");
+var import_node_path11 = require("node:path");
 
 // ../frontend/src/playground/share.ts
 var import_lz_string = __toESM(require_lz_string(), 1);
@@ -25934,24 +26899,31 @@ var SHARE_HELP = `share-link
         Prints a link that opens the file (with the files it imports) in the
         web editor; nothing is uploaded, the diagram is in the link. --base
         sets the editor's address (default ${DEFAULT_BASE}).`;
-function shareLink(source2, name, dir, base = DEFAULT_BASE) {
+function shareLink(file, base = DEFAULT_BASE) {
+  const entry = (0, import_node_path11.resolve)(file);
+  const name = (0, import_node_path11.basename)(entry);
+  const source2 = (0, import_node_fs10.readFileSync)(entry, "utf8");
+  const disk = fileResolver({ entry });
+  const where = /* @__PURE__ */ new Map([[name, entry]]);
   const read = {};
   const result = parse(source2, {
     path: name,
-    resolve: (importPath, fromPath) => {
-      const key = joinImportPath(fromPath, importPath);
+    resolve: (importPath, fromKey) => {
+      const found = disk(importPath, fromKey === void 0 ? entry : where.get(fromKey));
+      const key = resolveImportPath(fromKey, importPath);
       if (key === name) return { path: key, source: "" };
-      const abs = (0, import_node_path10.resolve)(dir, key);
-      if (!(0, import_node_fs9.existsSync)(abs) || !(0, import_node_fs9.statSync)(abs).isFile()) return void 0;
-      read[key] ??= (0, import_node_fs9.readFileSync)(abs, "utf8");
+      if (!found) return void 0;
+      where.set(key, found.path);
+      read[key] ??= found.source;
       return { path: key, source: read[key] };
     }
   });
+  if (disk.errors.size) return { errors: [...new Set(disk.errors.values())] };
   const imports = {};
   for (const { resolved } of result.imports ?? []) {
     if (resolved !== void 0 && resolved !== name && Object.prototype.hasOwnProperty.call(read, resolved)) imports[resolved] = read[resolved];
   }
-  return base.replace(/#.*$/, "") + encodeShareHash(source2, void 0, imports);
+  return { url: base.replace(/#.*$/, "") + encodeShareHash(source2, void 0, imports) };
 }
 function runShareLink(args, out, err) {
   let base = DEFAULT_BASE;
@@ -25978,20 +26950,23 @@ ${SHARE_USAGE}`);
 ${SHARE_USAGE}`);
     return 2;
   }
-  const [file] = paths;
-  let source2;
+  let link;
   try {
-    source2 = (0, import_node_fs9.readFileSync)(file, "utf8");
+    link = shareLink(paths[0], base);
   } catch (e) {
     err(String(e.message));
     return 2;
   }
-  out(shareLink(source2, (0, import_node_path10.basename)(file), (0, import_node_path10.dirname)((0, import_node_path10.resolve)(file)), base));
+  if ("errors" in link) {
+    err(link.errors.map((e) => `error: ${e}`).join("\n"));
+    return 1;
+  }
+  out(link.url);
   return 0;
 }
 
 // src/importCommand.ts
-var import_node_fs10 = require("node:fs");
+var import_node_fs11 = require("node:fs");
 var import_yaml2 = __toESM(require_dist(), 1);
 
 // ../frontend/src/dsl/importMermaid.ts
@@ -26591,20 +27566,289 @@ ${IMPORT_USAGE}`);
   }
   let text;
   try {
-    text = (0, import_node_fs10.readFileSync)(file, "utf8");
+    text = (0, import_node_fs11.readFileSync)(file, "utf8");
   } catch (e) {
     err(`Cannot read ${file}: ${e.message}`);
     return 2;
   }
   const result = format3 === "mermaid" ? fromMermaid(text) : openApiFromText(text, (t) => (0, import_yaml2.parse)(t));
   for (const w of result.warnings) err(`${file}:${w.line ? `${w.line}:` : ""} warning: ${w.message}`);
-  if (output) (0, import_node_fs10.writeFileSync)(output, result.source);
+  if (output) (0, import_node_fs11.writeFileSync)(output, result.source);
   else out(result.source.trimEnd());
   return 0;
 }
 
+// src/sync.ts
+var import_node_fs13 = require("node:fs");
+
+// src/fetchers.ts
+var import_node_child_process = require("node:child_process");
+var import_node_fs12 = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path12 = require("node:path");
+var GIT_TIMEOUT_MS = 12e4;
+var HTTPS_TIMEOUT_MS = 3e4;
+var MAX_REDIRECTS = 5;
+var defaultGitUrl = (repo) => `https://${repo}.git`;
+function hardening(noHooks) {
+  return [
+    "-c",
+    `core.hooksPath=${noHooks}`,
+    "-c",
+    "core.fsmonitor=false",
+    "-c",
+    "protocol.ext.allow=never",
+    "-c",
+    "fetch.recurseSubmodules=false",
+    "-c",
+    "submodule.recurse=false",
+    "-c",
+    "transfer.fsckObjects=true"
+  ];
+}
+function gitEnv() {
+  const env = { ...process.env };
+  for (const name of ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_OBJECT_DIRECTORY", "GIT_ALTERNATE_OBJECT_DIRECTORIES", "GIT_COMMON_DIR", "GIT_NAMESPACE"]) delete env[name];
+  return env;
+}
+var GitScratch = class {
+  dir = (0, import_node_fs12.mkdtempSync)((0, import_node_path12.join)((0, import_node_os.tmpdir)(), "proschi-git-"));
+  repo = (0, import_node_path12.join)(this.dir, "repo.git");
+  noHooks = (0, import_node_path12.join)(this.dir, "no-hooks");
+  constructor() {
+    (0, import_node_fs12.mkdirSync)(this.noHooks);
+    this.git(["init", "--bare", "--quiet", this.repo], false);
+  }
+  git(args, inRepo = true, encoding = "utf8") {
+    try {
+      return (0, import_node_child_process.execFileSync)("git", [...hardening(this.noHooks), ...inRepo ? ["-C", this.repo] : [], ...args], {
+        env: gitEnv(),
+        timeout: GIT_TIMEOUT_MS,
+        maxBuffer: MAX_IMPORT_BYTES + 1024 * 1024,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: encoding === "utf8" ? "utf8" : "buffer"
+      });
+    } catch (e) {
+      const stderr = String(e.stderr ?? "").trim();
+      throw new ImportError(`git ${args[0]} failed${stderr ? `: ${stderr.split("\n").pop()}` : ""}`);
+    }
+  }
+  /** Fetches one ref (or commit) shallowly and returns the commit it points at. */
+  fetch(url, ref) {
+    this.git(["fetch", "--quiet", "--depth=1", "--no-tags", "--no-recurse-submodules", "--", url, ref]);
+    return String(this.git(["rev-parse", "--verify", "FETCH_HEAD^{commit}"])).trim();
+  }
+  /** A regular file at `path` in `commit`: never a symlink or submodule, at most MAX_IMPORT_BYTES. */
+  read(commit, path, spec) {
+    const entry = String(this.git(["ls-tree", "-z", commit, "--", path]));
+    const match = /^(\d{6}) (\w+) ([0-9a-f]{40,64})\t/.exec(entry);
+    if (!match) throw new ImportError(`'${spec}': no such file in the repository at ${commit.slice(0, 12)}`);
+    const [, mode, type, oid] = match;
+    if (type !== "blob" || mode !== "100644" && mode !== "100755") throw new ImportError(`'${spec}' is not a regular file (a symlink, folder or submodule)`);
+    const size = Number(String(this.git(["cat-file", "-s", oid])).trim());
+    if (size > MAX_IMPORT_BYTES) throw new ImportError(`'${spec}' is larger than ${MAX_IMPORT_BYTES / 1e6} MB`);
+    return this.git(["cat-file", "blob", oid], true, "buffer");
+  }
+  dispose() {
+    (0, import_node_fs12.rmSync)(this.dir, { recursive: true, force: true });
+  }
+};
+async function fetchHttps(url, fetchImpl = fetch) {
+  let current = new URL(url);
+  for (let redirects = 0; ; redirects++) {
+    if (current.protocol !== "https:") throw new ImportError(`'${url}' redirects to ${current.protocol}//; only https:// is allowed`);
+    if (current.username || current.password) throw new ImportError(`'${url}' redirects to a URL with credentials`);
+    let response2;
+    try {
+      response2 = await fetchImpl(current.href, { redirect: "manual", signal: AbortSignal.timeout(HTTPS_TIMEOUT_MS) });
+    } catch (e) {
+      throw new ImportError(`Cannot download '${url}': ${e.message}`);
+    }
+    if (response2.status >= 300 && response2.status < 400) {
+      const location = response2.headers.get("location");
+      if (!location || redirects >= MAX_REDIRECTS) throw new ImportError(`'${url}' redirects too often or without a location`);
+      current = new URL(location, current);
+      continue;
+    }
+    if (!response2.ok) throw new ImportError(`Cannot download '${url}': HTTP ${response2.status}`);
+    if (Number(response2.headers.get("content-length") ?? 0) > MAX_IMPORT_BYTES) throw new ImportError(`'${url}' is larger than ${MAX_IMPORT_BYTES / 1e6} MB`);
+    const chunks = [];
+    let size = 0;
+    const reader = response2.body?.getReader();
+    for (; ; ) {
+      const chunk = reader ? await reader.read() : { done: true, value: void 0 };
+      if (chunk.done) break;
+      size += chunk.value.byteLength;
+      if (size > MAX_IMPORT_BYTES) {
+        await reader?.cancel();
+        throw new ImportError(`'${url}' is larger than ${MAX_IMPORT_BYTES / 1e6} MB`);
+      }
+      chunks.push(chunk.value);
+    }
+    return Buffer.concat(chunks);
+  }
+}
+
+// src/sync.ts
+var IMPORTS_USAGE = `  proschi imports sync [--frozen] [<file|dir>...]`;
+var IMPORTS_HELP = `imports sync
+        Downloads the git: and https:// imports of the files (default: the
+        current folder) into .proschi/cache and pins them in proschi.lock.
+        No other command uses the network. --frozen fails instead of
+        changing proschi.lock (for CI).`;
+var staleLock = (what) => new ImportError(`${LOCK_FILE} is out of date: ${what}; run proschi imports sync and commit ${LOCK_FILE}`);
+async function syncImports(entries2, { frozen = false, fetch: fetch2, gitUrl = defaultGitUrl } = {}) {
+  const roots = [...new Set(entries2.map((e) => projectRoot(e)))];
+  if (roots.length !== 1) {
+    const errors2 = roots.length ? [`The files belong to different project roots (${roots.map((r) => displayPath3(r)).join(", ")}); sync each separately`] : ["No .proschi files to sync"];
+    return { root: roots[0] ?? "", lock: emptyLock(), errors: errors2, written: false };
+  }
+  const [root] = roots;
+  const lock = emptyLock();
+  let old;
+  try {
+    old = readLock(root);
+  } catch (e) {
+    return { root, lock, errors: [e.message], written: false };
+  }
+  if (frozen && !old) return { root, lock, errors: [`${LOCK_FILE} is missing; run proschi imports sync and commit it`], written: false };
+  const texts = /* @__PURE__ */ new Map();
+  const failed = /* @__PURE__ */ new Map();
+  const scratches = /* @__PURE__ */ new Map();
+  const commits = /* @__PURE__ */ new Map();
+  const obtain = async (spec) => {
+    const remote = parseRemoteSpec(spec);
+    const cached = (hash) => {
+      try {
+        return hash ? readCached(root, hash, spec) : void 0;
+      } catch {
+        return void 0;
+      }
+    };
+    const changed = (pin) => new ImportError(`'${spec}' does not match its sha256 in ${LOCK_FILE} (${pin}); its content changed. If that is expected, delete its entry from ${LOCK_FILE} and sync again`);
+    if (remote.kind === "https") {
+      const pinned = old?.https[remote.url];
+      if (frozen && !pinned) throw staleLock(`'${spec}' is not locked`);
+      let bytes2 = cached(pinned);
+      if (!bytes2) {
+        bytes2 = await fetchHttps(remote.url, fetch2);
+        if (pinned && sha256(bytes2) !== pinned) throw changed(`sha256 ${pinned.slice(0, 12)}`);
+        writeCached(root, bytes2);
+      }
+      lock.https[remote.url] = sha256(bytes2);
+      return bytes2;
+    }
+    const key = gitKey(remote.repo, remote.ref);
+    const pinnedEntry = old?.git[key];
+    const pinnedHash = pinnedEntry?.files[remote.path];
+    if (frozen && !pinnedHash) throw staleLock(`'${spec}' is not locked`);
+    let bytes = cached(pinnedHash);
+    let commit = pinnedEntry?.commit;
+    if (!bytes) {
+      let scratch = scratches.get(remote.repo);
+      if (!scratch) scratches.set(remote.repo, scratch = new GitScratch());
+      if (!commits.has(key)) {
+        const got = scratch.fetch(gitUrl(remote.repo), commit ?? remote.ref);
+        if (commit && got !== commit) throw new ImportError(`'${spec}': fetching the locked commit ${commit} gave ${got}`);
+        if (/^[0-9a-f]{40}$/.test(remote.ref) && got !== remote.ref) throw new ImportError(`'${spec}': the ref is a commit but resolved to ${got}`);
+        commits.set(key, got);
+      }
+      commit = commits.get(key);
+      bytes = scratch.read(commit, remote.path, spec);
+      if (pinnedHash && sha256(bytes) !== pinnedHash) throw changed(`commit ${commit.slice(0, 12)}`);
+      writeCached(root, bytes);
+    }
+    lock.git[key] ??= { commit, files: {} };
+    lock.git[key].files[remote.path] = sha256(bytes);
+    return bytes;
+  };
+  let errors = [];
+  try {
+    for (let round2 = 0; round2 <= MAX_IMPORT_DEPTH + 1; round2++) {
+      const pending = /* @__PURE__ */ new Set();
+      const found = /* @__PURE__ */ new Set();
+      for (const entry of entries2) {
+        const resolver = fileResolver({
+          entry,
+          remote: (spec) => {
+            if (texts.has(spec)) return texts.get(spec);
+            if (!failed.has(spec)) pending.add(spec);
+            return void 0;
+          }
+        });
+        parse((0, import_node_fs13.readFileSync)(entry, "utf8"), { path: entry, resolve: resolver });
+        for (const [where, message] of resolver.errors) {
+          const from = where.split("\0")[0] || entry;
+          found.add(`${isRemoteSpec(from) ? from : displayPath3(from)}: ${message}`);
+        }
+      }
+      if (pending.size === 0) {
+        errors = [...found];
+        break;
+      }
+      for (const spec of pending) {
+        try {
+          texts.set(spec, (await obtain(spec)).toString("utf8"));
+        } catch (e) {
+          if (!(e instanceof ImportError)) throw e;
+          failed.set(spec, e.message);
+        }
+      }
+    }
+  } finally {
+    for (const scratch of scratches.values()) scratch.dispose();
+  }
+  errors.push(...failed.values());
+  if (errors.length) return { root, lock, errors, written: false };
+  const text = formatLock(lock);
+  if (old && text !== formatLock(old)) {
+    if (frozen) return { root, lock, errors: [staleLock("it locks imports that are no longer used").message], written: false };
+  }
+  const write = !frozen && (old ? text !== formatLock(old) : Object.keys(lock.git).length + Object.keys(lock.https).length > 0);
+  if (write) writeLock(root, lock);
+  return { root, lock, errors, written: write };
+}
+async function runImports(args, collectFiles2, out, err, options = {}) {
+  const [sub, ...rest] = args;
+  if (sub !== "sync") {
+    err(`Usage:
+${IMPORTS_USAGE}`);
+    return 2;
+  }
+  let frozen = false;
+  const paths = [];
+  for (const arg of rest) {
+    if (arg === "--frozen") frozen = true;
+    else if (arg.startsWith("-")) {
+      err(`Unknown option ${arg}
+
+Usage:
+${IMPORTS_USAGE}`);
+      return 2;
+    } else paths.push(arg);
+  }
+  let files;
+  try {
+    files = collectFiles2(paths.length ? paths : ["."]);
+  } catch (e) {
+    err(String(e.message));
+    return 2;
+  }
+  const result = await syncImports(files, { ...options, frozen });
+  if (result.errors.length) {
+    err(result.errors.map((e) => `error: ${e}`).join("\n"));
+    return 1;
+  }
+  const sources = Object.keys(result.lock.git).length + Object.keys(result.lock.https).length;
+  const filesLocked = Object.values(result.lock.git).reduce((n, g) => n + Object.keys(g.files).length, 0) + Object.keys(result.lock.https).length;
+  const lockPath = displayPath3(`${result.root}/${LOCK_FILE}`);
+  if (!sources) out("No git: or https:// imports to sync");
+  else out(`${filesLocked} remote file(s) from ${sources} source(s) ${result.written ? "locked in" : "match"} ${lockPath}`);
+  return 0;
+}
+
 // src/cli.ts
-var VERSION2 = true ? "0.11.0" : "dev";
+var VERSION2 = true ? "0.13.0" : "dev";
 var USAGE = `Usage:
   proschi check [--strict] [--format text|github|json] [--openapi <node>=<spec>]... <file|dir>...
   proschi parse <file>
@@ -26617,6 +27861,7 @@ ${ACHIEVEMENTS_USAGE}
 ${GAME_USAGE}
 ${SHARE_USAGE}
 ${IMPORT_USAGE}
+${IMPORTS_USAGE}
   proschi --version
 
 check   Reports errors and warnings. Directories are searched for *.proschi files.
@@ -26635,19 +27880,20 @@ ${CARDS_HELP}
 ${ACHIEVEMENTS_HELP}
 ${GAME_HELP}
 ${SHARE_HELP}
-${IMPORT_HELP}`;
+${IMPORT_HELP}
+${IMPORTS_HELP}`;
 function collectFiles(paths) {
   const out = [];
   const walk = (dir) => {
-    for (const entry of (0, import_node_fs11.readdirSync)(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    for (const entry of (0, import_node_fs14.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_path11.join)(dir, entry.name);
+      const full = (0, import_node_path13.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_fs11.statSync)(p).isDirectory()) walk(p);
+    if ((0, import_node_fs14.statSync)(p).isDirectory()) walk(p);
     else out.push(p);
   }
   return out;
@@ -26701,6 +27947,7 @@ function run(argv, out = console.log, err = console.error) {
   if (command === "game") return runGame(rest, out, err);
   if (command === "share-link") return runShareLink(rest, out, err);
   if (command === "import") return runImport(rest, out, err);
+  if (command === "imports") return runImports(rest, collectFiles, out, err);
   if (command === "check") {
     let strict = false;
     let style = "text";