openapi-typesafe 1.0.0-rc.3 → 1.0.0-rc.5

package/src/domain/ir/identifier-text.ts

@@ -2,11 +2,12 @@ import { NEWER_IDENTIFIER_PART, NEWER_IDENTIFIER_START } from "./newer-identifie
 
 /**
  * Identifier rules of ECMAScript (Unicode `ID_Start` / `ID_Continue`, plus `$`, `_`, ZWNJ and
- * ZWJ), for names built from document text, without the characters that TypeScript's scanner
- * does not know yet. Node.js follows a newer Unicode version than TypeScript's identifier tables,
- * so a name such as `꟒Name` (Unicode 17) passed here and failed to parse with "Invalid
- * character" (ADR-019). Removing the newer characters also gives the same names on every
- * supported Node.js version.
+ * ZWJ), for names built from document text, without the characters that the scanner of the lowest
+ * supported TypeScript (5.4) does not know. Node.js follows a newer Unicode version than
+ * TypeScript's identifier tables, so a name such as `꟒Name` (Unicode 17) passed here and failed to
+ * parse with "Invalid character" (ADR-019); TypeScript 5.4 also rejects ZWJ and characters that
+ * TypeScript 6 accepts. Removing these also gives the same names on every supported Node.js
+ * version.
  */
 
 const IDENTIFIER_START_RE = new RegExp(

package/src/domain/ir/ir-shape.ts

@@ -0,0 +1,299 @@
+import { hasIdentifierStart, withIdentifierParts } from "./identifier-text.js";
+import type { IrKeyword, IrPropertySignature, IrType } from "./nodes.js";
+
+/**
+ * Whether a value from outside the package (an IR callback's result) is IR the printer writes as
+ * valid TypeScript. JavaScript callers can return any value, and the type checker of a
+ * TypeScript caller does not stop `{ kind: "union", types: [] }` or an empty type text either:
+ * without this check such a result crashed the printer with an untyped error, or printed text
+ * such as `a?: ;`. Raw type text is printed as written, so only blank text is rejected; the text
+ * itself is the caller's TypeScript, which the caller's compiler checks.
+ */
+
+type Fields = Readonly<Record<string, unknown>>;
+
+const KEYWORDS: ReadonlySet<string> = new Set<IrKeyword>([
+  "string",
+  "number",
+  "boolean",
+  "null",
+  "undefined",
+  "unknown",
+  "never",
+]);
+
+const STRING_ENCODINGS: ReadonlySet<unknown> = new Set([undefined, "json", "escaped"]);
+
+function isFields(value: unknown): value is Fields {
+  return typeof value === "object" && value !== null;
+}
+
+function isText(value: unknown): value is string {
+  return typeof value === "string" && value.trim() !== "";
+}
+
+function isIdentifier(text: unknown): boolean {
+  return typeof text === "string" && hasIdentifierStart(text) && withIdentifierParts(text) === text;
+}
+
+/** The prefix of a type query: the generator writes `typeof Status` as a reference name. */
+const TYPE_QUERY_PREFIX = "typeof ";
+
+/**
+ * Words that cannot start the name of a type query (`typeof <name>`): `import` starts an import
+ * type, and strict mode reserves the others. Found with the TypeScript 5.4 and 6.0 compilers
+ * (syntax and grammar errors) on `type A = { a?: typeof <name> }`, over every reserved word and
+ * contextual keyword. A name after a `.` may be any identifier, reserved words included.
+ */
+const NOT_TYPE_QUERY_START: ReadonlySet<string> = new Set(
+  "import implements interface let package private protected public static yield".split(" "),
+);
+/** Words that cannot start a type reference either: they are operators of a type there. */
+const NOT_TYPE_REFERENCE_START: ReadonlySet<string> = new Set([
+  ...NOT_TYPE_QUERY_START,
+  ..."new typeof infer keyof readonly unique".split(" "),
+]);
+
+/**
+ * A name TypeScript reads as the name of a type: identifiers joined by `.` (`Status`,
+ * `Status.active`), optionally as a type query (`typeof Status`). Text such as `a b` or `A<B>`
+ * would print as other or invalid TypeScript, and so would `keyof` or `let` as the first name;
+ * type arguments go in `typeArguments`.
+ */
+function isTypeName(text: unknown): boolean {
+  if (typeof text !== "string") {
+    return false;
+  }
+  const isQuery = text.startsWith(TYPE_QUERY_PREFIX);
+  const names = (isQuery ? text.slice(TYPE_QUERY_PREFIX.length) : text).split(".");
+  const reserved = isQuery ? NOT_TYPE_QUERY_START : NOT_TYPE_REFERENCE_START;
+  return names.every(isIdentifier) && !reserved.has(names[0] as string);
+}
+
+/** A non-negative number written as JavaScript writes it, as `toPropertyName` makes them. */
+function isNumberName(text: unknown): boolean {
+  return typeof text === "string" && String(Number(text)) === text && !text.startsWith("-");
+}
+
+/** Walks one value; `ancestors` makes a cycle invalid instead of an endless recursion. */
+class IrShapeCheck {
+  readonly #ancestors = new Set<object>();
+
+  isType(value: unknown): boolean {
+    return this.#within(value, (node) => {
+      const check = TYPE_CHECKS[node.kind as IrType["kind"]];
+      return Object.hasOwn(TYPE_CHECKS, String(node.kind)) && check(node, this);
+    });
+  }
+
+  isTypeList(value: unknown, isEmptyAllowed: boolean): boolean {
+    return (
+      Array.isArray(value) &&
+      (isEmptyAllowed || value.length > 0) &&
+      value.every((entry) => this.isType(entry))
+    );
+  }
+
+  isMember(value: unknown): boolean {
+    return isFields(value) && value.kind === "indexSignature"
+      ? this.#within(value, (node) => this.#isIndexSignature(node))
+      : this.isProperty(value);
+  }
+
+  isProperty(value: unknown): boolean {
+    return this.#within(
+      value,
+      (node) =>
+        node.kind === "property" &&
+        isPropertyName(node.name) &&
+        this.isType(node.type) &&
+        typeof node.isOptional === "boolean" &&
+        typeof node.isReadonly === "boolean" &&
+        areComments(node.comments),
+    );
+  }
+
+  #isIndexSignature(node: Fields): boolean {
+    return (
+      isIdentifier(node.parameterName) &&
+      this.isType(node.parameterType) &&
+      isIndexParameterType(node.parameterType as IrType) &&
+      this.isType(node.type) &&
+      typeof node.isReadonly === "boolean" &&
+      areComments(node.comments)
+    );
+  }
+
+  #within(value: unknown, check: (node: Fields) => boolean): boolean {
+    if (!isFields(value) || this.#ancestors.has(value)) {
+      return false;
+    }
+    this.#ancestors.add(value);
+    try {
+      return check(value);
+    } finally {
+      this.#ancestors.delete(value);
+    }
+  }
+}
+
+/**
+ * What an index signature parameter type reduces to: `string`, `number`, or an object type that
+ * tags one of them (`string & {}`), each as an atom; `unresolved` for a name, an indexed access
+ * (`K["a"]`) or type text, which only TypeScript can resolve; undefined for a type that can never
+ * be one (a literal, an array, a tuple, `readonly`, another keyword).
+ */
+type IndexAtom = "string" | "number" | "tag";
+type IndexKeys = ReadonlySet<IndexAtom> | "unresolved";
+
+/** The keywords an index signature takes as its parameter type, as atoms. */
+const INDEX_KEYWORD_ATOMS: ReadonlyMap<string, IndexAtom> = new Map([
+  ["string", "string"],
+  ["number", "number"],
+]);
+
+const TAG: IndexAtom = "tag";
+const UNRESOLVED = "unresolved";
+
+/** One atom of each side together: a tag keeps the other side, two keys must be the same. */
+function intersectAtoms(left: IndexAtom, right: IndexAtom): IndexAtom | undefined {
+  if (left === right || right === TAG) {
+    return left;
+  }
+  return left === TAG ? right : undefined;
+}
+
+/** `A & B` over atoms, as TypeScript spreads an intersection over the members of a union. */
+function intersectKeys(left: IndexKeys, right: IndexKeys): IndexKeys {
+  if (left === UNRESOLVED || right === UNRESOLVED) {
+    return UNRESOLVED;
+  }
+  const atoms = [...left].flatMap((atom) => [...right].map((other) => intersectAtoms(atom, other)));
+  return new Set(atoms.filter((atom) => atom !== undefined));
+}
+
+/** `A | B` over atoms. */
+function unionKeys(left: IndexKeys, right: IndexKeys): IndexKeys {
+  return left === UNRESOLVED || right === UNRESOLVED ? UNRESOLVED : new Set([...left, ...right]);
+}
+
+/** The keys of each member combined, or undefined when one member can never be a key. */
+function combineKeys(
+  types: readonly IrType[],
+  combine: (left: IndexKeys, right: IndexKeys) => IndexKeys,
+): IndexKeys | undefined {
+  let combined: IndexKeys | undefined;
+  for (const member of types) {
+    const keys = indexKeys(member);
+    if (keys === undefined) {
+      return undefined;
+    }
+    combined = combined === undefined ? keys : combine(combined, keys);
+  }
+  return combined;
+}
+
+function indexKeys(type: IrType): IndexKeys | undefined {
+  switch (type.kind) {
+    case "keyword": {
+      const atom = INDEX_KEYWORD_ATOMS.get(type.keyword);
+      return atom === undefined ? undefined : new Set([atom]);
+    }
+    case "object":
+      return new Set([TAG]);
+    case "reference":
+    case "indexedAccess":
+    case "raw":
+      return UNRESOLVED;
+    case "union":
+      return combineKeys(type.types, unionKeys);
+    case "intersection":
+      return combineKeys(type.types, intersectKeys);
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Whether a type can be the parameter type of an index signature. TypeScript takes `string`,
+ * `number`, `symbol`, a template literal type, a union of these, or one of them tagged by an
+ * intersection (`string & {}`); anything else fails with TS1268 or TS1337. It decides by the
+ * resolved type, so `string & "a"` (the literal `"a"`), `string & number` (`never`) and an
+ * object type alone are refused, and a name, an indexed access and type text pass for TypeScript
+ * to check.
+ */
+function isIndexParameterType(type: IrType): boolean {
+  const keys = indexKeys(type);
+  return keys === UNRESOLVED || (keys !== undefined && keys.size > 0 && !keys.has(TAG));
+}
+
+function isPropertyName(value: unknown): boolean {
+  if (!isFields(value)) {
+    return false;
+  }
+  switch (value.kind) {
+    case "identifier":
+      return isIdentifier(value.text);
+    case "number":
+      return isNumberName(value.text);
+    case "string":
+      return typeof value.value === "string";
+    default:
+      return false;
+  }
+}
+
+/** A block comment must not end itself early (`*\/`); a line comment must stay on its line. */
+function isComment(value: unknown): boolean {
+  if (!isFields(value) || typeof value.text !== "string") {
+    return false;
+  }
+  return value.kind === "block"
+    ? !value.text.includes("*/")
+    : value.kind === "line" && !/[\n\r\u2028\u2029]/.test(value.text);
+}
+
+function areComments(value: unknown): boolean {
+  return Array.isArray(value) && value.every(isComment);
+}
+
+function isTupleElement(value: unknown, check: IrShapeCheck): boolean {
+  return (
+    isFields(value) &&
+    check.isType(value.type) &&
+    typeof value.isRest === "boolean" &&
+    typeof value.isOptional === "boolean" &&
+    !(value.isRest && value.isOptional)
+  );
+}
+
+/** One check per kind; the `Record` makes a new kind fail to compile until it is checked. */
+const TYPE_CHECKS: Readonly<
+  Record<IrType["kind"], (node: Fields, check: IrShapeCheck) => boolean>
+> = {
+  keyword: (node) => KEYWORDS.has(node.keyword as string),
+  stringLiteral: (node) => typeof node.value === "string" && STRING_ENCODINGS.has(node.encoding),
+  numberLiteral: (node) => Number.isFinite(node.value),
+  booleanLiteral: (node) => typeof node.value === "boolean",
+  reference: (node, check) => isTypeName(node.name) && check.isTypeList(node.typeArguments, true),
+  array: (node, check) => check.isType(node.element),
+  tuple: (node, check) =>
+    Array.isArray(node.elements) && node.elements.every((entry) => isTupleElement(entry, check)),
+  union: (node, check) => check.isTypeList(node.types, false),
+  intersection: (node, check) => check.isTypeList(node.types, false),
+  object: (node, check) =>
+    Array.isArray(node.members) && node.members.every((member) => check.isMember(member)),
+  indexedAccess: (node, check) => check.isType(node.object) && check.isType(node.index),
+  readonly: (node, check) => check.isType(node.type),
+  raw: (node) => isText(node.text),
+};
+
+/** Whether `value` is an IR type the printer writes as valid TypeScript. */
+export function isPrintableIrType(value: unknown): value is IrType {
+  return new IrShapeCheck().isType(value);
+}
+
+/** Whether `value` is an IR property signature the printer writes as valid TypeScript. */
+export function isPrintableIrProperty(value: unknown): value is IrPropertySignature {
+  return new IrShapeCheck().isProperty(value);
+}

package/src/domain/ir/newer-identifier-ranges.ts

@@ -1,22 +1,52 @@
 // Generated by scripts/identifier-ranges.ts (Node.js 26.0.0, Unicode
-// 17.0, TypeScript 5.9.3). Do not edit.
+// 17.0, TypeScript 5.4.5). Do not edit.
 
 /** `ID_Start` code points that TypeScript's scanner does not accept, as regex class items. */
 export const NEWER_IDENTIFIER_START: readonly string[] = [
-  "\\u{88F}",
-  "\\u{C5C}",
-  "\\u{CDC}",
+  "\\u{870}-\\u{887}",
+  "\\u{889}-\\u{88F}",
+  "\\u{8B5}",
+  "\\u{8BE}-\\u{8C9}",
+  "\\u{C5C}-\\u{C5D}",
+  "\\u{CDC}-\\u{CDD}",
+  "\\u{D04}",
+  "\\u{170D}",
+  "\\u{171F}",
+  "\\u{1B4C}",
   "\\u{1C89}-\\u{1C8A}",
-  "\\u{A7CB}-\\u{A7CF}",
-  "\\u{A7D2}",
-  "\\u{A7D4}",
-  "\\u{A7DA}-\\u{A7DC}",
-  "\\u{A7F1}",
+  "\\u{2C2F}",
+  "\\u{2C5F}",
+  "\\u{31BB}-\\u{31BF}",
+  "\\u{4DB6}-\\u{4DBF}",
+  "\\u{9FF0}-\\u{9FFF}",
+  "\\u{A7C0}-\\u{A7C1}",
+  "\\u{A7C7}-\\u{A7DC}",
+  "\\u{A7F1}-\\u{A7F6}",
+  "\\u{AB68}-\\u{AB69}",
+  "\\u{10570}-\\u{1057A}",
+  "\\u{1057C}-\\u{1058A}",
+  "\\u{1058C}-\\u{10592}",
+  "\\u{10594}-\\u{10595}",
+  "\\u{10597}-\\u{105A1}",
+  "\\u{105A3}-\\u{105B1}",
+  "\\u{105B3}-\\u{105B9}",
+  "\\u{105BB}-\\u{105BC}",
   "\\u{105C0}-\\u{105F3}",
+  "\\u{10780}-\\u{10785}",
+  "\\u{10787}-\\u{107B0}",
+  "\\u{107B2}-\\u{107BA}",
   "\\u{10940}-\\u{10959}",
   "\\u{10D4A}-\\u{10D65}",
   "\\u{10D6F}-\\u{10D85}",
+  "\\u{10E80}-\\u{10EA9}",
+  "\\u{10EB0}-\\u{10EB1}",
   "\\u{10EC2}-\\u{10EC7}",
+  "\\u{10F70}-\\u{10F81}",
+  "\\u{10FB0}-\\u{10FC4}",
+  "\\u{11071}-\\u{11072}",
+  "\\u{11075}",
+  "\\u{11147}",
+  "\\u{1123F}-\\u{11240}",
   "\\u{11380}-\\u{11389}",
   "\\u{1138B}",
   "\\u{1138E}",
@@ -24,18 +54,47 @@ export const NEWER_IDENTIFIER_START: readonly string[] = [
   "\\u{113B7}",
   "\\u{113D1}",
   "\\u{113D3}",
+  "\\u{11460}-\\u{11461}",
+  "\\u{11740}-\\u{11746}",
+  "\\u{11900}-\\u{11906}",
+  "\\u{11909}",
+  "\\u{1190C}-\\u{11913}",
+  "\\u{11915}-\\u{11916}",
+  "\\u{11918}-\\u{1192F}",
+  "\\u{1193F}",
+  "\\u{11941}",
+  "\\u{11AB0}-\\u{11ABF}",
   "\\u{11BC0}-\\u{11BE0}",
   "\\u{11DB0}-\\u{11DDB}",
+  "\\u{11F02}",
+  "\\u{11F04}-\\u{11F10}",
+  "\\u{11F12}-\\u{11F33}",
+  "\\u{11FB0}",
+  "\\u{12F90}-\\u{12FF0}",
+  "\\u{1342F}",
+  "\\u{13441}-\\u{13446}",
   "\\u{13460}-\\u{143FA}",
   "\\u{16100}-\\u{1611D}",
+  "\\u{16A70}-\\u{16ABE}",
   "\\u{16D40}-\\u{16D6C}",
   "\\u{16EA0}-\\u{16EB8}",
   "\\u{16EBB}-\\u{16ED3}",
   "\\u{16FF2}-\\u{16FF6}",
   "\\u{187F8}-\\u{187FF}",
-  "\\u{18CFF}",
-  "\\u{18D09}-\\u{18D1E}",
+  "\\u{18AF3}-\\u{18CD5}",
+  "\\u{18CFF}-\\u{18D1E}",
   "\\u{18D80}-\\u{18DF2}",
+  "\\u{1AFF0}-\\u{1AFF3}",
+  "\\u{1AFF5}-\\u{1AFFB}",
+  "\\u{1AFFD}-\\u{1AFFE}",
+  "\\u{1B11F}-\\u{1B122}",
+  "\\u{1B132}",
+  "\\u{1B155}",
+  "\\u{1DF00}-\\u{1DF1E}",
+  "\\u{1DF25}-\\u{1DF2A}",
+  "\\u{1E030}-\\u{1E06D}",
+  "\\u{1E290}-\\u{1E2AD}",
+  "\\u{1E4D0}-\\u{1E4EB}",
   "\\u{1E5D0}-\\u{1E5ED}",
   "\\u{1E5F0}",
   "\\u{1E6C0}-\\u{1E6DE}",
@@ -44,32 +103,83 @@ export const NEWER_IDENTIFIER_START: readonly string[] = [
   "\\u{1E6E7}-\\u{1E6ED}",
   "\\u{1E6F0}-\\u{1E6F4}",
   "\\u{1E6FE}-\\u{1E6FF}",
-  "\\u{2B73A}-\\u{2B73F}",
+  "\\u{1E7E0}-\\u{1E7E6}",
+  "\\u{1E7E8}-\\u{1E7EB}",
+  "\\u{1E7ED}-\\u{1E7EE}",
+  "\\u{1E7F0}-\\u{1E7FE}",
+  "\\u{2A6D7}-\\u{2A6DF}",
+  "\\u{2B735}-\\u{2B73F}",
   "\\u{2CEA2}-\\u{2CEAD}",
-  "\\u{323B0}-\\u{33479}",
+  "\\u{2EBF0}-\\u{2EE5D}",
+  "\\u{30000}-\\u{3134A}",
+  "\\u{31350}-\\u{33479}",
 ];
 
 /** `ID_Continue` code points that TypeScript's scanner does not accept, as regex class items. */
 export const NEWER_IDENTIFIER_PART: readonly string[] = [
-  "\\u{88F}",
-  "\\u{897}",
-  "\\u{C5C}",
-  "\\u{CDC}",
-  "\\u{1ACF}-\\u{1ADD}",
+  "\\u{870}-\\u{887}",
+  "\\u{889}-\\u{88F}",
+  "\\u{897}-\\u{89F}",
+  "\\u{8B5}",
+  "\\u{8BE}-\\u{8D2}",
+  "\\u{B55}",
+  "\\u{C3C}",
+  "\\u{C5C}-\\u{C5D}",
+  "\\u{CDC}-\\u{CDD}",
+  "\\u{CF3}",
+  "\\u{D04}",
+  "\\u{D81}",
+  "\\u{ECE}",
+  "\\u{170D}",
+  "\\u{1715}",
+  "\\u{171F}",
+  "\\u{180F}",
+  "\\u{1ABF}-\\u{1ADD}",
   "\\u{1AE0}-\\u{1AEB}",
+  "\\u{1B4C}",
   "\\u{1C89}-\\u{1C8A}",
-  "\\u{A7CB}-\\u{A7CF}",
-  "\\u{A7D2}",
-  "\\u{A7D4}",
-  "\\u{A7DA}-\\u{A7DC}",
-  "\\u{A7F1}",
+  "\\u{1DFA}",
+  "\\u{200C}-\\u{200D}",
+  "\\u{2C2F}",
+  "\\u{2C5F}",
+  "\\u{30FB}",
+  "\\u{31BB}-\\u{31BF}",
+  "\\u{4DB6}-\\u{4DBF}",
+  "\\u{9FF0}-\\u{9FFF}",
+  "\\u{A7C0}-\\u{A7C1}",
+  "\\u{A7C7}-\\u{A7DC}",
+  "\\u{A7F1}-\\u{A7F6}",
+  "\\u{A82C}",
+  "\\u{AB68}-\\u{AB69}",
+  "\\u{FF65}",
+  "\\u{10570}-\\u{1057A}",
+  "\\u{1057C}-\\u{1058A}",
+  "\\u{1058C}-\\u{10592}",
+  "\\u{10594}-\\u{10595}",
+  "\\u{10597}-\\u{105A1}",
+  "\\u{105A3}-\\u{105B1}",
+  "\\u{105B3}-\\u{105B9}",
+  "\\u{105BB}-\\u{105BC}",
   "\\u{105C0}-\\u{105F3}",
+  "\\u{10780}-\\u{10785}",
+  "\\u{10787}-\\u{107B0}",
+  "\\u{107B2}-\\u{107BA}",
   "\\u{10940}-\\u{10959}",
   "\\u{10D40}-\\u{10D65}",
   "\\u{10D69}-\\u{10D6D}",
   "\\u{10D6F}-\\u{10D85}",
+  "\\u{10E80}-\\u{10EA9}",
+  "\\u{10EAB}-\\u{10EAC}",
+  "\\u{10EB0}-\\u{10EB1}",
   "\\u{10EC2}-\\u{10EC7}",
-  "\\u{10EFA}-\\u{10EFC}",
+  "\\u{10EFA}-\\u{10EFF}",
+  "\\u{10F70}-\\u{10F85}",
+  "\\u{10FB0}-\\u{10FC4}",
+  "\\u{11070}-\\u{11075}",
+  "\\u{110C2}",
+  "\\u{11147}",
+  "\\u{111CE}-\\u{111CF}",
+  "\\u{1123F}-\\u{11241}",
   "\\u{11380}-\\u{11389}",
   "\\u{1138B}",
   "\\u{1138E}",
@@ -80,30 +190,73 @@ export const NEWER_IDENTIFIER_PART: readonly string[] = [
   "\\u{113C7}-\\u{113CA}",
   "\\u{113CC}-\\u{113D3}",
   "\\u{113E1}-\\u{113E2}",
+  "\\u{11460}-\\u{11461}",
   "\\u{116D0}-\\u{116E3}",
+  "\\u{11740}-\\u{11746}",
+  "\\u{11900}-\\u{11906}",
+  "\\u{11909}",
+  "\\u{1190C}-\\u{11913}",
+  "\\u{11915}-\\u{11916}",
+  "\\u{11918}-\\u{11935}",
+  "\\u{11937}-\\u{11938}",
+  "\\u{1193B}-\\u{11943}",
+  "\\u{11950}-\\u{11959}",
+  "\\u{11AB0}-\\u{11ABF}",
   "\\u{11B60}-\\u{11B67}",
   "\\u{11BC0}-\\u{11BE0}",
   "\\u{11BF0}-\\u{11BF9}",
   "\\u{11DB0}-\\u{11DDB}",
   "\\u{11DE0}-\\u{11DE9}",
-  "\\u{11F5A}",
+  "\\u{11F00}-\\u{11F10}",
+  "\\u{11F12}-\\u{11F3A}",
+  "\\u{11F3E}-\\u{11F42}",
+  "\\u{11F50}-\\u{11F5A}",
+  "\\u{11FB0}",
+  "\\u{12F90}-\\u{12FF0}",
+  "\\u{1342F}",
+  "\\u{13440}-\\u{13455}",
   "\\u{13460}-\\u{143FA}",
   "\\u{16100}-\\u{16139}",
+  "\\u{16A70}-\\u{16ABE}",
+  "\\u{16AC0}-\\u{16AC9}",
   "\\u{16D40}-\\u{16D6C}",
   "\\u{16D70}-\\u{16D79}",
   "\\u{16EA0}-\\u{16EB8}",
   "\\u{16EBB}-\\u{16ED3}",
-  "\\u{16FF2}-\\u{16FF6}",
+  "\\u{16FE4}",
+  "\\u{16FF0}-\\u{16FF6}",
   "\\u{187F8}-\\u{187FF}",
-  "\\u{18CFF}",
-  "\\u{18D09}-\\u{18D1E}",
+  "\\u{18AF3}-\\u{18CD5}",
+  "\\u{18CFF}-\\u{18D1E}",
   "\\u{18D80}-\\u{18DF2}",
+  "\\u{1AFF0}-\\u{1AFF3}",
+  "\\u{1AFF5}-\\u{1AFFB}",
+  "\\u{1AFFD}-\\u{1AFFE}",
+  "\\u{1B11F}-\\u{1B122}",
+  "\\u{1B132}",
+  "\\u{1B155}",
   "\\u{1CCF0}-\\u{1CCF9}",
+  "\\u{1CF00}-\\u{1CF2D}",
+  "\\u{1CF30}-\\u{1CF46}",
+  "\\u{1DF00}-\\u{1DF1E}",
+  "\\u{1DF25}-\\u{1DF2A}",
+  "\\u{1E030}-\\u{1E06D}",
+  "\\u{1E08F}",
+  "\\u{1E290}-\\u{1E2AE}",
+  "\\u{1E4D0}-\\u{1E4F9}",
   "\\u{1E5D0}-\\u{1E5FA}",
   "\\u{1E6C0}-\\u{1E6DE}",
   "\\u{1E6E0}-\\u{1E6F5}",
   "\\u{1E6FE}-\\u{1E6FF}",
-  "\\u{2B73A}-\\u{2B73F}",
+  "\\u{1E7E0}-\\u{1E7E6}",
+  "\\u{1E7E8}-\\u{1E7EB}",
+  "\\u{1E7ED}-\\u{1E7EE}",
+  "\\u{1E7F0}-\\u{1E7FE}",
+  "\\u{1FBF0}-\\u{1FBF9}",
+  "\\u{2A6D7}-\\u{2A6DF}",
+  "\\u{2B735}-\\u{2B73F}",
   "\\u{2CEA2}-\\u{2CEAD}",
-  "\\u{323B0}-\\u{33479}",
+  "\\u{2EBF0}-\\u{2EE5D}",
+  "\\u{30000}-\\u{3134A}",
+  "\\u{31350}-\\u{33479}",
 ];

package/src/domain/location-text.ts

@@ -0,0 +1,12 @@
+/** How a location the user writes, as a CLI argument or an option string, is read. */
+
+/**
+ * A scheme of two or more characters (`https:`, `file:`). One letter is a Windows drive (`C:`), so
+ * `C:\\specs\\api.yaml` stays a path.
+ */
+const URL_SCHEME = /^[a-z][a-z\d+.-]+:/i;
+
+/** Whether the location is written as a URL, not as a file path. */
+export function hasUrlScheme(location: string): boolean {
+  return URL_SCHEME.test(location);
+}

package/src/domain/openapi/alias-expansion.ts

@@ -53,7 +53,10 @@ export function countNodes(root: unknown): NodeCounts {
       ? childrenOf(node).filter((child) => isContainer(child) && !entered.has(child))
       : [];
     if (pending.length > 0) {
-      stack.push(...(pending as object[]));
+      // One push per child: spreading an array of millions of children overflows the stack.
+      for (const child of pending as object[]) {
+        stack.push(child);
+      }
       continue;
     }
     stack.pop();

package/src/domain/openapi/discriminated-union.ts

@@ -1,4 +1,4 @@
-import { escapePointerSegment } from "./json-pointer.js";
+import { canonicalRef, escapePointerSegment } from "./json-pointer.js";
 import type { Schema, SchemaObject } from "./schema-object.js";
 
 /**
@@ -51,7 +51,7 @@ function reaches(schema: Schema, search: Search): boolean {
   }
   const ref = (schema as { readonly $ref?: unknown }).$ref;
   if (typeof ref === "string") {
-    if (ref === search.target) {
+    if (canonicalRef(ref) === canonicalRef(search.target)) {
       return true;
     }
     if (search.visited.has(ref)) {
@@ -84,7 +84,9 @@ function mappingRef(target: unknown): string | undefined {
   if (typeof target !== "string") {
     return undefined;
   }
-  return target.startsWith("#") ? target : `${COMPONENT_SCHEMAS}${escapePointerSegment(target)}`;
+  return target.startsWith("#")
+    ? canonicalRef(target)
+    : `${COMPONENT_SCHEMAS}${escapePointerSegment(target)}`;
 }
 
 /** Whether the discriminator `mapping` of `union` names the schema at `target`. */
@@ -93,7 +95,7 @@ export function unionMaps(union: SchemaObject, target: string): boolean {
   if (!isSchemaObject(mapping)) {
     return false;
   }
-  return Object.values(mapping).some((value) => mappingRef(value) === target);
+  return Object.values(mapping).some((value) => mappingRef(value) === canonicalRef(target));
 }
 
 /**