openapi-typesafe 0.0.0 → 1.0.0-rc.0

package/src/application/print/print-nodes.ts

@@ -0,0 +1,62 @@
+import type { IrDeclaration, IrMember, IrType } from "../../domain/ir/nodes.js";
+import { writeDeclaration } from "./declaration-printer.js";
+import { DEFAULT_PRINT_OPTIONS, type PrintOptions } from "./print-options.js";
+import { TextWriter } from "./text-writer.js";
+import { writeMember, writeType } from "./type-printer.js";
+
+/**
+ * Print declarations as a TypeScript file body: one declaration per line, a line break at the end,
+ * and nothing for an empty list. Pure and deterministic (ENGINEERING_PLAN §4.3).
+ */
+export function printNodes(
+  declarations: readonly IrDeclaration[],
+  options: PrintOptions = DEFAULT_PRINT_OPTIONS,
+): string {
+  const writer = new TextWriter(options);
+  for (const declaration of declarations) {
+    writeDeclaration(writer, declaration);
+  }
+  writer.writeLine();
+  return writer.text;
+}
+
+/** Anything the IR printer can print at the top level of a file. */
+export type IrPrintable = IrDeclaration | IrMember | IrType;
+
+const DECLARATION_KINDS: ReadonlySet<string> = new Set<IrDeclaration["kind"]>([
+  "interface",
+  "typeAlias",
+  "enum",
+  "constArray",
+  "rawDeclaration",
+]);
+const MEMBER_KINDS: ReadonlySet<string> = new Set<IrMember["kind"]>(["property", "indexSignature"]);
+
+function writePrintable(writer: TextWriter, node: IrPrintable): void {
+  if (DECLARATION_KINDS.has(node.kind)) {
+    writeDeclaration(writer, node as IrDeclaration);
+    return;
+  }
+  writer.writeLine();
+  if (MEMBER_KINDS.has(node.kind)) {
+    writeMember(writer, node as IrMember);
+  } else {
+    writeType(writer, node as IrType);
+  }
+}
+
+/**
+ * Print declarations, members or types, one per line, as the TypeScript printer prints such nodes
+ * placed in a file (the original `astToString` accepted any node).
+ */
+export function printFragments(
+  nodes: readonly IrPrintable[],
+  options: PrintOptions = DEFAULT_PRINT_OPTIONS,
+): string {
+  const writer = new TextWriter(options);
+  for (const node of nodes) {
+    writePrintable(writer, node);
+  }
+  writer.writeLine();
+  return writer.text;
+}

package/src/application/print/print-options.ts

@@ -0,0 +1,11 @@
+/**
+ * Formatting rules of the printer as data (ENGINEERING_PLAN §4.3). The defaults reproduce the
+ * TypeScript printer that the original generator used: 4-space indentation and LF line endings.
+ */
+export interface PrintOptions {
+  /** Columns per indentation level; also the tab width used when re-indenting comment lines. */
+  readonly indentSize: number;
+  readonly newLine: string;
+}
+
+export const DEFAULT_PRINT_OPTIONS: PrintOptions = { indentSize: 4, newLine: "\n" };

package/src/application/print/text-writer.ts

@@ -0,0 +1,83 @@
+import type { PrintOptions } from "./print-options.js";
+
+const LINE_FEED = 0x0a;
+const CARRIAGE_RETURN = 0x0d;
+const LINE_SEPARATOR = 0x2028;
+const PARAGRAPH_SEPARATOR = 0x2029;
+
+/** Line breaks as the TypeScript scanner defines them (`isLineBreak`). */
+export function isLineBreak(code: number): boolean {
+  return (
+    code === LINE_FEED ||
+    code === CARRIAGE_RETURN ||
+    code === LINE_SEPARATOR ||
+    code === PARAGRAPH_SEPARATOR
+  );
+}
+
+/**
+ * Output buffer with indentation, modeled on the TypeScript printer's text writer: `write` indents
+ * text that starts a line, `rawWrite` never does, and `writeLine` does nothing at the start of a
+ * line. Matching these rules is what makes comment re-indentation byte-identical to the original.
+ */
+export class TextWriter {
+  readonly #options: PrintOptions;
+  #output = "";
+  #indent = 0;
+  #isAtLineStart = true;
+
+  constructor(options: PrintOptions) {
+    this.#options = options;
+  }
+
+  get indent(): number {
+    return this.#indent;
+  }
+
+  get options(): PrintOptions {
+    return this.#options;
+  }
+
+  get text(): string {
+    return this.#output;
+  }
+
+  increaseIndent(): void {
+    this.#indent++;
+  }
+
+  decreaseIndent(): void {
+    this.#indent--;
+  }
+
+  /** Write text, indenting it first when it starts a line. */
+  write(text: string): void {
+    if (text.length === 0) {
+      return;
+    }
+    const prefix = this.#isAtLineStart ? this.indentString(this.#indent) : "";
+    this.rawWrite(prefix + text);
+  }
+
+  /** Write text exactly as given. */
+  rawWrite(text: string): void {
+    this.#output += text;
+    this.#updateLineStart(text);
+  }
+
+  /** End the current line; does nothing when nothing has been written on it yet. */
+  writeLine(): void {
+    if (!this.#isAtLineStart) {
+      this.rawWrite(this.#options.newLine);
+    }
+  }
+
+  indentString(level: number): string {
+    return " ".repeat(level * this.#options.indentSize);
+  }
+
+  // Like TypeScript: any write leaves the writer mid-line unless the text ends with a line break.
+  #updateLineStart(text: string): void {
+    this.#isAtLineStart = text.length > 0 && isLineBreak(text.charCodeAt(text.length - 1));
+  }
+}

package/src/application/print/type-printer.ts

@@ -0,0 +1,281 @@
+import { assertNever } from "../../domain/assert-never.js";
+import type {
+  IrIndexedAccessType,
+  IrMember,
+  IrPropertyName,
+  IrRawType,
+  IrTupleElement,
+  IrType,
+} from "../../domain/ir/nodes.js";
+import { writeLeadingComment } from "./comment-writer.js";
+import { printEscapedString, printNumberLiteral, printStringLiteral } from "./literal-text.js";
+import type { TextWriter } from "./text-writer.js";
+
+/**
+ * Parenthesization contexts. Each predicate says when a child type needs parentheses; together they
+ * reproduce the TypeScript factory's parenthesizer rules for the node kinds of the IR, so output
+ * matches the original even when unions are nested (`A | (B | C)`).
+ */
+const isUnionOrIntersection = (type: IrType): boolean =>
+  type.kind === "union" || type.kind === "intersection";
+/** Union and intersection members (`parenthesizeConstituentTypeOf{Union,Intersection}Type`). */
+const needsParensAsConstituent = isUnionOrIntersection;
+/** Array element and indexed-access object (`parenthesizeNonArrayTypeOfPostfixType`). */
+const needsParensAsPostfixOperand = (type: IrType): boolean =>
+  type.kind === "readonly" || isUnionOrIntersection(type);
+/** Operand of `readonly` (`parenthesizeOperandOfReadonlyTypeOperator`). */
+const needsParensAsReadonlyOperand = needsParensAsPostfixOperand;
+
+function writeTypeIn(
+  writer: TextWriter,
+  type: IrType,
+  needsParens: (type: IrType) => boolean,
+): void {
+  if (!needsParens(type)) {
+    writeType(writer, type);
+    return;
+  }
+  writer.write("(");
+  writeType(writer, type);
+  writer.write(")");
+}
+
+/** Write a single-line list: `separator` between items, nothing for an empty list. */
+function writeInlineList<T>(
+  writer: TextWriter,
+  items: readonly T[],
+  separator: string,
+  writeItem: (item: T) => void,
+) {
+  items.forEach((item, index) => {
+    if (index > 0) {
+      writer.write(separator);
+    }
+    writeItem(item);
+  });
+}
+
+/**
+ * Write a multi-line list the way the TypeScript printer does: a line break after the opening
+ * token, one item per indented line, `delimiter` after every item but the last, and a line break
+ * before the closing token. An empty list prints the line break only when `isLineBreakWhenEmpty`
+ * (interfaces, enums and tuples do; object type literals print `{}`).
+ */
+export function writeMultiLineList<T>(
+  writer: TextWriter,
+  items: readonly T[],
+  format: { readonly delimiter: string; readonly isLineBreakWhenEmpty: boolean },
+  writeItem: (item: T) => void,
+): void {
+  if (items.length === 0) {
+    if (format.isLineBreakWhenEmpty) {
+      writer.writeLine();
+    }
+    return;
+  }
+  writer.writeLine();
+  writer.increaseIndent();
+  items.forEach((item, index) => {
+    if (index > 0) {
+      writer.write(format.delimiter);
+      writer.writeLine();
+    }
+    writeItem(item);
+  });
+  writer.decreaseIndent();
+  writer.writeLine();
+}
+
+function writePropertyName(writer: TextWriter, name: IrPropertyName): void {
+  switch (name.kind) {
+    case "identifier":
+    case "number":
+      writer.write(name.text);
+      break;
+    case "string":
+      writer.write(printEscapedString(name.value));
+      break;
+    default:
+      assertNever(name);
+  }
+}
+
+/**
+ * `[name: type]`. TypeScript prints index signature parameters as an indented list, so a multi-line
+ * parameter type (an object or tuple) is indented one level deeper than the member.
+ */
+function writeIndexSignatureParameter(writer: TextWriter, name: string, type: IrType): void {
+  writer.write(`[${name}: `);
+  writer.increaseIndent();
+  writeType(writer, type);
+  writer.decreaseIndent();
+  writer.write("]");
+}
+
+/** Write one member of an interface or object type, with its comment and trailing semicolon. */
+export function writeMember(writer: TextWriter, member: IrMember): void {
+  for (const comment of member.comments) {
+    writeLeadingComment(writer, comment);
+  }
+  if (member.isReadonly) {
+    writer.write("readonly ");
+  }
+  if (member.kind === "property") {
+    writePropertyName(writer, member.name);
+    writer.write(member.isOptional ? "?: " : ": ");
+  } else {
+    writeIndexSignatureParameter(writer, member.parameterName, member.parameterType);
+    writer.write(": ");
+  }
+  writeType(writer, member.type);
+  writer.write(";");
+}
+
+function writeTupleElement(writer: TextWriter, element: IrTupleElement): void {
+  if (element.isRest) {
+    writer.write("...");
+  }
+  writeType(writer, element.type);
+}
+
+function writeObjectType(writer: TextWriter, members: readonly IrMember[]): void {
+  writer.write("{");
+  writeMultiLineList(writer, members, { delimiter: "", isLineBreakWhenEmpty: false }, (member) =>
+    writeMember(writer, member),
+  );
+  writer.write("}");
+}
+
+function writeTupleType(writer: TextWriter, elements: readonly IrTupleElement[]): void {
+  writer.write("[");
+  writeMultiLineList(writer, elements, { delimiter: ",", isLineBreakWhenEmpty: true }, (element) =>
+    writeTupleElement(writer, element),
+  );
+  writer.write("]");
+}
+
+function writeReferenceType(
+  writer: TextWriter,
+  name: string,
+  typeArguments: readonly IrType[],
+): void {
+  writer.write(name);
+  if (typeArguments.length > 0) {
+    writer.write("<");
+    writeInlineList(writer, typeArguments, ", ", (argument) => writeType(writer, argument));
+    writer.write(">");
+  }
+}
+
+function writeIndexedAccessType(writer: TextWriter, type: IrIndexedAccessType): void {
+  writeTypeIn(writer, type.object, needsParensAsPostfixOperand);
+  writer.write("[");
+  writeType(writer, type.index);
+  writer.write("]");
+}
+
+function writeConstituents(writer: TextWriter, types: readonly IrType[], separator: string): void {
+  writeInlineList(writer, types, separator, (member) =>
+    writeTypeIn(writer, member, needsParensAsConstituent),
+  );
+}
+
+type IrLeafType = Extract<
+  IrType,
+  { kind: "keyword" | "stringLiteral" | "numberLiteral" | "booleanLiteral" }
+>;
+
+function printLeafType(type: IrLeafType): string {
+  switch (type.kind) {
+    case "keyword":
+      return type.keyword;
+    case "stringLiteral":
+      return printStringLiteral(type.value, type.encoding);
+    case "numberLiteral":
+      return printNumberLiteral(type.value);
+    case "booleanLiteral":
+      return String(type.value);
+    default:
+      return assertNever(type);
+  }
+}
+
+/**
+ * Raw text is printed as if it started at column 0, so its continuation lines get the current
+ * indentation, as the TypeScript printer indents a nested node.
+ */
+function writeRawType(writer: TextWriter, text: string): void {
+  text.split("\n").forEach((line, index) => {
+    if (index > 0) {
+      writer.rawWrite(writer.options.newLine);
+    }
+    writer.write(line);
+  });
+}
+
+function writeArrayType(writer: TextWriter, element: IrType): void {
+  writeTypeIn(writer, element, needsParensAsPostfixOperand);
+  writer.write("[]");
+}
+
+function writeReadonlyType(writer: TextWriter, operand: IrType): void {
+  writer.write("readonly ");
+  writeTypeIn(writer, operand, needsParensAsReadonlyOperand);
+}
+
+type IrOperatorType = Extract<IrType, { kind: "array" | "indexedAccess" | "readonly" }>;
+
+/** Types built with a type operator: `T[]`, `T[K]` and `readonly T`. */
+function writeOperatorType(writer: TextWriter, type: IrOperatorType): void {
+  if (type.kind === "array") {
+    writeArrayType(writer, type.element);
+  } else if (type.kind === "indexedAccess") {
+    writeIndexedAccessType(writer, type);
+  } else {
+    writeReadonlyType(writer, type.type);
+  }
+}
+
+const CONSTITUENT_SEPARATORS = { union: " | ", intersection: " & " } as const;
+
+/** A raw type may span lines and is re-indented; any other leaf prints on one line. */
+function writeLeafType(writer: TextWriter, type: IrLeafType | IrRawType): void {
+  if (type.kind === "raw") {
+    writeRawType(writer, type.text);
+  } else {
+    writer.write(printLeafType(type));
+  }
+}
+
+/** Write a type at the writer's current position. */
+export function writeType(writer: TextWriter, type: IrType): void {
+  switch (type.kind) {
+    case "keyword":
+    case "stringLiteral":
+    case "numberLiteral":
+    case "booleanLiteral":
+    case "raw":
+      writeLeafType(writer, type);
+      break;
+    case "reference":
+      writeReferenceType(writer, type.name, type.typeArguments);
+      break;
+    case "array":
+    case "indexedAccess":
+    case "readonly":
+      writeOperatorType(writer, type);
+      break;
+    case "union":
+    case "intersection":
+      writeConstituents(writer, type.types, CONSTITUENT_SEPARATORS[type.kind]);
+      break;
+    case "object":
+      writeObjectType(writer, type.members);
+      break;
+    case "tuple":
+      writeTupleType(writer, type.elements);
+      break;
+    default:
+      assertNever(type);
+  }
+}

package/src/application/stack-overflow.ts

@@ -0,0 +1,54 @@
+import { ERROR_CODES, OpenAPITypesafeError } from "../domain/errors.js";
+
+/**
+ * Deeply nested schemas (ENGINEERING_PLAN 8.5). Loading, bundling, transforming and printing walk
+ * schemas recursively, and Redocly follows each `$ref` inside the walk. On the default Node.js
+ * stack, about 550 levels of inline schemas or a chain of about 900 `$ref`s (each schema refers to
+ * the next) run out of call stack. Real documents stay far below: every YAML or JSON file goes
+ * through the YAML parser, which stops at 100 levels, and the whole corpus passes. The overflow is
+ * reported as a typed error instead of a `RangeError` with a stack trace.
+ */
+
+/** The step that ran out of call stack; named in the message and the details. */
+export type DeepSchemaStep = "load" | "transform" | "print";
+
+/** V8 and JavaScriptCore (Node.js, Deno, Bun) throw a `RangeError` with this message. */
+const STACK_OVERFLOW_MESSAGE = /maximum call stack size exceeded/i;
+
+/** Whether a thrown value is a call stack overflow. */
+export function isStackOverflowError(error: unknown): boolean {
+  return error instanceof RangeError && STACK_OVERFLOW_MESSAGE.test(error.message);
+}
+
+/** The typed error for a document nested too deeply for the call stack. */
+export function schemaTooDeepError(step: DeepSchemaStep, cause: unknown): OpenAPITypesafeError {
+  return new OpenAPITypesafeError({
+    code: ERROR_CODES.SCHEMA_TOO_DEEP,
+    message:
+      `The schema is nested too deeply to ${step}: the call stack ran out. Both inline ` +
+      "schemas and chains of $ref (each schema referring to the next) count; shorten the deepest.",
+    details: { step },
+    cause,
+  });
+}
+
+/** Run a step and report a stack overflow in it as SCHEMA_TOO_DEEP; other errors pass through. */
+export function withStackOverflowReported<T>(step: DeepSchemaStep, run: () => T): T {
+  try {
+    return run();
+  } catch (error) {
+    throw isStackOverflowError(error) ? schemaTooDeepError(step, error) : error;
+  }
+}
+
+/** The asynchronous form of `withStackOverflowReported`. */
+export async function withStackOverflowReportedAsync<T>(
+  step: DeepSchemaStep,
+  run: () => Promise<T>,
+): Promise<T> {
+  try {
+    return await run();
+  } catch (error) {
+    throw isStackOverflowError(error) ? schemaTooDeepError(step, error) : error;
+  }
+}

package/src/application/transform/document/components.ts

@@ -0,0 +1,189 @@
+import { irKeyword, irObject, irProperty } from "../../../domain/ir/constructors.js";
+import {
+  hasIdentifierStart,
+  isReservedTypeName,
+  withIdentifierParts,
+} from "../../../domain/ir/identifier-text.js";
+import type {
+  IrPropertySignature,
+  IrType,
+  IrTypeAliasDeclaration,
+} from "../../../domain/ir/nodes.js";
+import { toPropertyName } from "../../../domain/ir/property-name.js";
+import {
+  COMPONENT_KINDS,
+  type ComponentKind,
+  type ComponentsObject,
+  DECLARED_COMPONENT_KINDS,
+  isEnumSchema,
+  singularizeComponentKind,
+} from "../../../domain/openapi/components-object.js";
+import { createRef } from "../../../domain/openapi/json-pointer.js";
+import { OutputFix } from "../../../domain/output-fixes.js";
+import { type DeprecatedEntryFilter, documentEntries } from "../document-entries.js";
+import type { SchemaLocation } from "../schema/schema-context.js";
+import { transformSchema } from "../schema/schema-transform.js";
+import { withSchemaComment } from "../schema-comment.js";
+import type { TransformContext } from "../transform-context.js";
+import { headerType } from "./header.js";
+import { contentEntryType } from "./media-type.js";
+import { parameterType } from "./parameter.js";
+import { pathItemType } from "./path-item.js";
+import { requestBodyType } from "./request-body.js";
+import { responseType } from "./response.js";
+import { numberDisplacedAliases, rootTypeAlias } from "./root-type-aliases.js";
+
+type ComponentTransform = (
+  item: never,
+  location: SchemaLocation,
+  context: TransformContext,
+) => IrType;
+
+const COMPONENT_TRANSFORMS: Readonly<Record<ComponentKind, ComponentTransform>> = {
+  schemas: transformSchema,
+  responses: responseType,
+  parameters: parameterType,
+  requestBodies: requestBodyType,
+  headers: headerType,
+  pathItems: pathItemType,
+  mediaTypes: contentEntryType,
+};
+
+/** The `components` type and the `--root-types` aliases. */
+export interface ComponentsResult {
+  readonly type: IrType;
+  readonly rootTypes: readonly IrTypeAliasDeclaration[];
+}
+
+/** One component; the `transform` callback may replace its type, as for nested schemas. */
+function componentMember(
+  kind: ComponentKind,
+  name: string,
+  item: unknown,
+  context: TransformContext,
+): IrPropertySignature {
+  const location = { path: createRef(["components", kind, name]), schema: item };
+  const type = COMPONENT_TRANSFORMS[kind](item as never, location, context);
+  const custom = context.callbacks.transform(item, location);
+  const property = irProperty(toPropertyName(name), custom?.type ?? type, {
+    isOptional: custom?.isOptional ?? false,
+    isReadonly: context.options.immutable,
+  });
+  return withSchemaComment(property, item);
+}
+
+/**
+ * The root alias name: `SchemaPet`, `ResponseNotFound`, … A taken name gets `_2`, `_3`, … The
+ * original checks for conflicts before it removes the schema prefix, and so does this; for a clash
+ * of exported names see `addRootAlias`.
+ *
+ * The original could build a name that is no identifier, so the generated file did not parse
+ * (research/legacy-bugs.md, item 16): a kept casing keeps spaces and symbols, which become `_`;
+ * and a name without the prefix can start with a digit, so it keeps the prefix (`Schema1`). A
+ * kept casing without the prefix can also give a reserved name (`void`, `class`), which keeps the
+ * prefix too (`Schemavoid`).
+ */
+function rootTypeName(
+  kind: ComponentKind,
+  name: string,
+  aliases: Readonly<Record<string, IrTypeAliasDeclaration>>,
+  context: TransformContext,
+): string {
+  const { options, casing } = context;
+  const prefix = casing.pascalCase(singularizeComponentKind(kind));
+  const isSchema = kind === "schemas";
+  const base = withIdentifierParts(
+    options.rootTypesKeepCasing && isSchema ? name : casing.pascalCase(name),
+  );
+  const exportedName = (alias: string): string => {
+    const unprefixed = alias.replace(prefix, "");
+    const isUnprefixed = options.rootTypesNoSchemaPrefix && isSchema;
+    const isTypeName = hasIdentifierStart(unprefixed) && !isReservedTypeName(unprefixed);
+    return isUnprefixed && isTypeName ? unprefixed : alias;
+  };
+  let alias = `${prefix}${base}`;
+  for (let counter = 2; aliases[alias] !== undefined; counter++) {
+    alias = `${prefix}${base}_${counter}`;
+  }
+  return exportedName(alias);
+}
+
+/**
+ * Add a root alias. When its exported name is taken (two schemas of one PascalCase name without
+ * the prefix), the later schema takes the name, as in the original. Without the
+ * `root-type-numbering` fix the earlier one then has no alias: that output is valid, so a number
+ * for it would change it (backlog 30). With the fix the earlier alias is kept aside and numbered
+ * at the end.
+ */
+function addRootAlias(request: ComponentsRequest, alias: IrTypeAliasDeclaration): void {
+  const { aliases, displaced } = request;
+  const previous = aliases[alias.name];
+  if (previous !== undefined && displaced !== null) {
+    displaced.push(previous);
+  }
+  aliases[alias.name] = alias;
+}
+
+/** `--root-types` skips enum schemas under `--enum`: the enum itself is exported. */
+function hasRootType(kind: ComponentKind, item: unknown, context: TransformContext): boolean {
+  const { options } = context;
+  return options.rootTypes && !(options.enum && kind === "schemas" && isEnumSchema(item));
+}
+
+/** The components of one run, and the deprecated ones that kept output still references. */
+interface ComponentsRequest {
+  readonly components: ComponentsObject;
+  readonly isKept: DeprecatedEntryFilter;
+  readonly aliases: Record<string, IrTypeAliasDeclaration>;
+  /** With the `root-type-numbering` fix: the aliases a later schema took the name of, in order. */
+  readonly displaced: IrTypeAliasDeclaration[] | null;
+}
+
+function kindMember(
+  kind: ComponentKind,
+  request: ComponentsRequest,
+  context: TransformContext,
+): IrPropertySignature {
+  const { components, isKept, aliases } = request;
+  const startedAt = context.diagnostics.now();
+  const items: IrPropertySignature[] = [];
+  for (const [name, item] of documentEntries(components[kind] ?? {}, context.options, isKept)) {
+    items.push(componentMember(kind, name, item, context));
+    if (hasRootType(kind, item, context)) {
+      addRootAlias(request, rootTypeAlias(rootTypeName(kind, name, aliases, context), kind, name));
+    }
+  }
+  const type = items.length > 0 ? irObject(items) : irKeyword("never");
+  context.diagnostics.debug(
+    `Transformed components → ${kind}`,
+    context.diagnostics.now() - startedAt,
+  );
+  return irProperty(toPropertyName(kind), type);
+}
+
+/**
+ * The `components` interface body (OpenAPI 3.1 §4.8.7), one member per component kind. With
+ * `--exclude-deprecated`, `kept` holds the deprecated components that kept output references
+ * (`keptDeprecatedComponents`); they stay, so no reference names a missing key.
+ */
+export function componentsType(
+  components: ComponentsObject,
+  context: TransformContext,
+  kept: ReadonlySet<object> = new Set(),
+): ComponentsResult {
+  // A plain object, as in the original: its key order (integer-like names first) is the
+  // output order.
+  const aliases: Record<string, IrTypeAliasDeclaration> = {};
+  const displaced = context.options.fixes.has(OutputFix.ROOT_TYPE_NUMBERING) ? [] : null;
+  const isKept = (item: unknown) => kept.has(item as object);
+  const request = { components, isKept, aliases, displaced };
+  const declaredKinds = DECLARED_COMPONENT_KINDS.filter((kind) => components[kind] !== undefined);
+  const members = [...COMPONENT_KINDS, ...declaredKinds].map((kind) =>
+    kindMember(kind, request, context),
+  );
+  const rootTypes = Object.values(aliases);
+  return {
+    type: irObject(members),
+    rootTypes: [...rootTypes, ...numberDisplacedAliases(displaced ?? [], rootTypes)],
+  };
+}