@eriknaslund/skiss 0.3.0 → 0.5.0

package/dist/cli.js

@@ -1,16 +1,99 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { readFile, writeFile } from "fs/promises";
-import { basename, extname } from "path";
+import { spawnSync } from "child_process";
+import { constants } from "fs";
+import { access, mkdtemp, readFile, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { basename, delimiter, extname, join } from "path";
 import { parseArgs } from "util";
 
+// src/inheritance.ts
+function inheritance(classes) {
+  const declared = /* @__PURE__ */ new Map();
+  for (const cls of classes) {
+    if (!declared.has(cls.name.text)) declared.set(cls.name.text, cls);
+  }
+  const circles = /* @__PURE__ */ new Map();
+  const parentOf = (cls) => {
+    if (cls.parent === void 0 || circles.has(cls)) return void 0;
+    return declared.get(cls.parent.text);
+  };
+  for (const cls of declared.values()) {
+    const path = [cls];
+    const seen = new Set(path);
+    for (let next = parentOf(cls); next !== void 0; next = parentOf(next)) {
+      if (seen.has(next)) {
+        const circle = path.slice(path.indexOf(next));
+        let closer = circle[0];
+        for (const member2 of circle) {
+          if (member2.line > closer.line) closer = member2;
+        }
+        const at = circle.indexOf(closer);
+        circles.set(closer, [...circle.slice(at), ...circle.slice(0, at)]);
+        break;
+      }
+      path.push(next);
+      seen.add(next);
+    }
+  }
+  const ancestors = (cls) => {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set([cls]);
+    for (let next = parentOf(cls); next !== void 0; next = parentOf(next)) {
+      if (seen.has(next)) break;
+      out.push(next);
+      seen.add(next);
+    }
+    return out;
+  };
+  const find = (cls, matches) => {
+    for (const from of ancestors(cls)) {
+      const field = from.fields.find(matches);
+      if (field !== void 0) return { field, from };
+    }
+    return void 0;
+  };
+  return {
+    ancestors,
+    inherited: (cls, fieldName) => find(cls, (field) => field.name.text === fieldName),
+    inheritedIdentifier: (cls) => find(cls, (field) => field.identifier),
+    circle: (cls) => circles.get(cls)
+  };
+}
+function sameField(child, inheritedField) {
+  return meaning(child) === meaning(inheritedField);
+}
+var meaning = (field) => JSON.stringify([
+  field.name.text,
+  field.identifier,
+  typeMeaning(field),
+  field.system?.text,
+  field.joinsTo === void 0 ? void 0 : [field.joinsTo.className.text, field.joinsTo.fieldName.text],
+  field.description,
+  field.note
+]);
+function typeMeaning(field) {
+  const type = field.type;
+  if (type === void 0) return void 0;
+  switch (type.kind) {
+    case "primitive":
+      return [type.kind, type.name, type.many];
+    case "class":
+    case "unknown":
+      return [type.kind, type.name.text, type.many];
+    case "enum":
+      return [type.kind, type.values.map((v) => v.text), type.many];
+  }
+}
+
 // src/parse.ts
 var isWs = (c) => c === " " || c === "	";
 var trimWs = (s) => s.replace(/^[ \t]+/, "").replace(/[ \t]+$/, "");
 var CLASS_NAME = /^[A-Z][A-Za-z0-9]*$/;
 var FIELD_NAME = /^[a-z][A-Za-z0-9]*$/;
-var SYSTEM_OR_VALUE = /^[A-Za-z][A-Za-z0-9_-]*$/;
+var SYSTEM_NAME = /^[A-Za-z][A-Za-z0-9_-]*$/;
+var ENUM_VALUE = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
 var PRIMITIVES = {
   string: "string",
   int: "int",
@@ -27,7 +110,7 @@ function primitiveFor(word) {
   return Object.hasOwn(PRIMITIVES, word) ? PRIMITIVES[word] : void 0;
 }
 var FIELD_ORDER = "name, `*`, `: type`, `@System`, `= Class.field`, then `#` and `?`";
-var CLASS_ORDER = "name, `@System`, `~ Class`, then `#` and `?`";
+var CLASS_ORDER = "name, `< Parent`, `@System`, `~ Class`, then `#` and `?`";
 function parse(source) {
   const classes = [];
   const diagnostics = [];
@@ -114,7 +197,7 @@ function splitTrailer(text) {
   return trailer;
 }
 var WORD = /[\p{L}\p{N}_-]+/uy;
-var OPERATORS = ["*", ":", "@", "~", "=", ".", "|", "["];
+var OPERATORS = ["*", ":", "@", "~", "=", ".", "|", "<", ",", "["];
 function tokenize(head) {
   const tokens = [];
   let i = 0;
@@ -176,6 +259,13 @@ function parseClassLine(text, line) {
     );
   }
   const node = { name: name(head, line), line };
+  const lt = peek(c);
+  if (lt?.kind === "<") {
+    take(c);
+    const parent = parseParent(c, lt);
+    if (!parent.ok) return parent;
+    node.parent = parent.value;
+  }
   const at = peek(c);
   if (at?.kind === "@") {
     take(c);
@@ -305,6 +395,31 @@ function parseFieldLine(text, line) {
   if (trailer.note !== void 0) node.note = trailer.note;
   return { ok: true, value: node };
 }
+function parseParent(c, lt) {
+  const parent = take(c);
+  if (parent === void 0 || parent.kind !== "word") {
+    return fail(
+      "E_UNPARSABLE",
+      "Expected a class name after `<`, e.g. `Jedi < Character`",
+      c.line,
+      parent ?? afterSpan(lt)
+    );
+  }
+  if (!CLASS_NAME.test(parent.text)) {
+    const message = Object.hasOwn(PRIMITIVES, parent.text) ? `\`${parent.text}\` is a primitive, not a class; a parent is a class` : `The class after \`<\` must be UpperCamelCase: \`${parent.text}\``;
+    return fail("E_BAD_NAME", message, c.line, parent);
+  }
+  const next = peek(c);
+  if (next?.kind === "," || next?.kind === "<") {
+    return fail(
+      "E_UNPARSABLE",
+      "A class has one parent; `<` takes a single class name",
+      c.line,
+      next
+    );
+  }
+  return { ok: true, value: name(parent, c.line) };
+}
 function parseSystem(c, at) {
   const system = take(c);
   if (system === void 0 || system.kind !== "word") {
@@ -315,7 +430,7 @@ function parseSystem(c, at) {
       system ?? afterSpan(at)
     );
   }
-  if (!SYSTEM_OR_VALUE.test(system.text)) {
+  if (!SYSTEM_NAME.test(system.text)) {
     return fail(
       "E_UNPARSABLE",
       `A system name is letters, digits, \`-\` and \`_\`, starting with a letter: \`${system.text}\``,
@@ -373,10 +488,10 @@ function parseType(c, colon) {
   }
   if (words.length > 1) {
     for (const w of words) {
-      if (!SYSTEM_OR_VALUE.test(w.text)) {
+      if (!ENUM_VALUE.test(w.text)) {
         return fail(
           "E_UNPARSABLE",
-          `An enum value is letters, digits, \`-\` and \`_\`, starting with a letter: \`${w.text}\``,
+          `An enum value is letters, digits, \`-\` and \`_\`, and does not start with \`-\` or \`_\`: \`${w.text}\``,
           c.line,
           w
         );
@@ -414,7 +529,7 @@ function parseType(c, colon) {
   );
 }
 function unexpected(token, line, kind, order) {
-  const modifiers = kind === "field" ? ["*", ":", "@", "="] : ["@", "~"];
+  const modifiers = kind === "field" ? ["*", ":", "@", "="] : ["<", "@", "~"];
   if (modifiers.includes(token.kind)) {
     return fail(
       "E_UNPARSABLE",
@@ -423,10 +538,10 @@ function unexpected(token, line, kind, order) {
       token
     );
   }
-  if (token.text === "<") {
+  if (token.kind === "<") {
     return fail(
       "E_UNPARSABLE",
-      "`<` is reserved for inheritance and not yet part of the language",
+      "`<` marks inheritance and belongs on the class line: `Child < Parent`",
       line,
       token
     );
@@ -455,10 +570,14 @@ function resolve(doc) {
   };
   const classes = out.classes;
   const declared = new Set(classes.map((c) => c.name.text));
-  const warnings = [];
+  const found = [];
   const undeclared = /* @__PURE__ */ new Map();
+  const tree = inheritance(classes);
   const warn = (code, message, at) => {
-    warnings.push({ severity: "warning", code, message, line: at.line, col: at.col, end: at.end });
+    found.push({ severity: "warning", code, message, line: at.line, col: at.col, end: at.end });
+  };
+  const error = (code, message, at) => {
+    found.push({ severity: "error", code, message, line: at.line, col: at.col, end: at.end });
   };
   const reference = (name2) => {
     if (declared.has(name2.text)) return true;
@@ -479,9 +598,25 @@ function resolve(doc) {
         cls.name
       );
     }
+    const parent = cls.parent;
+    if (parent !== void 0) {
+      reference(parent);
+      const circle = tree.circle(cls);
+      if (circle !== void 0) {
+        const through = circle.slice(1).map((member2) => `\`${member2.name.text}\``);
+        const path = through.length === 0 ? "" : ` through ${through.join(", ")}`;
+        error(
+          "E_INHERITANCE_CYCLE",
+          `class \`${cls.name.text}\` inherits from itself${path}; this \`<\` is not carried`,
+          parent
+        );
+        cls.parent = void 0;
+      }
+    }
     if (cls.similarTo !== void 0) reference(cls.similarTo);
     const firstField = /* @__PURE__ */ new Map();
-    let identifier;
+    const inheritedIdentifier = tree.inheritedIdentifier(cls);
+    let identifier = inheritedIdentifier?.field;
     for (const field of cls.fields) {
       const earlierField = firstField.get(field.name.text);
       if (earlierField === void 0) firstField.set(field.name.text, field);
@@ -495,14 +630,23 @@ function resolve(doc) {
       if (field.identifier) {
         if (identifier === void 0) identifier = field;
         else {
+          const from = identifier === inheritedIdentifier?.field ? ` inherits the identifier \`${identifier.name.text}\` from class \`${inheritedIdentifier.from.name.text}\`, line` : ` already has the identifier \`${identifier.name.text}\` on line`;
           warn(
             "W_MULTIPLE_IDENTIFIERS",
-            `\`*\` on \`${field.name.text}\` is ignored: class \`${cls.name.text}\` already has the identifier \`${identifier.name.text}\` on line ${identifier.line}`,
+            `\`*\` on \`${field.name.text}\` is ignored: class \`${cls.name.text}\`${from} ${identifier.line}`,
             field.identifierAt ?? field.name
           );
           field.identifier = false;
         }
       }
+      const replaced = tree.inherited(cls, field.name.text);
+      if (replaced !== void 0 && sameField(field, replaced.field)) {
+        warn(
+          "W_REDUNDANT_OVERRIDE",
+          `field \`${field.name.text}\` is identical to the one inherited from class \`${replaced.from.name.text}\` on line ${replaced.field.line}`,
+          field.name
+        );
+      }
       if (field.type?.kind === "unknown") {
         const word = field.type.name.text;
         const suggestion = closestTypeWord(word);
@@ -513,6 +657,18 @@ function resolve(doc) {
         );
       } else if (field.type?.kind === "class") {
         reference(field.type.name);
+      } else if (field.type?.kind === "enum") {
+        const seen = /* @__PURE__ */ new Set();
+        for (const value of field.type.values) {
+          if (seen.has(value.text)) {
+            warn(
+              "W_DUPLICATE_ENUM_VALUE",
+              `value \`${value.text}\` is already in this enum; it is carried once`,
+              value
+            );
+          }
+          seen.add(value.text);
+        }
       }
       if (field.joinsTo !== void 0) {
         const { className, fieldName } = field.joinsTo;
@@ -528,8 +684,8 @@ function resolve(doc) {
     }
   }
   const present2 = new Set(out.diagnostics.map(key));
-  for (const w of warnings) {
-    if (!present2.has(key(w))) out.diagnostics.push(w);
+  for (const d of found) {
+    if (!present2.has(key(d))) out.diagnostics.push(d);
   }
   out.diagnostics.sort((a, b) => a.line - b.line);
   out.undeclared = [...undeclared.values()].map((n) => ({ ...n }));
@@ -560,6 +716,7 @@ function copyField(f) {
 }
 function copyClass(c) {
   const out = { ...c, name: copyName(c.name), fields: c.fields.map(copyField) };
+  if (c.parent !== void 0) out.parent = copyName(c.parent);
   if (c.system !== void 0) out.system = copyName(c.system);
   if (c.similarTo !== void 0) out.similarTo = copyName(c.similarTo);
   return out;
@@ -626,7 +783,8 @@ function toLinkML(doc, opts) {
   const classNames = new Set(classes.map((cls) => cls.node.name.text));
   for (const name2 of resolved.undeclared) classNames.add(name2.text);
   const enums = nameEnums(classes, classNames);
-  const prefixes = { linkml: "https://w3id.org/linkml/" };
+  const prefixes = nameKeyed();
+  prefixes.linkml = "https://w3id.org/linkml/";
   if (!Object.hasOwn(prefixes, schemaName)) prefixes[schemaName] = `${BASE_URI}/${schemaName}/`;
   const systemPrefix = /* @__PURE__ */ new Map();
   const addSystem = (system) => {
@@ -657,12 +815,12 @@ function toLinkML(doc, opts) {
     prefixes,
     imports: ["linkml:types"]
   };
-  const out = {};
+  const out = nameKeyed();
   for (const cls of classes) {
     out[cls.node.name.text] = buildClass(cls, mappingPrefix, enums);
   }
   for (const name2 of resolved.undeclared) {
-    if (!(name2.text in out)) out[name2.text] = { annotations: { undeclared: true } };
+    if (!Object.hasOwn(out, name2.text)) out[name2.text] = { annotations: { undeclared: true } };
   }
   if (Object.keys(out).length > 0) schema.classes = out;
   const enumBlock = buildEnums(classes, enums);
@@ -720,13 +878,13 @@ function nameEnums(classes, classNames) {
   return names;
 }
 function buildEnums(classes, enums) {
-  const out = {};
+  const out = nameKeyed();
   for (const { node, fields } of classes) {
     for (const field of fields) {
       if (field.type?.kind !== "enum") continue;
       const name2 = enums.get(useKey(node.name.text, field.name.text));
-      if (name2 === void 0 || name2 in out) continue;
-      const values = {};
+      if (name2 === void 0 || Object.hasOwn(out, name2)) continue;
+      const values = nameKeyed();
       for (const value of field.type.values) values[value.text] = null;
       out[name2] = { permissible_values: values };
     }
@@ -737,6 +895,7 @@ function buildClass(cls, mappingPrefix, enums) {
   const { node, fields } = cls;
   const out = {};
   if (node.description !== void 0) out.description = node.description;
+  if (node.parent !== void 0) out.is_a = node.parent.text;
   const annotations = {};
   if (node.system !== void 0) annotations.system = node.system.text;
   if (node.note !== void 0) annotations.note = node.note;
@@ -745,7 +904,7 @@ function buildClass(cls, mappingPrefix, enums) {
     const target = node.similarTo.text;
     out.close_mappings = [`${mappingPrefix(target)}:${target}`];
   }
-  const attributes = {};
+  const attributes = nameKeyed();
   for (const field of fields) {
     attributes[field.name.text] = buildAttribute(field, node.name.text, enums);
   }
@@ -783,10 +942,12 @@ function rangeOf(field, className, enums) {
   }
 }
 var RESERVED_PREFIXES = /* @__PURE__ */ new Set(["linkml", "xsd", "shex", "schema"]);
+var PROTOTYPE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var nameKeyed = () => /* @__PURE__ */ Object.create(null);
 var linkmlName = (text) => {
   const name2 = text.toLowerCase().replace(/[^a-z0-9]/g, "_");
   if (!/[a-z0-9]/.test(name2)) return "sketch";
-  if (RESERVED_PREFIXES.has(name2)) return `${name2}_`;
+  if (RESERVED_PREFIXES.has(name2) || PROTOTYPE_KEYS.has(name2)) return `${name2}_`;
   return /^[0-9]/.test(name2) ? `_${name2}` : name2;
 };
 var capitalise = (text) => text.charAt(0).toUpperCase() + text.slice(1);
@@ -817,6 +978,7 @@ function toMermaid(doc, opts) {
   }
   for (const cls of resolved.classes) {
     const from = cls.name.text;
+    if (cls.parent !== void 0) lines.push(`  ${cls.parent.text} <|-- ${from}`);
     if (cls.similarTo !== void 0) lines.push(`  ${from} ..> ${cls.similarTo.text} : similar`);
     for (const field of cls.fields) {
       const type = field.type;
@@ -923,7 +1085,7 @@ function toSkiss(doc) {
 `;
 }
 function classBlock(cls) {
-  const head = cls.name.text + (cls.system === void 0 ? "" : ` @${cls.system.text}`) + (cls.similarTo === void 0 ? "" : ` ~ ${cls.similarTo.text}`);
+  const head = cls.name.text + (cls.parent === void 0 ? "" : ` < ${cls.parent.text}`) + (cls.system === void 0 ? "" : ` @${cls.system.text}`) + (cls.similarTo === void 0 ? "" : ` ~ ${cls.similarTo.text}`);
   return [withTrailer(head, cls), ...cls.fields.map(fieldLine)].join("\n");
 }
 function fieldLine(field) {
@@ -949,10 +1111,15 @@ function typeText2(type) {
   }
   return type.many ? `${text}[]` : text;
 }
+function writeDescription(text) {
+  const attached = text.replace(/[ \t]+\?(?=[ \t]|$)/g, "?");
+  return /^\?([ \t]|$)/.test(attached) ? `#${attached}` : `# ${attached}`;
+}
+var rewordsDescription = (text) => writeDescription(text) !== `# ${text}`;
 function withTrailer(head, node) {
   const parts2 = [];
   if (node.description !== void 0 && node.description !== "")
-    parts2.push(`# ${node.description}`);
+    parts2.push(writeDescription(node.description));
   if (node.note !== void 0 && node.note !== "") parts2.push(`? ${node.note}`);
   if (parts2.length === 0) return head;
   const gap = head.length < TRAILER_COLUMN - 1 ? " ".repeat(TRAILER_COLUMN - head.length) : "  ";
@@ -972,7 +1139,14 @@ var PRIMITIVE_RANGE = {
   uri: "uri",
   uriorcurie: "uri"
 };
-var CLASS_KEYS = /* @__PURE__ */ new Set(["description", "annotations", "close_mappings", "attributes", "slots"]);
+var CLASS_KEYS = /* @__PURE__ */ new Set([
+  "description",
+  "is_a",
+  "annotations",
+  "close_mappings",
+  "attributes",
+  "slots"
+]);
 var SLOT_KEYS = /* @__PURE__ */ new Set(["description", "annotations", "range", "multivalued", "identifier"]);
 var CLASS_TAGS = /* @__PURE__ */ new Set(["system", "note", "undeclared"]);
 var SLOT_TAGS = /* @__PURE__ */ new Set(["system", "note", "joins_to"]);
@@ -990,6 +1164,7 @@ var QUIET_SCHEMA_KEYS = /* @__PURE__ */ new Set([
   "slots",
   "enums"
 ]);
+var REWORDED = "a standalone `?` is attached to the word before it";
 var UNKNOWN_TYPE = /^[a-z][a-z0-9_-]*$/;
 function fromLinkML(schema) {
   const root = asRecord(schema);
@@ -1014,7 +1189,7 @@ function fromLinkML(schema) {
   for (const key2 of Object.keys(classDefs)) {
     const names = /* @__PURE__ */ new Map();
     const taken = /* @__PURE__ */ new Set();
-    for (const slot of slotKeysOf(asRecord(get(classDefs, key2)) ?? {})) {
+    for (const slot of fieldKeysOf(key2)) {
       names.set(slot, unique(toFieldName(slot), taken));
     }
     fieldNames.set(key2, names);
@@ -1033,7 +1208,7 @@ function fromLinkML(schema) {
     const rawValues = get(asRecord(get(enumDefs, key2)) ?? {}, "permissible_values");
     const values = asRecord(rawValues);
     const keys = Object.keys(values ?? {});
-    const bad = keys.find((value) => !SYSTEM_OR_VALUE.test(value));
+    const bad = keys.find((value) => !ENUM_VALUE.test(value));
     if (values === void 0 && present(rawValues)) {
       unwritable.set(key2, `${shown(rawValues)} is not a map of permissible values`);
     } else if (keys.length < 2) {
@@ -1064,14 +1239,32 @@ function fromLinkML(schema) {
       }
       continue;
     }
+    const undeclared = annotations.get("undeclared");
+    if (undeclared !== void 0 && typeof undeclared !== "boolean") {
+      report("annotation", name2, notText("undeclared", undeclared));
+    }
     const node = { name: at0(name2), fields: [], line: 0 };
     const description = oneLine(stringOf(get(def, "description")));
-    if (description !== void 0) node.description = description;
+    if (description !== void 0) {
+      node.description = description;
+      if (rewordsDescription(description)) report("reworded", name2, REWORDED);
+    }
     const system = annotations.get("system");
-    if (typeof system === "string" && SYSTEM_OR_VALUE.test(system)) node.system = at0(system);
-    else if (system !== void 0) report("annotation", name2, "`system` is not a system name");
-    const note = oneLine(stringOf(annotations.get("note")));
-    if (note !== void 0) node.note = note;
+    if (typeof system === "string") {
+      if (SYSTEM_NAME.test(system)) node.system = at0(system);
+      else report("annotation", name2, "`system` is not a system name");
+    } else if (system !== void 0) report("annotation", name2, notText("system", system));
+    const rawNote = annotations.get("note");
+    if (typeof rawNote === "string") {
+      const note = oneLine(rawNote);
+      if (note !== void 0) node.note = note;
+    } else if (rawNote !== void 0) report("annotation", name2, notText("note", rawNote));
+    const parent = stringOf(get(def, "is_a"));
+    if (parent !== void 0) {
+      const parentName = Object.hasOwn(classDefs, parent) ? classNameOf(parent) : toClassName(parent);
+      node.parent = at0(parentName);
+      reference(name2, parent, parentName);
+    }
     const mappings = stringList(get(def, "close_mappings"));
     const first = mappings[0];
     const target = first === void 0 ? "" : localName(first);
@@ -1094,6 +1287,9 @@ function fromLinkML(schema) {
           }
         }
         const block = get(def, other);
+        if (other === "is_a" && present(block) && stringOf(block) === void 0) {
+          report("is_a", name2, `${shown(block)} is not a class name`);
+        }
         if (other === "attributes" && present(block) && asRecord(block) === void 0) {
           report("attributes", name2, `${shown(block)} is not a map`);
         }
@@ -1108,10 +1304,12 @@ function fromLinkML(schema) {
           report("slot_usage", name2);
           continue;
         }
+        const written = slotKeysOf(def);
+        const inherited = inheritedSlots(key2);
         for (const slot of Object.keys(usage)) {
-          if (fieldNames.get(key2)?.has(slot) === true) {
+          if (written.includes(slot)) {
             report("slot_usage", `${name2}.${fieldNameOf(key2, slot)}`);
-          } else {
+          } else if (!inherited.has(slot)) {
             report("slot_usage", name2, `\`${slot}\` is inherited and not in the sketch`);
           }
         }
@@ -1119,9 +1317,10 @@ function fromLinkML(schema) {
       }
       report(other, name2);
     }
-    for (const slot of slotKeysOf(def)) {
+    const own = slotKeysOf(def);
+    for (const slot of fieldKeysOf(key2)) {
       const attributes = asRecord(get(def, "attributes")) ?? {};
-      const rawSlot = Object.hasOwn(attributes, slot) ? get(attributes, slot) : get(slotDefs, slot);
+      const rawSlot = !own.includes(slot) ? get(asRecord(get(def, "slot_usage")) ?? {}, slot) : Object.hasOwn(attributes, slot) ? get(attributes, slot) : get(slotDefs, slot);
       const slotDef = asRecord(rawSlot);
       if (slotDef === void 0 && present(rawSlot)) {
         report("slot", `${name2}.${fieldNameOf(key2, slot)}`, "is not a slot definition");
@@ -1176,13 +1375,18 @@ function fromLinkML(schema) {
       line: 0
     };
     const description = oneLine(stringOf(get(def, "description")));
-    if (description !== void 0) field.description = description;
+    if (description !== void 0) {
+      field.description = description;
+      if (rewordsDescription(description)) report("reworded", element, REWORDED);
+    }
     const type = typeFor(element, name2, def);
     if (type !== void 0) field.type = type;
     const annotations = annotationsOf(def);
     const system = annotations.get("system");
-    if (typeof system === "string" && SYSTEM_OR_VALUE.test(system)) field.system = at0(system);
-    else if (system !== void 0) report("annotation", element, "`system` is not a system name");
+    if (typeof system === "string") {
+      if (SYSTEM_NAME.test(system)) field.system = at0(system);
+      else report("annotation", element, "`system` is not a system name");
+    } else if (system !== void 0) report("annotation", element, notText("system", system));
     const joins = annotations.get("joins_to");
     if (typeof joins === "string") {
       const dot = joins.indexOf(".");
@@ -1195,9 +1399,12 @@ function fromLinkML(schema) {
         reference(element, target, targetClass);
         reference(element, targetField, targetName);
       } else report("annotation", element, "`joins_to` is not `Class.field`");
-    } else if (joins !== void 0) report("annotation", element, "`joins_to` is not text");
-    const note = oneLine(stringOf(annotations.get("note")));
-    if (note !== void 0) field.note = note;
+    } else if (joins !== void 0) report("annotation", element, notText("joins_to", joins));
+    const rawNote = annotations.get("note");
+    if (typeof rawNote === "string") {
+      const note = oneLine(rawNote);
+      if (note !== void 0) field.note = note;
+    } else if (rawNote !== void 0) report("annotation", element, notText("note", rawNote));
     for (const other of Object.keys(def)) {
       if (!SLOT_KEYS.has(other)) {
         report(other, element);
@@ -1250,6 +1457,34 @@ function fromLinkML(schema) {
     report("narrowed", element, `\`${range}\` is not a Skiss type; it falls back to string`);
     return { kind: "unknown", name: at0(word), many };
   }
+  function parentKeyOf(classKey) {
+    const def = asRecord(get(classDefs, classKey)) ?? {};
+    const parent = stringOf(get(def, "is_a"));
+    if (parent === void 0 || !Object.hasOwn(classDefs, parent)) return void 0;
+    return parent;
+  }
+  function inheritedSlots(classKey) {
+    const out = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set([classKey]);
+    let key2 = parentKeyOf(classKey);
+    while (key2 !== void 0 && !seen.has(key2)) {
+      seen.add(key2);
+      for (const slot of slotKeysOf(asRecord(get(classDefs, key2)) ?? {})) out.add(slot);
+      key2 = parentKeyOf(key2);
+    }
+    return out;
+  }
+  function fieldKeysOf(classKey) {
+    const def = asRecord(get(classDefs, classKey)) ?? {};
+    const keys = slotKeysOf(def);
+    const usage = asRecord(get(def, "slot_usage"));
+    if (usage === void 0) return keys;
+    const inherited = inheritedSlots(classKey);
+    for (const slot of Object.keys(usage)) {
+      if (inherited.has(slot) && !keys.includes(slot)) keys.push(slot);
+    }
+    return keys;
+  }
   function listedSomewhere(slot) {
     for (const key2 of Object.keys(classDefs)) {
       const def = asRecord(get(classDefs, key2)) ?? {};
@@ -1272,13 +1507,17 @@ var COUNTED = {
   class: ["class", "classes"],
   slot: ["slot", "slots"],
   schema: ["schema key", "schema keys"],
+  narrowed: ["narrowed range", "narrowed ranges"],
+  enum_detail: ["enum detail", "enum details"],
+  annotation: ["unreadable annotation", "unreadable annotations"],
+  reworded: ["description reworded", "descriptions reworded"],
   // `mixin: true` marks the class; `mixins: [M]` points at another one.
   mixin: ["mixin class", "mixin classes"],
   mixins: ["mixin", "mixins"],
   pattern: ["pattern", "patterns"],
   unit: ["unit", "units"]
 };
-var ENUM_KINDS = /* @__PURE__ */ new Set(["enum_detail"]);
+var UNREADABLE = "unreadable";
 function formatDropped(dropped) {
   const groups = /* @__PURE__ */ new Map();
   for (const entry of dropped) {
@@ -1287,15 +1526,21 @@ function formatDropped(dropped) {
     else group.push(entry);
   }
   const drops = [];
+  const notRead = [];
   let renamed = "";
   let inlined = "";
   for (const [kind, entries] of groups) {
+    if (kind === UNREADABLE) {
+      for (const entry of entries) notRead.push(entry.detail ?? "the schema could not be read");
+      continue;
+    }
     const phrase = phraseFor(kind, entries);
     if (kind === "renamed") renamed = phrase;
     else if (kind === "inlined") inlined = phrase;
     else drops.push(phrase);
   }
   const sentences = [];
+  if (notRead.length > 0) sentences.push(`Not read: ${notRead.join("; ")}.`);
   if (drops.length > 0) sentences.push(`Dropped: ${drops.join(", ")}.`);
   if (renamed !== "") sentences.push(`Renamed: ${renamed}.`);
   if (inlined !== "") sentences.push(`Inlined: ${inlined}.`);
@@ -1305,11 +1550,10 @@ function phraseFor(kind, entries) {
   const n = entries.length;
   const counted = Object.hasOwn(COUNTED, kind) ? COUNTED[kind] : void 0;
   if (counted !== void 0) return `${n} ${n === 1 ? counted[0] : counted[1]}`;
-  return `${kind} on ${n} ${nounFor(kind, entries)}`;
+  return `${kind} on ${n} ${nounFor(entries)}`;
 }
-function nounFor(kind, entries) {
+function nounFor(entries) {
   const one = entries.length === 1;
-  if (ENUM_KINDS.has(kind)) return one ? "enum" : "enums";
   const slots = entries.filter((entry) => entry.element.includes(".")).length;
   if (slots === entries.length) return one ? "slot" : "slots";
   if (slots === 0) return one ? "class" : "classes";
@@ -1360,12 +1604,18 @@ function annotationsOf(def) {
   if (annotations === void 0) return out;
   for (const tag of Object.keys(annotations)) {
     const raw = get(annotations, tag);
-    const value = asRecord(raw) === void 0 ? raw : get(asRecord(raw) ?? {}, "value");
-    if (typeof value === "string" || typeof value === "boolean") out.set(tag, value);
-    else out.set(tag, String(value));
+    const long = asRecord(raw);
+    const value = long === void 0 ? raw : get(long, "value");
+    out.set(tag, value ?? null);
   }
   return out;
 }
+function notText(tag, value) {
+  if (value === null) return `\`${tag}\` was written with no value`;
+  if (Array.isArray(value)) return `\`${tag}\` is a list, not text`;
+  if (typeof value === "object") return `\`${tag}\` is a map, not text`;
+  return `\`${tag}\` is a ${typeof value}, not text`;
+}
 function slotKeysOf(def) {
   const keys = Object.keys(asRecord(get(def, "attributes")) ?? {});
   for (const slot of stringList(get(def, "slots"))) {
@@ -1390,7 +1640,7 @@ var schemaElement = (root) => stringOf(get(root, "name")) ?? "schema";
 var nothing = (element, detail) => ({
   document: parse(""),
   source: "",
-  dropped: [{ kind: "schema", element, detail }]
+  dropped: [{ kind: UNREADABLE, element, detail }]
 });
 
 // src/import.ts
@@ -1417,7 +1667,7 @@ function notYAML(error) {
 }
 
 // src/index.ts
-var VERSION = "0.3.0";
+var VERSION = "0.5.0";
 
 // src/cli.ts
 var HELP = `Usage: skiss <command> [options]
@@ -1426,15 +1676,22 @@ Commands:
   diagram <file>       Write a Mermaid class diagram for a .skiss file.
   compile <file>       Write a LinkML schema for a .skiss file.
   import <file>        Write Skiss for a LinkML schema file, YAML or JSON.
+  render <file>        Write an SVG or a PNG of the class diagram, through
+                       the Mermaid CLI (mmdc), which must be installed.
                        <file> may be - to read standard input.
 
 Options:
   -o, --output <path>  Write the output to <path> instead of standard output
-      --notes          diagram: emit \`? text\` doubts as Mermaid notes
+      --notes          diagram, render: emit \`? text\` doubts as Mermaid notes
       --json           compile: write the schema as JSON instead of YAML
       --name <name>    compile: the schema name. Defaults to the file's
                        basename without its extension, or \`sketch\` for
                        standard input.
+      --format <fmt>   render: svg or png. Defaults to the extension of
+                       -o, and to svg when there is no -o. png needs an -o:
+                       only the SVG can go to standard output.
+      --scale <n>      render: the scale mmdc rasterises at. Defaults to 2
+                       for png, and to mmdc's own default for svg.
       --strict         Exit 1 when the input has any diagnostic; for import,
                        also when the projection dropped anything
   -h, --help           Show this help and exit
@@ -1450,8 +1707,12 @@ wrote has, so their line numbers are lines of that sketch.
 Exit codes:
   0  the output was produced
   1  --strict and the input has diagnostics (the output is still written)
-  2  usage error, missing file or unreadable input
+  2  usage error, missing file, or unreadable input: for import, a text no
+     schema could be read out of, which produces no sketch at all; for
+     render, the Mermaid CLI not being installed
   70 internal error, a bug in skiss
+
+render exits with mmdc's own status when mmdc ran and failed.
 `;
 var EXIT_OK = 0;
 var EXIT_STRICT = 1;
@@ -1460,7 +1721,8 @@ var EXIT_INTERNAL = 70;
 var COMMANDS = {
   diagram: ["output", "notes", "strict"],
   compile: ["output", "json", "name", "strict"],
-  import: ["output", "strict"]
+  import: ["output", "strict"],
+  render: ["output", "notes", "format", "scale", "strict"]
 };
 var isCommand = (text) => Object.hasOwn(COMMANDS, text);
 var UsageError = class extends Error {
@@ -1482,6 +1744,8 @@ async function main(argv) {
       notes: { type: "boolean" },
       json: { type: "boolean" },
       name: { type: "string" },
+      format: { type: "string" },
+      scale: { type: "string" },
       strict: { type: "boolean" },
       help: { type: "boolean", short: "h" },
       version: { type: "boolean" }
@@ -1511,8 +1775,16 @@ async function main(argv) {
     }
   }
   const source = file === "-" ? await readStdin() : await readSource(file);
-  const { output, diagnostics, dropped } = runCommand(command, source, file, values);
   const label = file === "-" ? "<stdin>" : file;
+  if (command === "render") {
+    const picture = compile(source, { target: "mermaid", notes: values.notes });
+    for (const d of picture.diagnostics) process.stderr.write(`${formatDiagnostic(d, label)}
+`);
+    const status = await render(picture.output, values);
+    if (status !== EXIT_OK) return status;
+    return values.strict === true && picture.diagnostics.length > 0 ? EXIT_STRICT : EXIT_OK;
+  }
+  const { output, diagnostics, dropped } = runCommand(command, source, file, values);
   const report = formatDropped(dropped);
   if (report !== "") process.stderr.write(`${report}
 `);
@@ -1520,9 +1792,15 @@ async function main(argv) {
 `);
   if (values.output === void 0) process.stdout.write(output);
   else await writeOutput(values.output, output);
+  if (unreadableInput(command, diagnostics, dropped)) return EXIT_USAGE;
   const strict = values.strict === true && (diagnostics.length > 0 || dropped.length > 0);
   return strict ? EXIT_STRICT : EXIT_OK;
 }
+function unreadableInput(command, diagnostics, dropped) {
+  if (command !== "import") return false;
+  if (dropped.some((entry) => entry.kind === "unreadable")) return true;
+  return diagnostics.some((d) => d.code === "E_NOT_YAML");
+}
 function runCommand(command, source, file, values) {
   if (command === "import") return importLinkML(source);
   if (command === "compile") {
@@ -1561,6 +1839,76 @@ async function writeOutput(path, text) {
     throw new UsageError(`cannot write \`${path}\`: ${reason(error)}`);
   }
 }
+var MMDC_MISSING = "skiss render needs the Mermaid CLI: npm install -g @mermaid-js/mermaid-cli";
+var isFormat = (text) => text === "svg" || text === "png";
+async function render(mermaid, values) {
+  const format = renderFormat(values);
+  const scale = renderScale(values.scale, format);
+  const mmdc = await findMmdc();
+  if (mmdc === void 0) {
+    process.stderr.write(`${MMDC_MISSING}
+`);
+    return EXIT_USAGE;
+  }
+  const dir = await mkdtemp(join(tmpdir(), "skiss-render-"));
+  try {
+    const input = join(dir, "diagram.mmd");
+    await writeFile(input, mermaid, "utf8");
+    const target = values.output ?? join(dir, `diagram.${format}`);
+    const args = ["-i", input, "-o", target, "-e", format, "-b", "transparent"];
+    if (scale !== void 0) args.push("--scale", scale);
+    const run = spawnSync(mmdc, args, {
+      stdio: ["ignore", "pipe", "inherit"],
+      encoding: "utf8"
+    });
+    if (run.error !== void 0)
+      throw new UsageError(`cannot run \`${mmdc}\`: ${reason(run.error)}`);
+    if (run.stdout !== "") process.stderr.write(run.stdout);
+    if (run.status !== EXIT_OK) return run.status ?? EXIT_INTERNAL;
+    if (values.output === void 0) process.stdout.write(await readFile(target, "utf8"));
+    return EXIT_OK;
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+function renderFormat(values) {
+  if (values.format !== void 0) {
+    if (!isFormat(values.format)) {
+      throw new UsageError(`unknown \`--format ${values.format}\`: svg or png`);
+    }
+    if (values.format === "png" && values.output === void 0) {
+      throw new UsageError(
+        "render --format png needs -o <path>: a PNG cannot go to standard output"
+      );
+    }
+    return values.format;
+  }
+  if (values.output === void 0) return "svg";
+  const extension = extname(values.output).slice(1).toLowerCase();
+  if (isFormat(extension)) return extension;
+  throw new UsageError(
+    `cannot tell the format of \`${values.output}\`: give --format svg or --format png`
+  );
+}
+function renderScale(scale, format) {
+  if (scale === void 0) return format === "png" ? "2" : void 0;
+  const value = Number(scale);
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new UsageError(`\`--scale ${scale}\` is not a positive number`);
+  }
+  return scale;
+}
+async function findMmdc() {
+  const onPath = (process.env.PATH ?? "").split(delimiter).filter((dir) => dir !== "").map((dir) => join(dir, "mmdc"));
+  for (const candidate of [...onPath, join(process.cwd(), "node_modules", ".bin", "mmdc")]) {
+    try {
+      await access(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+}
 function reason(error) {
   if (error instanceof Error) {
     const code = error.code;
@@ -1568,6 +1916,12 @@ function reason(error) {
   }
   return String(error);
 }
+for (const stream of [process.stdout, process.stderr]) {
+  stream.on("error", (error) => {
+    if (error.code === "EPIPE") process.exit(EXIT_OK);
+    throw error;
+  });
+}
 main(process.argv.slice(2)).then(
   (code) => {
     process.exitCode = code;