proschi 0.11.0 → 0.13.0

package/dist/server.cjs

@@ -1303,8 +1303,8 @@ var require_semaphore = __commonJS({
         this._waiting = [];
       }
       lock(thunk) {
-        return new Promise((resolve4, reject) => {
-          this._waiting.push({ thunk, resolve: resolve4, reject });
+        return new Promise((resolve3, reject) => {
+          this._waiting.push({ thunk, resolve: resolve3, reject });
           this.runNext();
         });
       }
@@ -2930,9 +2930,9 @@ ${JSON.stringify(message, null, 4)}`);
           if (typeof cancellationStrategy.sender.enableCancellation === "function") {
             cancellationStrategy.sender.enableCancellation(requestMessage);
           }
-          return new Promise(async (resolve4, reject) => {
+          return new Promise(async (resolve3, reject) => {
             const resolveWithCleanup = (r) => {
-              resolve4(r);
+              resolve3(r);
               cancellationStrategy.sender.cleanup(id);
               disposable?.dispose();
             };
@@ -8574,8 +8574,8 @@ var require_server = __commonJS({
         if (value instanceof Promise) {
           return value;
         } else if (Is2.thenable(value)) {
-          return new Promise((resolve4, reject) => {
-            value.then((resolved) => resolve4(resolved), (error) => reject(error));
+          return new Promise((resolve3, reject) => {
+            value.then((resolved) => resolve3(resolved), (error) => reject(error));
           });
         } else {
           return Promise.resolve(value);
@@ -8859,7 +8859,7 @@ var require_files = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.FileSystem = void 0;
     exports2.uriToFilePath = uriToFilePath;
-    exports2.resolve = resolve4;
+    exports2.resolve = resolve3;
     exports2.resolveGlobalNodePath = resolveGlobalNodePath;
     exports2.resolveGlobalYarnPath = resolveGlobalYarnPath;
     exports2.resolveModulePath = resolveModulePath;
@@ -8888,7 +8888,7 @@ var require_files = __commonJS({
     function isWindows() {
       return process.platform === "win32";
     }
-    function resolve4(moduleName, nodePath, cwd, tracer) {
+    function resolve3(moduleName, nodePath, cwd, tracer) {
       const nodePathKey = "NODE_PATH";
       const app = [
         "var p = process;",
@@ -8907,7 +8907,7 @@ var require_files = __commonJS({
         "}",
         "});"
       ].join("");
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve4, reject) => {
         const env = process.env;
         const newEnv = /* @__PURE__ */ Object.create(null);
         Object.keys(env).forEach((key) => newEnv[key] = env[key]);
@@ -8939,7 +8939,7 @@ var require_files = __commonJS({
             if (message2.c === "r") {
               cp.send({ c: "e" });
               if (message2.s) {
-                resolve5(message2.r);
+                resolve4(message2.r);
               } else {
                 reject(new Error(`Failed to resolve module: ${moduleName}`));
               }
@@ -9067,17 +9067,17 @@ var require_files = __commonJS({
         if (!path.isAbsolute(nodePath)) {
           nodePath = path.join(workspaceRoot, nodePath);
         }
-        return resolve4(moduleName, nodePath, nodePath, tracer).then((value) => {
+        return resolve3(moduleName, nodePath, nodePath, tracer).then((value) => {
           if (FileSystem.isParent(nodePath, value)) {
             return value;
           } else {
             return Promise.reject(new Error(`Failed to load ${moduleName} from node path location.`));
           }
         }).then(void 0, (_error) => {
-          return resolve4(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
+          return resolve3(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
         });
       } else {
-        return resolve4(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
+        return resolve3(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
       }
     }
   }
@@ -9159,10 +9159,10 @@ var require_ril = __commonJS({
         return api_1.Disposable.create(() => this.stream.off("end", listener));
       }
       write(data, encoding) {
-        return new Promise((resolve4, reject) => {
+        return new Promise((resolve3, reject) => {
           const callback = (error) => {
             if (error === void 0 || error === null) {
-              resolve4();
+              resolve3();
             } else {
               reject(error);
             }
@@ -9454,10 +9454,10 @@ var require_main = __commonJS({
     }
     function createClientPipeTransport(pipeName, encoding = "utf-8") {
       let connectResolve;
-      const connected = new Promise((resolve4, _reject) => {
-        connectResolve = resolve4;
+      const connected = new Promise((resolve3, _reject) => {
+        connectResolve = resolve3;
       });
-      return new Promise((resolve4, reject) => {
+      return new Promise((resolve3, reject) => {
         const server = (0, net_1.createServer)((socket) => {
           server.close();
           connectResolve([
@@ -9468,7 +9468,7 @@ var require_main = __commonJS({
         server.on("error", reject);
         server.listen(pipeName, () => {
           server.removeListener("error", reject);
-          resolve4({
+          resolve3({
             onConnected: () => {
               return connected;
             }
@@ -9485,10 +9485,10 @@ var require_main = __commonJS({
     }
     function createClientSocketTransport(port, encoding = "utf-8") {
       let connectResolve;
-      const connected = new Promise((resolve4, _reject) => {
-        connectResolve = resolve4;
+      const connected = new Promise((resolve3, _reject) => {
+        connectResolve = resolve3;
       });
-      return new Promise((resolve4, reject) => {
+      return new Promise((resolve3, reject) => {
         const server = (0, net_1.createServer)((socket) => {
           server.close();
           connectResolve([
@@ -9505,7 +9505,7 @@ var require_main = __commonJS({
             return;
           }
           const boundPort = address.port;
-          resolve4({
+          resolve3({
             port: () => boundPort,
             onConnected: () => {
               return connected;
@@ -12856,7 +12856,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve4.call(this, root, ref);
+      let _sch = resolve3.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -12883,7 +12883,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve4(root, ref) {
+    function resolve3(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -13713,7 +13713,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve4(baseURI, relativeURI, options) {
+    function resolve3(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const {
         parsed: baseParsed,
@@ -14082,7 +14082,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve4,
+      resolve: resolve3,
       resolveComponent,
       equal,
       serialize,
@@ -21292,10 +21292,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,
@@ -21309,7 +21309,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)
@@ -21333,7 +21333,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],
@@ -21349,7 +21349,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];
@@ -21440,7 +21440,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) {
@@ -21454,13 +21454,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:
@@ -21503,18 +21503,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)
@@ -21568,8 +21568,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))
@@ -21581,7 +21581,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,
@@ -21592,8 +21592,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") {
@@ -21610,7 +21610,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);
@@ -21790,7 +21790,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";
@@ -21807,24 +21807,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;
         }
       }
@@ -22007,25 +22007,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 = "";
@@ -22835,14 +22835,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);
@@ -24009,18 +24009,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 (scalar.end) {
-            sep = scalar.end;
-            sep.push(this.sourceToken);
+            sep2 = scalar.end;
+            sep2.push(this.sourceToken);
             delete scalar.end;
           } else
-            sep = [this.sourceToken];
+            sep2 = [this.sourceToken];
           const map = {
             type: "block-map",
             offset: scalar.offset,
             indent: scalar.indent,
-            items: [{ start, key: scalar, sep }]
+            items: [{ start, key: scalar, sep: sep2 }]
           };
           this.onKeyLine = true;
           this.stack[this.stack.length - 1] = map;
@@ -24173,15 +24173,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);
@@ -24375,13 +24375,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;
@@ -24912,7 +24912,7 @@ function getWellformedEdit(textEdit) {
 }
 
 // src/server.ts
-var import_node_fs4 = require("node:fs");
+var import_node_fs5 = require("node:fs");
 
 // src/openapi/config.ts
 var import_node_fs2 = require("node:fs");
@@ -25933,6 +25933,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"];
@@ -25977,7 +25979,7 @@ var DID_YOU_MEAN = /^Unknown tech stack '(.*)'\. Did you mean '([^']+)'\?/;
 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. */
@@ -25998,7 +26000,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;
@@ -26020,14 +26027,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}`);
@@ -26050,7 +26061,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);
@@ -26067,14 +26079,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;
@@ -26095,13 +26109,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();
@@ -26123,6 +26141,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;
@@ -26177,7 +26200,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;
     }
@@ -26209,7 +26232,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;
@@ -26229,7 +26252,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;
@@ -26279,21 +26302,13 @@ var Parser = class {
     const loc = this.locOf(pathToken, line);
     const entry = { path, loc };
     this.imports.push(entry);
-    const { resolve: resolve4 } = this.options;
-    if (!resolve4) {
+    const { resolve: resolve3 } = this.options;
+    if (!resolve3) {
       this.warning(`Imports are not resolved in this context; '${path}' was not loaded`, loc);
       return;
     }
-    let target;
-    try {
-      target = resolve4(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) {
@@ -26313,6 +26328,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();
@@ -26372,6 +26406,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) {
@@ -26561,7 +26862,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) {
@@ -26596,6 +26898,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;
@@ -27506,7 +27809,9 @@ var Parser = class {
     for (const step of raw) {
       this.checkConnection(step);
       if (step.arrow === "-->") {
-        const request2 = [...steps].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 = [...steps].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;
@@ -27525,14 +27830,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 === "->>";
       steps.push({
         id: `${prefix}-${steps.length + 1}`,
         stepOrder: steps.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 ?? "",
@@ -27548,7 +27856,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 steps;
@@ -27558,8 +27868,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() {
@@ -27655,6 +27967,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}
@@ -27690,6 +28013,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;
 }
@@ -28489,6 +28829,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 targets = r.useCase === void 0 ? [...entered] : [findUseCase(team, r.useCase)].filter((u) => !!u && entered.has(u));
+    for (const u of targets) {
+      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 steps = scenario ? scenario.steps : u.scenarios.flatMap((s) => s.steps);
+      const saturated = steps.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;
@@ -28646,6 +29320,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);
@@ -28731,6 +29406,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);
@@ -28769,12 +29445,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 pathOf2 = (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 };
       })
     )
@@ -28804,6 +29481,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) };
@@ -28814,9 +29492,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();
@@ -28866,6 +29550,7 @@ function runTests(diagram, analysis = analyze(diagram), options = {}) {
     const { passed, message, hint } = requirement(run, r);
     return { id: `req:${i + 1}`, name: requirementName(r), category: CATEGORY[r.kind], passed, message, hint, loc: r.loc };
   });
+  results.push(...systemResults(diagram, analysis));
   const names = /* @__PURE__ */ new Map();
   for (const test of diagram.tests ?? []) {
     const n = (names.get(test.name) ?? 0) + 1;
@@ -28874,6 +29559,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",
@@ -29412,7 +30117,7 @@ var KEYWORDS2 = [
   { label: "par", detail: "Steps that run in parallel", snippet: "par {\n	$0\n}" },
   { label: "alt", detail: "One scenario of a use case", snippet: 'alt "${1:Scenario}" {\n	$0\n}' },
   { label: "legend", detail: 'Styles that .tag applies: owned "Owned by us" green', snippet: 'legend {\n	${1:tag} "${2:What it means}" ${3:blue}$0\n}' },
-  // Layout hints (docs/LANGUAGE.md, "Steering the layout").
+  // Layout hints (docs/STYLING.md, "Steering the layout").
   { label: "direction", detail: "Where edges flow: down, right, up or left (top level or in a group)", snippet: "direction ${1|down,right,up,left|}" },
   { label: "layout ordered", detail: "Lay edges out by declaration order (top level)", snippet: "layout ordered" },
   // High-level design sections (top level).
@@ -29443,14 +30148,282 @@ var ASSERTIONS = [
 ];
 
 // src/imports.ts
+var import_node_fs4 = require("node:fs");
+var import_node_path5 = 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("/");
+}
+
+// src/lock.ts
+var import_node_crypto = require("node:crypto");
 var import_node_fs3 = require("node:fs");
 var import_node_path4 = require("node:path");
-function fileResolver(read = () => void 0, toPath = (p) => p) {
-  return (importPath, fromPath) => {
-    const abs = (0, import_node_path4.resolve)(fromPath ? (0, import_node_path4.dirname)(fromPath) : process.cwd(), importPath);
-    const text = read(abs) ?? ((0, import_node_fs3.existsSync)(abs) && (0, import_node_fs3.statSync)(abs).isFile() ? (0, import_node_fs3.readFileSync)(abs, "utf8") : void 0);
-    return text === void 0 ? void 0 : { path: toPath(abs), source: text };
+
+// 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 json;
+  try {
+    json = JSON.parse(text);
+  } catch (e) {
+    throw invalid(e.message);
+  }
+  if (!isRecord(json) || json.version !== 1) throw invalid('expected {"version": 1, \u2026}');
+  const lock = emptyLock();
+  const git = json.git ?? {};
+  const https = json.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_path4.join)(root, LOCK_FILE);
+  return (0, import_node_fs3.existsSync)(file) ? parseLock((0, import_node_fs3.readFileSync)(file, "utf8")) : void 0;
+}
+var cacheFile = (root, hash) => (0, import_node_path4.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_fs3.existsSync)(file)) return void 0;
+  const bytes = (0, import_node_fs3.readFileSync)(file);
+  if (sha256(bytes) !== hash) throw remoteError.altered(spec);
+  return bytes;
+}
+
+// src/imports.ts
+function displayPath2(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;
+}
+var MAX_IMPORT_BYTES = 1e6;
+var MAX_IMPORT_FILES = 500;
+var MAX_IMPORT_DEPTH = 32;
+function projectRoot(entry) {
+  const dir = (0, import_node_path5.dirname)((0, import_node_path5.resolve)(entry));
+  const config = findConfigFile(dir);
+  if (config) return (0, import_node_fs4.realpathSync)((0, import_node_path5.dirname)(config));
+  for (let current = dir; ; current = (0, import_node_path5.dirname)(current)) {
+    if ((0, import_node_fs4.existsSync)((0, import_node_path5.join)(current, ".git"))) return (0, import_node_fs4.realpathSync)(current);
+    if ((0, import_node_path5.dirname)(current) === current) break;
+  }
+  return (0, import_node_fs4.realpathSync)((0, import_node_fs4.existsSync)(dir) ? dir : process.cwd());
+}
+var isInside = (root, path) => {
+  const rel = (0, import_node_path5.relative)(root, path);
+  return rel === "" || rel !== ".." && !rel.startsWith(`..${import_node_path5.sep}`) && !(0, import_node_path5.isAbsolute)(rel);
+};
+function realLocation(path) {
+  let existing = path;
+  while (!(0, import_node_fs4.existsSync)(existing) && (0, import_node_path5.dirname)(existing) !== existing) existing = (0, import_node_path5.dirname)(existing);
+  return (0, import_node_path5.join)((0, import_node_fs4.realpathSync)(existing), (0, import_node_path5.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_path5.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_path5.resolve)(fromPath ? (0, import_node_path5.dirname)((0, import_node_path5.resolve)(fromPath)) : root, importPath);
+    if (!isInside(root, realLocation(abs))) {
+      const link = (0, import_node_fs4.existsSync)(abs) && (0, import_node_fs4.lstatSync)(abs).isSymbolicLink();
+      throw new ImportError(
+        link ? `'${importPath}' is a symlink to a file outside the project root ${displayPath2(root)}` : `'${importPath}' is outside the project root ${displayPath2(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_fs4.existsSync)(abs)) return void 0;
+    const stat = (0, import_node_fs4.statSync)(abs);
+    if (!stat.isFile()) return void 0;
+    if (stat.size > MAX_IMPORT_BYTES) throw tooLarge(importPath);
+    return found(toPath(abs), (0, import_node_fs4.readFileSync)((0, import_node_fs4.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 reachableFrom(result, start) {
   const reached = /* @__PURE__ */ new Set([start]);
@@ -29472,12 +30445,12 @@ function ownDiagnostics(result) {
     if (i.loc.file !== void 0 || i.resolved === void 0) continue;
     const files = reachableFrom(result, i.resolved);
     const errors = result.diagnostics.filter((d) => d.severity === "error" && d.file !== void 0 && files.has(d.file)).length;
-    if (errors) own.push({ severity: "error", message: `'${(0, import_node_path4.basename)(i.path)}' has ${errors} error${errors === 1 ? "" : "s"}`, ...i.loc });
+    if (errors) own.push({ severity: "error", message: `'${(0, import_node_path5.basename)(i.path)}' has ${errors} error${errors === 1 ? "" : "s"}`, ...i.loc });
   }
   return own.sort((a, b) => a.line - b.line || a.col - b.col);
 }
 function importLinks(result) {
-  return (result.imports ?? []).filter((i) => i.loc.file === void 0 && i.resolved !== void 0).map((i) => {
+  return (result.imports ?? []).filter((i) => i.loc.file === void 0 && i.resolved !== void 0 && !isRemoteSpec(i.resolved)).map((i) => {
     const range = toRange(i.loc);
     return {
       range: { start: { ...range.start, character: range.start.character + 1 }, end: { ...range.end, character: Math.max(range.start.character + 1, range.end.character - 1) } },
@@ -29784,7 +30757,7 @@ function positionAt(text, offset) {
 
 // src/server.ts
 if (process.argv.includes("--version")) {
-  console.log(true ? "0.11.0" : "dev");
+  console.log(true ? "0.13.0" : "dev");
   process.exit(0);
 }
 var connection = (0, import_node.createConnection)(import_node.ProposedFeatures.all);
@@ -29795,11 +30768,13 @@ var uriOf = (path) => (0, import_node_url.pathToFileURL)(path).href;
 function openText(path) {
   return documents.all().find((d) => pathOf(d.uri) === path)?.getText();
 }
-var resolve3 = fileResolver(openText);
 function analysisOf(doc) {
   const cached = cache2.get(doc.uri);
   if (cached?.version === doc.version) return cached.analysis;
-  const analysis = analyze2(doc.getText(), { path: pathOf(doc.uri), resolve: resolve3 });
+  const path = pathOf(doc.uri);
+  const resolve3 = fileResolver({ entry: path, read: openText });
+  const analysis = analyze2(doc.getText(), { path, resolve: resolve3 });
+  resolve3.explain(analysis.result);
   const files = new Set((analysis.result.imports ?? []).flatMap((i) => i.resolved ? [i.resolved] : []));
   cache2.set(doc.uri, { version: doc.version, analysis, files });
   return analysis;
@@ -29828,7 +30803,7 @@ connection.onInitialize(() => ({
     codeActionProvider: { codeActionKinds: [import_node.CodeActionKind.QuickFix] },
     semanticTokensProvider: { legend: { tokenTypes: TOKEN_TYPES, tokenModifiers: [] }, full: true }
   },
-  serverInfo: { name: "proschi-language-server", version: true ? "0.11.0" : "dev" }
+  serverInfo: { name: "proschi-language-server", version: true ? "0.13.0" : "dev" }
 }));
 function validate(document) {
   const analysis = analysisOf(document);
@@ -29872,7 +30847,7 @@ documents.onDidChangeContent(({ document }) => {
 function watchedStamp() {
   return watchedFiles().map((file) => {
     try {
-      return `${file}:${(0, import_node_fs4.statSync)(file).mtimeMs}`;
+      return `${file}:${(0, import_node_fs5.statSync)(file).mtimeMs}`;
     } catch {
       return `${file}:missing`;
     }