@eriknaslund/skiss 0.2.0 → 0.3.0

package/dist/cli.js

@@ -5,6 +5,446 @@ import { readFile, writeFile } from "fs/promises";
 import { basename, extname } from "path";
 import { parseArgs } from "util";
 
+// 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"
+};
+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 `?`";
+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 };
+  const star = peek(c);
+  if (star?.kind === "*") {
+    take(c);
+    node.identifier = true;
+    node.identifierAt = name(star, line);
+  }
+  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 = primitiveFor(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/resolve.ts
 function resolve(doc) {
   const out = {
@@ -23,7 +463,9 @@ function resolve(doc) {
   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);
+    const lower = name2.text.toLowerCase();
+    const hint = Object.hasOwn(PRIMITIVES, lower) ? `. Did you mean \`${lower}\`?` : "";
+    warn("W_UNDECLARED_CLASS", `class \`${name2.text}\` is not declared${hint}`, name2);
     return false;
   };
   const firstClass = /* @__PURE__ */ new Map();
@@ -56,7 +498,7 @@ function resolve(doc) {
           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.identifierAt ?? field.name
           );
           field.identifier = false;
         }
@@ -85,9 +527,9 @@ function resolve(doc) {
       }
     }
   }
-  const present = new Set(out.diagnostics.map(key));
+  const present2 = new Set(out.diagnostics.map(key));
   for (const w of warnings) {
-    if (!present.has(key(w))) out.diagnostics.push(w);
+    if (!present2.has(key(w))) out.diagnostics.push(w);
   }
   out.diagnostics.sort((a, b) => a.line - b.line);
   out.undeclared = [...undeclared.values()].map((n) => ({ ...n }));
@@ -111,6 +553,7 @@ var copyJoin = (j) => ({
 });
 function copyField(f) {
   const out = { ...f, name: copyName(f.name) };
+  if (f.identifierAt !== void 0) out.identifierAt = copyName(f.identifierAt);
   if (f.type !== void 0) out.type = copyType(f.type);
   if (f.joinsTo !== void 0) out.joinsTo = copyJoin(f.joinsTo);
   return out;
@@ -122,18 +565,7 @@ function copyClass(c) {
   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 TYPE_WORDS = Object.keys(PRIMITIVES);
 var MAX_DISTANCE = 2;
 function closestTypeWord(word) {
   let best;
@@ -144,722 +576,287 @@ function closestTypeWord(word) {
     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}`);
-      }
+      best = candidate;
+      bestDistance = distance;
+      bestPrefix = prefix;
     }
   }
-  return `${lines.join("\n")}
-`;
+  return best;
 }
-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 commonPrefixLength(a, b) {
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) i++;
+  return i;
 }
-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;
+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 type.many ? `${text}[]` : text;
+  return previous[b.length] ?? 0;
 }
-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 = {
+// src/generators/linkml.ts
+var BASE_URI = "https://example.org";
+var RANGE = {
   string: "string",
-  int: "int",
+  int: "integer",
   float: "float",
-  bool: "bool",
+  bool: "boolean",
   date: "date",
   datetime: "datetime",
-  uri: "uri",
-  text: "string",
-  integer: "int",
-  boolean: "bool"
+  uri: "uri"
 };
-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;
+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 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;
+  const declaredSystem = /* @__PURE__ */ new Map();
+  for (const { node } of classes) {
+    if (!declaredSystem.has(node.name.text)) declaredSystem.set(node.name.text, node.system?.text);
   }
-  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 }
+  const mappingPrefix = (target) => {
+    const system = declaredSystem.get(target);
+    if (system === void 0) return schemaName;
+    return systemPrefix.get(system) ?? schemaName;
   };
-}
-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 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);
   }
-  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;
+  for (const name2 of resolved.undeclared) {
+    if (!(name2.text in out)) out[name2.text] = { annotations: { undeclared: true } };
   }
-  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
-      );
+  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);
     }
-    node.similarTo = name(target, line);
+    out.push({ node, fields });
   }
-  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: [] } };
+  return out;
 }
-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) });
+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("|")
+      });
+    }
   }
-  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 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 node = { name: name(head, line), line, identifier: false };
-  if (peek(c)?.kind === "*") {
-    take(c);
-    node.identifier = true;
+  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);
   }
-  const colon = peek(c);
-  if (colon?.kind === ":") {
-    take(c);
-    const type = parseType(c, colon);
-    if (!type.ok) return type;
-    node.type = type.value;
+  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 };
+    }
   }
-  const at = peek(c);
-  if (at?.kind === "@") {
-    take(c);
-    const system = parseSystem(c, at);
-    if (!system.ok) return system;
-    node.system = system.value;
+  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 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 attributes = {};
+  for (const field of fields) {
+    attributes[field.name.text] = buildAttribute(field, node.name.text, enums);
   }
-  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 };
+  if (Object.keys(attributes).length > 0) out.attributes = attributes;
+  return out;
 }
-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)
-    );
+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 (!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
-    );
+  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));
   }
-  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
-    );
+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("  }");
   }
-  if (first.kind !== "word") {
-    return fail(
-      "E_UNPARSABLE",
-      `Expected a type after \`:\`, found \`${first.text}\``,
-      c.line,
-      first
-    );
+  for (const name2 of resolved.undeclared) {
+    lines.push(`  class ${name2.text} {`, "    <<undeclared>>", "  }");
   }
-  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)
-      );
+  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}`)}`);
+        }
+      }
     }
-    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
+  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 { 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
-  );
+  return `${lines.join("\n")}
+`;
 }
-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);
+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 fail("E_UNPARSABLE", `Unexpected \`${token.text}\` on a ${kind} line`, line, token);
+  return type.many ? `${text}[]` : text;
 }
+var quote = (text) => `"${text.replaceAll('"', "'")}"`;
 
 // src/serialize.ts
 import { isMap, isScalar, Scalar, visit, Document as YAMLDocument } from "yaml";
@@ -918,8 +915,509 @@ function formatDiagnostic(d, file) {
   return `${where}: ${d.severity} ${d.code} ${d.message}`;
 }
 
+// src/generators/skiss.ts
+var TRAILER_COLUMN = 40;
+function toSkiss(doc) {
+  if (doc.classes.length === 0) return "";
+  return `${doc.classes.map(classBlock).join("\n\n")}
+`;
+}
+function classBlock(cls) {
+  const head = cls.name.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) {
+  const type = typeText2(field.type);
+  const head = `  ${field.name.text}` + (field.identifier ? "*" : "") + (type === void 0 ? "" : `: ${type}`) + (field.system === void 0 ? "" : ` @${field.system.text}`) + (field.joinsTo === void 0 ? "" : ` = ${field.joinsTo.className.text}.${field.joinsTo.fieldName.text}`);
+  return withTrailer(head, field);
+}
+function typeText2(type) {
+  if (type === void 0) return void 0;
+  let text;
+  switch (type.kind) {
+    case "primitive":
+      if (type.name === "string" && !type.many) return void 0;
+      text = type.name;
+      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;
+}
+function withTrailer(head, node) {
+  const parts2 = [];
+  if (node.description !== void 0 && node.description !== "")
+    parts2.push(`# ${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) : "  ";
+  return head + gap + parts2.join(" ");
+}
+
+// src/generators/from-linkml.ts
+var PRIMITIVE_RANGE = {
+  string: "string",
+  integer: "int",
+  float: "float",
+  double: "float",
+  decimal: "float",
+  boolean: "bool",
+  date: "date",
+  datetime: "datetime",
+  uri: "uri",
+  uriorcurie: "uri"
+};
+var CLASS_KEYS = /* @__PURE__ */ new Set(["description", "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"]);
+var QUIET_SCHEMA_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "name",
+  "prefixes",
+  "imports",
+  "default_prefix",
+  "default_range",
+  "title",
+  "license",
+  "version",
+  "classes",
+  "slots",
+  "enums"
+]);
+var UNKNOWN_TYPE = /^[a-z][a-z0-9_-]*$/;
+function fromLinkML(schema) {
+  const root = asRecord(schema);
+  if (root === void 0) return nothing("schema", "the schema is not an object");
+  const schemaName = schemaElement(root);
+  const classBlock2 = asRecord(get(root, "classes"));
+  if (classBlock2 === void 0) return nothing(schemaName, "the schema has no `classes`");
+  const classDefs = classBlock2;
+  const dropped = [];
+  const report = (kind, element, detail) => {
+    dropped.push(detail === void 0 ? { kind, element } : { kind, element, detail });
+  };
+  const slotDefs = asRecord(get(root, "slots")) ?? {};
+  const enumDefs = asRecord(get(root, "enums")) ?? {};
+  const defaultRange = stringOf(get(root, "default_range")) ?? "string";
+  const classNames = /* @__PURE__ */ new Map();
+  const takenClasses = /* @__PURE__ */ new Set();
+  for (const key2 of Object.keys(classDefs)) {
+    classNames.set(key2, unique(toClassName(key2), takenClasses));
+  }
+  const fieldNames = /* @__PURE__ */ new Map();
+  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)) ?? {})) {
+      names.set(slot, unique(toFieldName(slot), taken));
+    }
+    fieldNames.set(key2, names);
+  }
+  const referenced = /* @__PURE__ */ new Set();
+  const reference = (element, from, to) => {
+    if (from === to || referenced.has(`${element}\0${to}`)) return;
+    referenced.add(`${element}\0${to}`);
+    report("renamed", element, `\`${to}\` from \`${from}\``);
+  };
+  const classNameOf = (key2) => classNames.get(key2) ?? toClassName(key2);
+  const fieldNameOf = (classKey, slot) => fieldNames.get(classKey)?.get(slot) ?? toFieldName(slot);
+  const enumValues = /* @__PURE__ */ new Map();
+  const unwritable = /* @__PURE__ */ new Map();
+  for (const key2 of Object.keys(enumDefs)) {
+    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));
+    if (values === void 0 && present(rawValues)) {
+      unwritable.set(key2, `${shown(rawValues)} is not a map of permissible values`);
+    } else if (keys.length < 2) {
+      const count = `${keys.length} permissible value${keys.length === 1 ? "" : "s"}`;
+      unwritable.set(key2, `${count} cannot be an inline enum (\xA73.4)`);
+    } else if (bad !== void 0) {
+      unwritable.set(key2, `\`${bad}\` is not a value Skiss can write (\xA74)`);
+    } else {
+      enumValues.set(key2, keys);
+    }
+  }
+  const enumUses = [];
+  const classes = [];
+  for (const key2 of Object.keys(classDefs)) {
+    const raw = get(classDefs, key2);
+    const body = asRecord(raw);
+    const name2 = classNameOf(key2);
+    if (body === void 0 && raw !== null && raw !== void 0) {
+      report("class", name2, "is not a class definition");
+      continue;
+    }
+    const def = body ?? {};
+    if (name2 !== key2) report("renamed", name2, `from \`${key2}\``);
+    const annotations = annotationsOf(def);
+    if (annotations.get("undeclared") === true) {
+      for (const other of Object.keys(def)) {
+        if (other !== "annotations") report(other, name2);
+      }
+      continue;
+    }
+    const node = { name: at0(name2), fields: [], line: 0 };
+    const description = oneLine(stringOf(get(def, "description")));
+    if (description !== void 0) node.description = description;
+    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;
+    const mappings = stringList(get(def, "close_mappings"));
+    const first = mappings[0];
+    const target = first === void 0 ? "" : localName(first);
+    if (target !== "") {
+      const similar = Object.hasOwn(classDefs, target) ? classNameOf(target) : toClassName(target);
+      node.similarTo = at0(similar);
+      reference(name2, target, similar);
+    }
+    for (const other of Object.keys(def)) {
+      if (CLASS_KEYS.has(other)) {
+        if (other === "annotations") {
+          for (const tag of annotations.keys()) {
+            if (!CLASS_TAGS.has(tag)) report("annotation", name2, `\`${tag}\``);
+          }
+        }
+        if (other === "close_mappings") {
+          if (target === "") report("close_mappings", name2, "no mapping this can read");
+          else if (mappings.length > 1) {
+            report("close_mappings", name2, `${mappings.length - 1} beyond the first`);
+          }
+        }
+        const block = get(def, other);
+        if (other === "attributes" && present(block) && asRecord(block) === void 0) {
+          report("attributes", name2, `${shown(block)} is not a map`);
+        }
+        if (other === "slots" && present(block) && !Array.isArray(block)) {
+          report("slots", name2, `${shown(block)} is not a list`);
+        }
+        continue;
+      }
+      if (other === "slot_usage") {
+        const usage = asRecord(get(def, other));
+        if (usage === void 0) {
+          report("slot_usage", name2);
+          continue;
+        }
+        for (const slot of Object.keys(usage)) {
+          if (fieldNames.get(key2)?.has(slot) === true) {
+            report("slot_usage", `${name2}.${fieldNameOf(key2, slot)}`);
+          } else {
+            report("slot_usage", name2, `\`${slot}\` is inherited and not in the sketch`);
+          }
+        }
+        continue;
+      }
+      report(other, name2);
+    }
+    for (const slot of slotKeysOf(def)) {
+      const attributes = asRecord(get(def, "attributes")) ?? {};
+      const rawSlot = 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");
+        continue;
+      }
+      node.fields.push(buildField(key2, name2, slot, slotDef ?? {}));
+    }
+    classes.push(node);
+  }
+  for (const key2 of Object.keys(enumDefs)) {
+    const def = asRecord(get(enumDefs, key2)) ?? {};
+    const uses = enumUses.filter((use) => use.enumName === key2);
+    const why = unwritable.get(key2);
+    if (why !== void 0) report("enum", key2, `${why}; those attributes keep no type`);
+    else if (uses.length === 0) report("unused_enum", key2, "no attribute has it as its range");
+    else if (uses.length > 1 && sharingLost(uses, enumUses)) {
+      report("inlined", key2, `inlined at ${uses.length} attributes`);
+    }
+    const detail = [];
+    const values = asRecord(get(def, "permissible_values")) ?? {};
+    const detailed = Object.keys(values).filter((value) => {
+      const valueBody = asRecord(get(values, value));
+      return valueBody !== void 0 && Object.keys(valueBody).length > 0;
+    });
+    if (detailed.length > 0) {
+      const bodies = detailed.length === 1 ? "carries a body of its own" : "carry bodies of their own";
+      detail.push(`${list(detailed)} ${bodies}`);
+    }
+    const others = Object.keys(def).filter((other) => other !== "permissible_values");
+    if (others.length > 0) detail.push(`the enum carries ${list(others)}`);
+    if (detail.length > 0) report("enum_detail", key2, detail.join("; "));
+  }
+  for (const slot of Object.keys(slotDefs)) {
+    if (!listedSomewhere(slot)) report("slot", slot, "no class lists it");
+  }
+  for (const key2 of Object.keys(root)) {
+    if (!QUIET_SCHEMA_KEYS.has(key2)) report("schema", schemaName, `\`${key2}\``);
+  }
+  const source = toSkiss({ classes, diagnostics: [] });
+  return { document: parse(source), source, dropped };
+  function buildField(classKey, className, slot, def) {
+    const name2 = fieldNameOf(classKey, slot);
+    const element = `${className}.${name2}`;
+    if (name2 !== slot) report("renamed", element, `from \`${slot}\``);
+    const identifier = get(def, "identifier");
+    if (present(identifier) && typeof identifier !== "boolean") {
+      report("identifier", element, `${shown(identifier)} is not a boolean`);
+    }
+    const field = {
+      name: at0(name2),
+      identifier: identifier === true,
+      line: 0
+    };
+    const description = oneLine(stringOf(get(def, "description")));
+    if (description !== void 0) field.description = description;
+    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");
+    const joins = annotations.get("joins_to");
+    if (typeof joins === "string") {
+      const dot = joins.indexOf(".");
+      const target = joins.slice(0, dot);
+      const targetField = joins.slice(dot + 1);
+      if (dot > 0 && targetField !== "") {
+        const targetClass = classNameOf(target);
+        const targetName = fieldNameOf(target, targetField);
+        field.joinsTo = { className: at0(targetClass), fieldName: at0(targetName) };
+        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;
+    for (const other of Object.keys(def)) {
+      if (!SLOT_KEYS.has(other)) {
+        report(other, element);
+        continue;
+      }
+      if (other !== "annotations") continue;
+      for (const tag of annotations.keys()) {
+        if (!SLOT_TAGS.has(tag)) report("annotation", element, `\`${tag}\``);
+      }
+    }
+    return field;
+  }
+  function typeFor(element, field, def) {
+    const rawMany = get(def, "multivalued");
+    if (present(rawMany) && typeof rawMany !== "boolean") {
+      report("multivalued", element, `${shown(rawMany)} is not a boolean`);
+    }
+    const many = rawMany === true;
+    const rawRange = get(def, "range");
+    if (present(rawRange) && typeof rawRange !== "string") {
+      report("range", element, `${shown(rawRange)} is not a string`);
+    } else if (rawRange === "") report("range", element, "the range is empty");
+    const range = stringOf(rawRange) ?? defaultRange;
+    if (Object.hasOwn(classDefs, range)) {
+      const target = classNameOf(range);
+      reference(element, range, target);
+      return { kind: "class", name: at0(target), many };
+    }
+    if (Object.hasOwn(enumDefs, range)) {
+      const values = enumValues.get(range);
+      if (values === void 0) return many ? stringType(true) : void 0;
+      enumUses.push({ enumName: range, field, values: values.join("|") });
+      return { kind: "enum", values: values.map(at0), many };
+    }
+    if (Object.hasOwn(PRIMITIVE_RANGE, range)) {
+      const primitive = PRIMITIVE_RANGE[range] ?? "string";
+      if (primitive === "string") return many ? stringType(true) : void 0;
+      return { kind: "primitive", name: primitive, written: at0(primitive), many };
+    }
+    if (/^[A-Z]/.test(range)) {
+      const target = toClassName(range);
+      reference(element, range, target);
+      return { kind: "class", name: at0(target), many };
+    }
+    const word = range.toLowerCase();
+    if (!UNKNOWN_TYPE.test(word)) {
+      report("narrowed", element, `\`${range}\` is not a type Skiss can write; it reads as string`);
+      return many ? stringType(true) : void 0;
+    }
+    report("narrowed", element, `\`${range}\` is not a Skiss type; it falls back to string`);
+    return { kind: "unknown", name: at0(word), many };
+  }
+  function listedSomewhere(slot) {
+    for (const key2 of Object.keys(classDefs)) {
+      const def = asRecord(get(classDefs, key2)) ?? {};
+      if (stringList(get(def, "slots")).includes(slot)) return true;
+    }
+    return false;
+  }
+}
+function sharingLost(uses, all) {
+  const first = uses[0];
+  if (first === void 0) return false;
+  if (uses.some((use) => use.field !== first.field)) return true;
+  return all.some((use) => use.field === first.field && use.values !== first.values);
+}
+var COUNTED = {
+  renamed: ["name", "names"],
+  inlined: ["enum", "enums"],
+  enum: ["unwritable enum", "unwritable enums"],
+  unused_enum: ["unused enum", "unused enums"],
+  class: ["class", "classes"],
+  slot: ["slot", "slots"],
+  schema: ["schema key", "schema keys"],
+  // `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"]);
+function formatDropped(dropped) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of dropped) {
+    const group = groups.get(entry.kind);
+    if (group === void 0) groups.set(entry.kind, [entry]);
+    else group.push(entry);
+  }
+  const drops = [];
+  let renamed = "";
+  let inlined = "";
+  for (const [kind, entries] of groups) {
+    const phrase = phraseFor(kind, entries);
+    if (kind === "renamed") renamed = phrase;
+    else if (kind === "inlined") inlined = phrase;
+    else drops.push(phrase);
+  }
+  const sentences = [];
+  if (drops.length > 0) sentences.push(`Dropped: ${drops.join(", ")}.`);
+  if (renamed !== "") sentences.push(`Renamed: ${renamed}.`);
+  if (inlined !== "") sentences.push(`Inlined: ${inlined}.`);
+  return sentences.join(" ");
+}
+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)}`;
+}
+function nounFor(kind, 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";
+  return one ? "element" : "elements";
+}
+var capitalise2 = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+var decapitalise = (text) => text.charAt(0).toLowerCase() + text.slice(1);
+var parts = (text) => text.split(/[^A-Za-z0-9]+/).filter((part) => part !== "");
+function toClassName(text) {
+  if (CLASS_NAME.test(text)) return text;
+  const name2 = parts(text).map(capitalise2).join("");
+  if (name2 === "") return "Class";
+  return CLASS_NAME.test(name2) ? name2 : `X${name2}`;
+}
+function toFieldName(text) {
+  if (FIELD_NAME.test(text)) return text;
+  const name2 = parts(text).map((part, i) => i === 0 ? decapitalise(part) : capitalise2(part)).join("");
+  if (name2 === "") return "field";
+  return FIELD_NAME.test(name2) ? name2 : `x${capitalise2(name2)}`;
+}
+function unique(base, taken) {
+  let name2 = base;
+  for (let n = 2; taken.has(name2); n++) name2 = `${base}${n}`;
+  taken.add(name2);
+  return name2;
+}
+var get = (record, key2) => Object.hasOwn(record, key2) ? record[key2] : void 0;
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  return value;
+}
+var present = (value) => value !== void 0 && value !== null;
+function shown(value) {
+  if (Array.isArray(value)) return "a list";
+  if (typeof value === "object" && value !== null) return "a map";
+  return `\`${String(value)}\``;
+}
+function localName(mapping) {
+  let cut = -1;
+  for (const mark of [":", "/", "#"]) cut = Math.max(cut, mapping.lastIndexOf(mark));
+  return mapping.slice(cut + 1);
+}
+var stringOf = (value) => typeof value === "string" && value !== "" ? value : void 0;
+var stringList = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+function annotationsOf(def) {
+  const out = /* @__PURE__ */ new Map();
+  const annotations = asRecord(get(def, "annotations"));
+  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));
+  }
+  return out;
+}
+function slotKeysOf(def) {
+  const keys = Object.keys(asRecord(get(def, "attributes")) ?? {});
+  for (const slot of stringList(get(def, "slots"))) {
+    if (!keys.includes(slot)) keys.push(slot);
+  }
+  return keys;
+}
+function oneLine(text) {
+  if (text === void 0) return void 0;
+  const line = text.replace(/\s*[\r\n]+\s*/g, " ").trim();
+  return line === "" ? void 0 : line;
+}
+var list = (items) => items.map((item) => `\`${item}\``).join(", ");
+var at0 = (text) => ({ text, line: 0, col: 0, end: 0 });
+var stringType = (many) => ({
+  kind: "primitive",
+  name: "string",
+  written: at0("string"),
+  many
+});
+var schemaElement = (root) => stringOf(get(root, "name")) ?? "schema";
+var nothing = (element, detail) => ({
+  document: parse(""),
+  source: "",
+  dropped: [{ kind: "schema", element, detail }]
+});
+
+// src/import.ts
+import { parse as parseYAML } from "yaml";
+function importLinkML(text) {
+  let schema;
+  try {
+    schema = parseYAML(text);
+  } catch (error) {
+    return { output: "", dropped: [], diagnostics: [notYAML(error)] };
+  }
+  const { document, source, dropped } = fromLinkML(schema);
+  return { output: source, dropped, diagnostics: resolve(document).diagnostics };
+}
+function notYAML(error) {
+  const first = error instanceof Error ? error.message.split("\n")[0] ?? "" : String(error);
+  const detail = first.replace(/:$/, "");
+  return {
+    severity: "error",
+    code: "E_NOT_YAML",
+    message: `the input is not YAML: ${detail}`,
+    line: 1
+  };
+}
+
 // src/index.ts
-var VERSION = "0.2.0";
+var VERSION = "0.3.0";
 
 // src/cli.ts
 var HELP = `Usage: skiss <command> [options]
@@ -927,6 +1425,7 @@ 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.
+  import <file>        Write Skiss for a LinkML schema file, YAML or JSON.
                        <file> may be - to read standard input.
 
 Options:
@@ -936,13 +1435,18 @@ Options:
       --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
+      --strict         Exit 1 when the input has any diagnostic; for import,
+                       also when the projection dropped anything
   -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>
 
+import writes what the projection could not carry to standard error too, as
+one line before the diagnostics. Its diagnostics are the ones the sketch it
+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)
@@ -955,7 +1459,8 @@ var EXIT_USAGE = 2;
 var EXIT_INTERNAL = 70;
 var COMMANDS = {
   diagram: ["output", "notes", "strict"],
-  compile: ["output", "json", "name", "strict"]
+  compile: ["output", "json", "name", "strict"],
+  import: ["output", "strict"]
 };
 var isCommand = (text) => Object.hasOwn(COMMANDS, text);
 var UsageError = class extends Error {
@@ -1006,17 +1511,31 @@ async function main(argv) {
     }
   }
   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 { output, diagnostics, dropped } = runCommand(command, source, file, values);
   const label = file === "-" ? "<stdin>" : file;
+  const report = formatDropped(dropped);
+  if (report !== "") process.stderr.write(`${report}
+`);
   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;
+  const strict = values.strict === true && (diagnostics.length > 0 || dropped.length > 0);
+  return strict ? EXIT_STRICT : EXIT_OK;
+}
+function runCommand(command, source, file, values) {
+  if (command === "import") return importLinkML(source);
+  if (command === "compile") {
+    return {
+      ...compile(source, {
+        target: "linkml",
+        schemaName: values.name ?? defaultSchemaName(file),
+        format: values.json === true ? "json" : "yaml"
+      }),
+      dropped: []
+    };
+  }
+  return { ...compile(source, { target: "mermaid", notes: values.notes }), dropped: [] };
 }
 var defaultSchemaName = (file) => file === "-" ? "sketch" : basename(file, extname(file));
 async function readSource(file) {