@eriknaslund/skiss 0.1.0

package/dist/cli.js

@@ -0,0 +1,1071 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFile, writeFile } from "fs/promises";
+import { basename, extname } from "path";
+import { parseArgs } from "util";
+
+// src/resolve.ts
+function resolve(doc) {
+  const out = {
+    ...doc,
+    classes: doc.classes.map(copyClass),
+    diagnostics: doc.diagnostics.map((d) => ({ ...d })),
+    undeclared: []
+  };
+  const classes = out.classes;
+  const declared = new Set(classes.map((c) => c.name.text));
+  const warnings = [];
+  const undeclared = /* @__PURE__ */ new Map();
+  const warn = (code, message, at) => {
+    warnings.push({ severity: "warning", code, message, line: at.line, col: at.col, end: at.end });
+  };
+  const reference = (name2) => {
+    if (declared.has(name2.text)) return true;
+    if (!undeclared.has(name2.text)) undeclared.set(name2.text, name2);
+    warn("W_UNDECLARED_CLASS", `class \`${name2.text}\` is not declared`, name2);
+    return false;
+  };
+  const firstClass = /* @__PURE__ */ new Map();
+  for (const cls of classes) {
+    const earlier = firstClass.get(cls.name.text);
+    if (earlier === void 0) firstClass.set(cls.name.text, cls);
+    else {
+      warn(
+        "W_DUPLICATE_CLASS",
+        `class \`${cls.name.text}\` is already declared on line ${earlier.line}`,
+        cls.name
+      );
+    }
+    if (cls.similarTo !== void 0) reference(cls.similarTo);
+    const firstField = /* @__PURE__ */ new Map();
+    let identifier;
+    for (const field of cls.fields) {
+      const earlierField = firstField.get(field.name.text);
+      if (earlierField === void 0) firstField.set(field.name.text, field);
+      else {
+        warn(
+          "W_DUPLICATE_FIELD",
+          `field \`${field.name.text}\` is already declared on line ${earlierField.line} in class \`${cls.name.text}\``,
+          field.name
+        );
+      }
+      if (field.identifier) {
+        if (identifier === void 0) identifier = field;
+        else {
+          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}`,
+            field.name
+          );
+          field.identifier = false;
+        }
+      }
+      if (field.type?.kind === "unknown") {
+        const word = field.type.name.text;
+        const suggestion = closestTypeWord(word);
+        warn(
+          "W_UNKNOWN_TYPE",
+          suggestion === void 0 ? `unknown type \`${word}\`, treated as \`string\`` : `unknown type \`${word}\`, did you mean \`${suggestion}\`?`,
+          field.type.name
+        );
+      } else if (field.type?.kind === "class") {
+        reference(field.type.name);
+      }
+      if (field.joinsTo !== void 0) {
+        const { className, fieldName } = field.joinsTo;
+        const hasField = (c) => c.name.text === className.text && c.fields.some((f) => f.name.text === fieldName.text);
+        if (reference(className) && !classes.some(hasField)) {
+          warn(
+            "W_UNDECLARED_FIELD",
+            `class \`${className.text}\` has no field \`${fieldName.text}\``,
+            fieldName
+          );
+        }
+      }
+    }
+  }
+  const present = new Set(out.diagnostics.map(key));
+  for (const w of warnings) {
+    if (!present.has(key(w))) out.diagnostics.push(w);
+  }
+  out.diagnostics.sort((a, b) => a.line - b.line);
+  out.undeclared = [...undeclared.values()].map((n) => ({ ...n }));
+  return out;
+}
+var copyName = (n) => ({ ...n });
+function copyType(t) {
+  switch (t.kind) {
+    case "primitive":
+      return { ...t, written: copyName(t.written) };
+    case "class":
+    case "unknown":
+      return { ...t, name: copyName(t.name) };
+    case "enum":
+      return { ...t, values: t.values.map(copyName) };
+  }
+}
+var copyJoin = (j) => ({
+  className: copyName(j.className),
+  fieldName: copyName(j.fieldName)
+});
+function copyField(f) {
+  const out = { ...f, name: copyName(f.name) };
+  if (f.type !== void 0) out.type = copyType(f.type);
+  if (f.joinsTo !== void 0) out.joinsTo = copyJoin(f.joinsTo);
+  return out;
+}
+function copyClass(c) {
+  const out = { ...c, name: copyName(c.name), fields: c.fields.map(copyField) };
+  if (c.system !== void 0) out.system = copyName(c.system);
+  if (c.similarTo !== void 0) out.similarTo = copyName(c.similarTo);
+  return out;
+}
+var key = (d) => [d.severity, d.code, d.line, d.col, d.end, d.message].join(" ");
+var TYPE_WORDS = [
+  "string",
+  "int",
+  "float",
+  "bool",
+  "date",
+  "datetime",
+  "uri",
+  "text",
+  "integer",
+  "boolean"
+];
+var MAX_DISTANCE = 2;
+function closestTypeWord(word) {
+  let best;
+  let bestDistance = MAX_DISTANCE + 1;
+  let bestPrefix = -1;
+  for (const candidate of TYPE_WORDS) {
+    const distance = levenshtein(word, candidate);
+    if (distance > MAX_DISTANCE || distance > bestDistance) continue;
+    const prefix = commonPrefixLength(word, candidate);
+    if (distance < bestDistance || prefix > bestPrefix) {
+      best = candidate;
+      bestDistance = distance;
+      bestPrefix = prefix;
+    }
+  }
+  return best;
+}
+function commonPrefixLength(a, b) {
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) i++;
+  return i;
+}
+function levenshtein(a, b) {
+  if (a === b) return 0;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const current = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      current[j] = Math.min(
+        (previous[j] ?? 0) + 1,
+        (current[j - 1] ?? 0) + 1,
+        (previous[j - 1] ?? 0) + cost
+      );
+    }
+    previous = current;
+  }
+  return previous[b.length] ?? 0;
+}
+
+// src/generators/linkml.ts
+var BASE_URI = "https://example.org";
+var RANGE = {
+  string: "string",
+  int: "integer",
+  float: "float",
+  bool: "boolean",
+  date: "date",
+  datetime: "datetime",
+  uri: "uri"
+};
+function toLinkML(doc, opts) {
+  const resolved = resolve(doc);
+  const schemaName = linkmlName(opts.schemaName);
+  const classes = emittedClasses(resolved.classes);
+  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/" };
+  if (!Object.hasOwn(prefixes, schemaName)) prefixes[schemaName] = `${BASE_URI}/${schemaName}/`;
+  const systemPrefix = /* @__PURE__ */ new Map();
+  const addSystem = (system) => {
+    const prefix = linkmlName(system);
+    if (!systemPrefix.has(system)) systemPrefix.set(system, prefix);
+    if (!Object.hasOwn(prefixes, prefix)) prefixes[prefix] = `${BASE_URI}/system/${prefix}/`;
+  };
+  for (const { node, fields } of classes) {
+    if (node.system !== void 0) addSystem(node.system.text);
+    for (const field of fields) {
+      if (field.system !== void 0) addSystem(field.system.text);
+    }
+  }
+  const declaredSystem = /* @__PURE__ */ new Map();
+  for (const { node } of classes) {
+    if (!declaredSystem.has(node.name.text)) declaredSystem.set(node.name.text, node.system?.text);
+  }
+  const mappingPrefix = (target) => {
+    const system = declaredSystem.get(target);
+    if (system === void 0) return schemaName;
+    return systemPrefix.get(system) ?? schemaName;
+  };
+  const schema = {
+    id: `${BASE_URI}/${schemaName}`,
+    name: schemaName,
+    default_prefix: schemaName,
+    default_range: "string",
+    prefixes,
+    imports: ["linkml:types"]
+  };
+  const out = {};
+  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.keys(out).length > 0) schema.classes = out;
+  const enumBlock = buildEnums(classes, enums);
+  if (Object.keys(enumBlock).length > 0) schema.enums = enumBlock;
+  return schema;
+}
+function emittedClasses(classes) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const node of classes) {
+    if (seen.has(node.name.text)) continue;
+    seen.add(node.name.text);
+    const fields = [];
+    const seenField = /* @__PURE__ */ new Set();
+    for (const field of node.fields) {
+      if (seenField.has(field.name.text)) continue;
+      seenField.add(field.name.text);
+      fields.push(field);
+    }
+    out.push({ node, fields });
+  }
+  return out;
+}
+var useKey = (className, fieldName) => `${className}\0${fieldName}`;
+function nameEnums(classes, classNames) {
+  const uses = [];
+  for (const { node, fields } of classes) {
+    for (const field of fields) {
+      if (field.type?.kind !== "enum") continue;
+      uses.push({
+        className: node.name.text,
+        fieldName: field.name.text,
+        values: field.type.values.map((v) => v.text).join("|")
+      });
+    }
+  }
+  const valueSets = /* @__PURE__ */ new Map();
+  for (const use of uses) {
+    const seen = valueSets.get(use.fieldName) ?? /* @__PURE__ */ new Set();
+    seen.add(use.values);
+    valueSets.set(use.fieldName, seen);
+  }
+  const taken = /* @__PURE__ */ new Map();
+  const names = /* @__PURE__ */ new Map();
+  for (const use of uses) {
+    const shared = (valueSets.get(use.fieldName)?.size ?? 0) <= 1;
+    const base = shared ? `${capitalise(use.fieldName)}Enum` : `${capitalise(use.className)}${capitalise(use.fieldName)}Enum`;
+    let name2 = base;
+    for (let n = 2; classNames.has(name2) || taken.has(name2) && taken.get(name2) !== use.values; n++) {
+      name2 = `${base}${n}`;
+    }
+    taken.set(name2, use.values);
+    names.set(useKey(use.className, use.fieldName), name2);
+  }
+  return names;
+}
+function buildEnums(classes, enums) {
+  const out = {};
+  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 = {};
+      for (const value of field.type.values) values[value.text] = null;
+      out[name2] = { permissible_values: values };
+    }
+  }
+  return out;
+}
+function buildClass(cls, mappingPrefix, enums) {
+  const { node, fields } = cls;
+  const out = {};
+  if (node.description !== void 0) out.description = node.description;
+  const annotations = {};
+  if (node.system !== void 0) annotations.system = node.system.text;
+  if (node.note !== void 0) annotations.note = node.note;
+  if (Object.keys(annotations).length > 0) out.annotations = annotations;
+  if (node.similarTo !== void 0) {
+    const target = node.similarTo.text;
+    out.close_mappings = [`${mappingPrefix(target)}:${target}`];
+  }
+  const attributes = {};
+  for (const field of fields) {
+    attributes[field.name.text] = buildAttribute(field, node.name.text, enums);
+  }
+  if (Object.keys(attributes).length > 0) out.attributes = attributes;
+  return out;
+}
+function buildAttribute(field, className, enums) {
+  const out = {};
+  if (field.description !== void 0) out.description = field.description;
+  const range = rangeOf(field, className, enums);
+  if (range !== void 0) out.range = range;
+  if (field.type?.many === true) out.multivalued = true;
+  if (field.identifier) out.identifier = true;
+  const annotations = {};
+  if (field.system !== void 0) annotations.system = field.system.text;
+  if (field.joinsTo !== void 0) {
+    annotations.joins_to = `${field.joinsTo.className.text}.${field.joinsTo.fieldName.text}`;
+  }
+  if (field.note !== void 0) annotations.note = field.note;
+  if (Object.keys(annotations).length > 0) out.annotations = annotations;
+  return out;
+}
+function rangeOf(field, className, enums) {
+  const type = field.type;
+  if (type === void 0) return void 0;
+  switch (type.kind) {
+    case "primitive":
+      return RANGE[type.name];
+    case "class":
+      return type.name.text;
+    case "unknown":
+      return "string";
+    case "enum":
+      return enums.get(useKey(className, field.name.text));
+  }
+}
+var RESERVED_PREFIXES = /* @__PURE__ */ new Set(["linkml", "xsd", "shex", "schema"]);
+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}_`;
+  return /^[0-9]/.test(name2) ? `_${name2}` : name2;
+};
+var capitalise = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+
+// src/generators/mermaid.ts
+function toMermaid(doc, opts) {
+  const resolved = resolve(doc);
+  const notes = opts?.notes === true;
+  const lines = ["classDiagram"];
+  for (const cls of resolved.classes) {
+    lines.push(`  class ${cls.name.text} {`);
+    if (cls.system !== void 0) lines.push(`    <<${cls.system.text}>>`);
+    for (const field of cls.fields) lines.push(`    ${member(field)}`);
+    lines.push("  }");
+  }
+  for (const name2 of resolved.undeclared) {
+    lines.push(`  class ${name2.text} {`, "    <<undeclared>>", "  }");
+  }
+  if (notes) {
+    for (const cls of resolved.classes) {
+      if (cls.note !== void 0) lines.push(`  note for ${cls.name.text} ${quote(cls.note)}`);
+      for (const field of cls.fields) {
+        if (field.note !== void 0) {
+          lines.push(`  note for ${cls.name.text} ${quote(`${field.name.text}: ${field.note}`)}`);
+        }
+      }
+    }
+  }
+  for (const cls of resolved.classes) {
+    const from = cls.name.text;
+    if (cls.similarTo !== void 0) lines.push(`  ${from} ..> ${cls.similarTo.text} : similar`);
+    for (const field of cls.fields) {
+      const type = field.type;
+      if (type?.kind === "class") {
+        lines.push(
+          type.many ? `  ${from} "1" --> "*" ${type.name.text} : ${field.name.text}` : `  ${from} --> ${type.name.text} : ${field.name.text}`
+        );
+      }
+      if (field.joinsTo !== void 0) {
+        const { className, fieldName } = field.joinsTo;
+        lines.push(`  ${from} ..> ${className.text} : ${field.name.text} = ${fieldName.text}`);
+      }
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function member(field) {
+  const marker = field.identifier ? "*" : "+";
+  const type = field.type === void 0 ? "" : `${typeText(field.type)} `;
+  const system = field.system === void 0 ? "" : ` @${field.system.text}`;
+  return `${marker}${type}${field.name.text}${system}`;
+}
+function typeText(type) {
+  let text;
+  switch (type.kind) {
+    case "primitive":
+      text = type.written.text;
+      break;
+    case "class":
+    case "unknown":
+      text = type.name.text;
+      break;
+    case "enum":
+      text = type.values.map((v) => v.text).join("|");
+      break;
+  }
+  return type.many ? `${text}[]` : text;
+}
+var quote = (text) => `"${text.replaceAll('"', "'")}"`;
+
+// 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 PRIMITIVES = {
+  string: "string",
+  int: "int",
+  float: "float",
+  bool: "bool",
+  date: "date",
+  datetime: "datetime",
+  uri: "uri",
+  text: "string",
+  integer: "int",
+  boolean: "bool"
+};
+var FIELD_ORDER = "name, `*`, `: type`, `@System`, `= Class.field`, then `#` and `?`";
+var CLASS_ORDER = "name, `@System`, `~ Class`, then `#` and `?`";
+function parse(source) {
+  const classes = [];
+  const diagnostics = [];
+  let current;
+  const text0 = source.startsWith("\uFEFF") ? source.slice(1) : source;
+  const lines = text0.split(/\r\n|\n|\r/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = i + 1;
+    const text = (lines[i] ?? "").replace(/[ \t]+$/, "");
+    const first = text[0];
+    if (first === void 0 || first === "#") continue;
+    if (isWs(first)) {
+      const start = text.search(/[^ \t]/);
+      if (current === void 0) {
+        diagnostics.push({
+          severity: "error",
+          code: "E_FIELD_WITHOUT_CLASS",
+          message: "An indented line is a field, but there is no valid class line above it",
+          line,
+          col: start,
+          end: text.length
+        });
+        continue;
+      }
+      const result = parseFieldLine(text, line);
+      if (result.ok) current.fields.push(result.value);
+      else diagnostics.push(result.diagnostic);
+      continue;
+    }
+    if (/\p{L}/u.test(first)) {
+      const result = parseClassLine(text, line);
+      if (result.ok) {
+        classes.push(result.value);
+        current = result.value;
+      } else {
+        diagnostics.push(result.diagnostic);
+        current = void 0;
+      }
+      continue;
+    }
+    diagnostics.push({
+      severity: "error",
+      code: "E_UNPARSABLE",
+      message: "A line at column 0 must start with a class name or `#` for a comment",
+      line,
+      col: 0,
+      end: text.length
+    });
+  }
+  return { classes, diagnostics };
+}
+function isDoubtMarker(text, i) {
+  return text[i] === "?" && isWs(text[i - 1]) && (i + 1 === text.length || isWs(text[i + 1]));
+}
+function splitTrailer(text) {
+  let start = -1;
+  for (let i = 1; i < text.length; i++) {
+    if (!isWs(text[i - 1])) continue;
+    if (text[i] === "#" || isDoubtMarker(text, i)) {
+      start = i;
+      break;
+    }
+  }
+  if (start < 0) return { head: text };
+  const trailer = { head: text.slice(0, start).replace(/[ \t]+$/, "") };
+  if (text[start] === "?") {
+    const note = trimWs(text.slice(start + 1));
+    if (note !== "") trailer.note = note;
+    return trailer;
+  }
+  let doubt = -1;
+  for (let i = start + 1; i < text.length; i++) {
+    if (isDoubtMarker(text, i)) {
+      doubt = i;
+      break;
+    }
+  }
+  const description = trimWs(text.slice(start + 1, doubt < 0 ? text.length : doubt));
+  if (description !== "") trailer.description = description;
+  if (doubt >= 0) {
+    const note = trimWs(text.slice(doubt + 1));
+    if (note !== "") trailer.note = note;
+  }
+  return trailer;
+}
+var WORD = /[\p{L}\p{N}_-]+/uy;
+var OPERATORS = ["*", ":", "@", "~", "=", ".", "|", "["];
+function tokenize(head) {
+  const tokens = [];
+  let i = 0;
+  while (i < head.length) {
+    const c = head[i] ?? "";
+    if (isWs(c)) {
+      i++;
+      continue;
+    }
+    WORD.lastIndex = i;
+    const word = WORD.exec(head);
+    if (word !== null) {
+      tokens.push({ kind: "word", text: word[0], col: i, end: i + word[0].length });
+      i += word[0].length;
+      continue;
+    }
+    if (c === "[" && head[i + 1] === "]") {
+      tokens.push({ kind: "[]", text: "[]", col: i, end: i + 2 });
+      i += 2;
+      continue;
+    }
+    const ch = String.fromCodePoint(head.codePointAt(i) ?? 0);
+    const kind = OPERATORS.find((op) => op === ch) ?? "other";
+    tokens.push({ kind, text: ch, col: i, end: i + ch.length });
+    i += ch.length;
+  }
+  return tokens;
+}
+var peek = (c) => c.tokens[c.pos];
+function take(c) {
+  const t = c.tokens[c.pos];
+  if (t !== void 0) c.pos++;
+  return t;
+}
+var name = (t, line) => ({ text: t.text, line, col: t.col, end: t.end });
+function fail(code, message, line, span) {
+  return {
+    ok: false,
+    diagnostic: { severity: "error", code, message, line, col: span.col, end: span.end }
+  };
+}
+var afterSpan = (after) => ({ col: after.end, end: after.end });
+function parseClassLine(text, line) {
+  const trailer = splitTrailer(text);
+  const c = { tokens: tokenize(trailer.head), pos: 0, line };
+  const head = take(c);
+  if (head === void 0 || head.kind !== "word") {
+    return fail("E_UNPARSABLE", "A class line must start with a class name", line, {
+      col: 0,
+      end: Math.max(1, trailer.head.length)
+    });
+  }
+  if (!CLASS_NAME.test(head.text)) {
+    return fail(
+      "E_BAD_NAME",
+      `Class names are UpperCamelCase (letters and digits, uppercase first): \`${head.text}\``,
+      line,
+      head
+    );
+  }
+  const node = { name: name(head, line), line };
+  const at = peek(c);
+  if (at?.kind === "@") {
+    take(c);
+    const system = parseSystem(c, at);
+    if (!system.ok) return system;
+    node.system = system.value;
+  }
+  const tilde = peek(c);
+  if (tilde?.kind === "~") {
+    take(c);
+    const target = take(c);
+    if (target === void 0 || target.kind !== "word") {
+      return fail(
+        "E_UNPARSABLE",
+        "Expected a class name after `~`, e.g. `CharacterPage @Community ~ Character`",
+        line,
+        target ?? afterSpan(tilde)
+      );
+    }
+    if (!CLASS_NAME.test(target.text)) {
+      return fail(
+        "E_BAD_NAME",
+        `The class after \`~\` must be UpperCamelCase: \`${target.text}\``,
+        line,
+        target
+      );
+    }
+    node.similarTo = name(target, line);
+  }
+  const rest = peek(c);
+  if (rest !== void 0) return unexpected(rest, line, "class", CLASS_ORDER);
+  if (trailer.description !== void 0) node.description = trailer.description;
+  if (trailer.note !== void 0) node.note = trailer.note;
+  return { ok: true, value: { ...node, fields: [] } };
+}
+function parseFieldLine(text, line) {
+  const trailer = splitTrailer(text);
+  const c = { tokens: tokenize(trailer.head), pos: 0, line };
+  const head = take(c);
+  if (head === void 0) {
+    const col = text.search(/[^ \t]/);
+    const message = text[col] === "#" ? "A `#` comment must start at column 0; an indented line is a field and needs a name" : "A field line needs a field name before its trailer";
+    return fail("E_UNPARSABLE", message, line, { col, end: Math.max(col + 1, text.length) });
+  }
+  if (head.kind !== "word") return unexpected(head, line, "field", FIELD_ORDER);
+  if (!FIELD_NAME.test(head.text)) {
+    return fail(
+      "E_BAD_NAME",
+      `Field names are lowerCamelCase (letters and digits, lowercase first): \`${head.text}\``,
+      line,
+      head
+    );
+  }
+  const node = { name: name(head, line), line, identifier: false };
+  if (peek(c)?.kind === "*") {
+    take(c);
+    node.identifier = true;
+  }
+  const colon = peek(c);
+  if (colon?.kind === ":") {
+    take(c);
+    const type = parseType(c, colon);
+    if (!type.ok) return type;
+    node.type = type.value;
+  }
+  const at = peek(c);
+  if (at?.kind === "@") {
+    take(c);
+    const system = parseSystem(c, at);
+    if (!system.ok) return system;
+    node.system = system.value;
+  }
+  const equals = peek(c);
+  if (equals?.kind === "=") {
+    take(c);
+    const example = "e.g. `characterId = Character.id`";
+    const className = take(c);
+    if (className === void 0 || className.kind !== "word") {
+      return fail(
+        "E_UNPARSABLE",
+        `Expected \`Class.field\` after \`=\`, ${example}`,
+        line,
+        className ?? afterSpan(equals)
+      );
+    }
+    if (!CLASS_NAME.test(className.text)) {
+      return fail(
+        "E_BAD_NAME",
+        `The class after \`=\` must be UpperCamelCase: \`${className.text}\``,
+        line,
+        className
+      );
+    }
+    const dot = take(c);
+    if (dot === void 0 || dot.kind !== ".") {
+      return fail(
+        "E_UNPARSABLE",
+        `Expected \`.\` and a field name after \`= ${className.text}\`, ${example}`,
+        line,
+        dot ?? afterSpan(className)
+      );
+    }
+    const fieldName = take(c);
+    if (fieldName === void 0 || fieldName.kind !== "word") {
+      return fail(
+        "E_UNPARSABLE",
+        `Expected a field name after \`= ${className.text}.\`, ${example}`,
+        line,
+        fieldName ?? afterSpan(dot)
+      );
+    }
+    if (!FIELD_NAME.test(fieldName.text)) {
+      return fail(
+        "E_BAD_NAME",
+        `The field after \`= ${className.text}.\` must be lowerCamelCase: \`${fieldName.text}\``,
+        line,
+        fieldName
+      );
+    }
+    node.joinsTo = { className: name(className, line), fieldName: name(fieldName, line) };
+  }
+  const rest = peek(c);
+  if (rest !== void 0) return unexpected(rest, line, "field", FIELD_ORDER);
+  if (trailer.description !== void 0) node.description = trailer.description;
+  if (trailer.note !== void 0) node.note = trailer.note;
+  return { ok: true, value: node };
+}
+function parseSystem(c, at) {
+  const system = take(c);
+  if (system === void 0 || system.kind !== "word") {
+    return fail(
+      "E_UNPARSABLE",
+      "Expected a system name after `@`, e.g. `@Catalog`",
+      c.line,
+      system ?? afterSpan(at)
+    );
+  }
+  if (!SYSTEM_OR_VALUE.test(system.text)) {
+    return fail(
+      "E_UNPARSABLE",
+      `A system name is letters, digits, \`-\` and \`_\`, starting with a letter: \`${system.text}\``,
+      c.line,
+      system
+    );
+  }
+  return { ok: true, value: name(system, c.line) };
+}
+function parseType(c, colon) {
+  const first = peek(c);
+  if (first === void 0 || first.kind === "*" || first.kind === "@" || first.kind === "=") {
+    return fail(
+      "E_MISSING_TYPE",
+      "A colon needs a type after it, e.g. `crewSize: int`",
+      c.line,
+      colon
+    );
+  }
+  if (first.kind !== "word") {
+    return fail(
+      "E_UNPARSABLE",
+      `Expected a type after \`:\`, found \`${first.text}\``,
+      c.line,
+      first
+    );
+  }
+  take(c);
+  const words = [first];
+  for (let pipe = peek(c); pipe?.kind === "|"; pipe = peek(c)) {
+    take(c);
+    const value = take(c);
+    if (value === void 0 || value.kind !== "word") {
+      return fail(
+        "E_UNPARSABLE",
+        "Expected an enum value after `|`, e.g. `climate: arid|temperate|frozen`",
+        c.line,
+        value ?? afterSpan(pipe)
+      );
+    }
+    words.push(value);
+  }
+  let many = false;
+  const bracket = peek(c);
+  if (bracket?.kind === "[]") {
+    take(c);
+    many = true;
+  } else if (bracket?.kind === "[") {
+    return fail(
+      "E_UNCLOSED_MANY",
+      "`[` must be closed: `[]` marks a many-valued field",
+      c.line,
+      bracket
+    );
+  }
+  if (words.length > 1) {
+    for (const w of words) {
+      if (!SYSTEM_OR_VALUE.test(w.text)) {
+        return fail(
+          "E_UNPARSABLE",
+          `An enum value is letters, digits, \`-\` and \`_\`, starting with a letter: \`${w.text}\``,
+          c.line,
+          w
+        );
+      }
+    }
+    return { ok: true, value: { kind: "enum", values: words.map((w) => name(w, c.line)), many } };
+  }
+  const word = first.text;
+  const primitive = PRIMITIVES[word];
+  if (primitive !== void 0) {
+    return {
+      ok: true,
+      value: { kind: "primitive", name: primitive, written: name(first, c.line), many }
+    };
+  }
+  if (/^[A-Z]/.test(word)) {
+    if (!CLASS_NAME.test(word)) {
+      return fail(
+        "E_BAD_NAME",
+        `A referenced class must be UpperCamelCase: \`${word}\``,
+        c.line,
+        first
+      );
+    }
+    return { ok: true, value: { kind: "class", name: name(first, c.line), many } };
+  }
+  if (/^[a-z]/.test(word)) {
+    return { ok: true, value: { kind: "unknown", name: name(first, c.line), many } };
+  }
+  return fail(
+    "E_UNPARSABLE",
+    `A type is a primitive, a class name or an enum, not \`${word}\``,
+    c.line,
+    first
+  );
+}
+function unexpected(token, line, kind, order) {
+  const modifiers = kind === "field" ? ["*", ":", "@", "="] : ["@", "~"];
+  if (modifiers.includes(token.kind)) {
+    return fail(
+      "E_UNPARSABLE",
+      `\`${token.text}\` is out of order; a ${kind} line reads: ${order}`,
+      line,
+      token
+    );
+  }
+  if (token.text === "<") {
+    return fail(
+      "E_UNPARSABLE",
+      "`<` is reserved for inheritance and not yet part of the language",
+      line,
+      token
+    );
+  }
+  if (token.text === "?") {
+    return fail(
+      "E_UNPARSABLE",
+      "`?` attached to a word is not a marker; a doubt needs whitespace before `?` and after it",
+      line,
+      token
+    );
+  }
+  if (token.text === "#") {
+    return fail("E_UNPARSABLE", "A description needs whitespace before `#`", line, token);
+  }
+  return fail("E_UNPARSABLE", `Unexpected \`${token.text}\` on a ${kind} line`, line, token);
+}
+
+// src/serialize.ts
+import { isMap, isScalar, Scalar, visit, Document as YAMLDocument } from "yaml";
+function serialize(schema, format) {
+  if (format === "json") return `${JSON.stringify(schema, null, 2)}
+`;
+  const doc = new YAMLDocument(schema, { version: "1.1" });
+  const root = doc.contents;
+  if (isMap(root)) {
+    for (const pair of root.items) {
+      const key2 = pair.key;
+      if (!isScalar(key2)) continue;
+      if (key2.value !== "classes" && key2.value !== "enums") continue;
+      key2.spaceBefore = true;
+      if (key2.value === "classes" && isMap(pair.value)) {
+        for (const entry of pair.value.items) {
+          if (isScalar(entry.key)) entry.key.spaceBefore = true;
+        }
+      }
+    }
+  }
+  visit(doc, {
+    Scalar(_, node) {
+      if (typeof node.value === "string" && hasControlCharacter(node.value)) {
+        node.type = Scalar.QUOTE_DOUBLE;
+      }
+    }
+  });
+  const text = doc.toString({
+    directives: false,
+    indent: 2,
+    lineWidth: 0,
+    // A permissible value carries no body: `arid:`, not `arid: null`.
+    nullStr: ""
+  });
+  return text.replace(/^[ \t]+$/gm, "");
+}
+function hasControlCharacter(text) {
+  for (const character of text) {
+    const code = character.codePointAt(0) ?? 0;
+    if (code < 32 || code === 127) return true;
+  }
+  return false;
+}
+
+// src/compile.ts
+function compile(source, opts) {
+  const doc = resolve(parse(source));
+  const output = opts.target === "linkml" ? serialize(toLinkML(doc, { schemaName: opts.schemaName }), opts.format ?? "yaml") : toMermaid(doc, { notes: opts.notes });
+  return { output, diagnostics: doc.diagnostics };
+}
+
+// src/diagnostics.ts
+function formatDiagnostic(d, file) {
+  const where = [file, d.line, d.col === void 0 ? void 0 : d.col + 1].filter((part) => part !== void 0).join(":");
+  return `${where}: ${d.severity} ${d.code} ${d.message}`;
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+
+// src/cli.ts
+var HELP = `Usage: skiss <command> [options]
+
+Commands:
+  diagram <file>       Write a Mermaid class diagram for a .skiss file.
+  compile <file>       Write a LinkML schema for a .skiss file.
+                       <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
+      --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.
+      --strict         Exit 1 when the input has any diagnostic
+  -h, --help           Show this help and exit
+      --version        Print the version and exit
+
+Diagnostics go to standard error, one per line:
+  <file>:<line>:<col>: <severity> <CODE> <message>
+
+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
+  70 internal error, a bug in skiss
+`;
+var EXIT_OK = 0;
+var EXIT_STRICT = 1;
+var EXIT_USAGE = 2;
+var EXIT_INTERNAL = 70;
+var COMMANDS = {
+  diagram: ["output", "notes", "strict"],
+  compile: ["output", "json", "name", "strict"]
+};
+var isCommand = (text) => Object.hasOwn(COMMANDS, text);
+var UsageError = class extends Error {
+};
+function isUsageError(error) {
+  if (error instanceof UsageError) return true;
+  if (typeof error !== "object" || error === null || !("code" in error)) return false;
+  return typeof error.code === "string" && error.code.startsWith("ERR_PARSE_ARGS");
+}
+async function main(argv) {
+  if (argv.length === 0) {
+    process.stderr.write(HELP);
+    return EXIT_USAGE;
+  }
+  const { values, positionals } = parseArgs({
+    args: argv,
+    options: {
+      output: { type: "string", short: "o" },
+      notes: { type: "boolean" },
+      json: { type: "boolean" },
+      name: { type: "string" },
+      strict: { type: "boolean" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean" }
+    },
+    allowPositionals: true,
+    strict: true
+  });
+  if (values.help === true) {
+    process.stdout.write(HELP);
+    return EXIT_OK;
+  }
+  if (values.version === true) {
+    process.stdout.write(`${VERSION}
+`);
+    return EXIT_OK;
+  }
+  const [command, file, ...extra] = positionals;
+  if (command === void 0) throw new UsageError("missing command");
+  if (!isCommand(command)) throw new UsageError(`unknown command \`${command}\``);
+  if (file === void 0)
+    throw new UsageError(`${command} needs a <file>, or - for standard input`);
+  if (extra.length > 0) throw new UsageError(`unexpected argument \`${extra[0]}\``);
+  const accepted = COMMANDS[command];
+  for (const option of Object.keys(values)) {
+    if (!accepted.includes(option)) {
+      throw new UsageError(`\`${command}\` does not take \`--${option}\``);
+    }
+  }
+  const source = file === "-" ? await readStdin() : await readSource(file);
+  const { output, diagnostics } = command === "compile" ? compile(source, {
+    target: "linkml",
+    schemaName: values.name ?? defaultSchemaName(file),
+    format: values.json === true ? "json" : "yaml"
+  }) : compile(source, { target: "mermaid", notes: values.notes });
+  const label = file === "-" ? "<stdin>" : file;
+  for (const d of diagnostics) process.stderr.write(`${formatDiagnostic(d, label)}
+`);
+  if (values.output === void 0) process.stdout.write(output);
+  else await writeOutput(values.output, output);
+  return values.strict === true && diagnostics.length > 0 ? EXIT_STRICT : EXIT_OK;
+}
+var defaultSchemaName = (file) => file === "-" ? "sketch" : basename(file, extname(file));
+async function readSource(file) {
+  try {
+    return await readFile(file, "utf8");
+  } catch (error) {
+    throw new UsageError(`cannot read \`${file}\`: ${reason(error)}`);
+  }
+}
+async function readStdin() {
+  try {
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    return Buffer.concat(chunks).toString("utf8");
+  } catch (error) {
+    throw new UsageError(`cannot read standard input: ${reason(error)}`);
+  }
+}
+async function writeOutput(path, text) {
+  try {
+    await writeFile(path, text, "utf8");
+  } catch (error) {
+    throw new UsageError(`cannot write \`${path}\`: ${reason(error)}`);
+  }
+}
+function reason(error) {
+  if (error instanceof Error) {
+    const code = error.code;
+    return code ?? error.message;
+  }
+  return String(error);
+}
+main(process.argv.slice(2)).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (error) => {
+    if (isUsageError(error)) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`skiss: ${message}
+Try 'skiss --help' for more information.
+`);
+      process.exitCode = EXIT_USAGE;
+      return;
+    }
+    const detail = error instanceof Error && error.stack !== void 0 ? error.stack : String(error);
+    process.stderr.write(`skiss: internal error: ${detail}
+`);
+    process.exitCode = EXIT_INTERNAL;
+  }
+);
+//# sourceMappingURL=cli.js.map