openapi-typesafe 1.0.0-rc.1 → 1.0.0-rc.2

package/src/api/document-run.ts

@@ -11,11 +11,14 @@ import {
   outputFixNamesOf,
   resolveOutputFixes,
 } from "../domain/output-fixes.js";
-import type { GeneratorOptions, GlobalContext, OpenAPI3, SchemaSource } from "../types.js";
+import { WARNING_CODES, warningText } from "../domain/warnings.js";
+import type { GeneratorOptions, OpenAPI3, SchemaSource } from "../types.js";
+import { processCwd } from "./default-ports.js";
 import { warnDiscriminatorValueConflicts } from "./discriminator-conflict-warnings.js";
 import { findDiscriminators } from "./discriminator-scan.js";
 import { resolveDocumentRef } from "./document-refs.js";
 import { warnIdenticalPathTemplates } from "./path-template-warnings.js";
+import type { RunContext } from "./run-context.js";
 import { warnUnsupportedFeatures } from "./unsupported-feature-warnings.js";
 
 /** The ports of one generator run, wired by the Node API or the CLI (ENGINEERING_PLAN 4.5). */
@@ -31,12 +34,12 @@ export interface GeneratorPorts {
 /** A validated, bundled document and the context of one generator run. */
 export interface DocumentRun {
   readonly schema: OpenAPI3;
-  readonly ctx: GlobalContext;
+  readonly ctx: RunContext;
 }
 
 /** The context fields that are user flags, with the original defaults. */
 type ContextFlags = Omit<
-  GlobalContext,
+  RunContext,
   | "discriminators"
   | "injectFooter"
   | "redoc"
@@ -56,7 +59,7 @@ function sourceCwd(options: GeneratorOptions): URL {
   if (cwd instanceof URL) {
     return cwd.pathname.endsWith("/") ? cwd : new URL(`${cwd.pathname}/`, cwd);
   }
-  const directory = path.resolve(cwd === undefined ? process.cwd() : cwd.toString());
+  const directory = path.resolve(cwd === undefined ? processCwd() : cwd.toString());
   return pathToFileURL(path.join(directory, path.sep));
 }
 
@@ -119,7 +122,7 @@ function contextFlags(options: GeneratorOptions): ContextFlags {
 function outputFixesOf(options: GeneratorOptions, logger: Logger): readonly OutputFix[] {
   const names = outputFixNamesOf(options.fix ?? []);
   for (const notice of ineffectiveFixNotices(names, (option) => options[option] === true)) {
-    logger.warn(notice);
+    logger.warn(warningText(notice, WARNING_CODES.FIX_NEEDS_OPTION));
   }
   return [...resolveOutputFixes(names)];
 }
@@ -156,7 +159,7 @@ export async function createDocumentRun(
     refAccess: refAccessOf(options, cwd),
   });
   warnAboutDocument(schema, fix, logger);
-  const ctx: GlobalContext = {
+  const ctx: RunContext = {
     ...contextFlags(options),
     fix,
     // The scan walks every schema before the transform does, so on a larger stack, where loading

package/src/api/footer-sink.ts

@@ -4,6 +4,7 @@ import type { FooterSink } from "../application/transform/footer/document-footer
 import type {
   IrDeclaration,
   IrInterfaceDeclaration,
+  IrMember,
   IrPropertySignature,
 } from "../domain/ir/nodes.js";
 import { declaresTypeAlias, type FooterEntry, isIrDeclaration } from "./footer-entry.js";
@@ -16,6 +17,12 @@ const OPERATIONS_NAME = "operations";
  */
 export class ContextFooterSink implements FooterSink {
   private readonly footer: FooterEntry[];
+  /**
+   * The IR `operations` entry this sink wrote last, with its members array that only this sink
+   * holds. Adding to it in place keeps a run linear: copying the members on every operation was
+   * quadratic (about 0.4 s on Microsoft Graph beta).
+   */
+  private owned: OwnedOperations | null = null;
 
   constructor(footer: FooterEntry[]) {
     this.footer = footer;
@@ -35,6 +42,11 @@ export class ContextFooterSink implements FooterSink {
    * the member in place, as in the original.
    */
   addOperation(build: () => IrPropertySignature): void {
+    const owned = this.currentOwnedOperations();
+    if (owned !== null) {
+      owned.members.push(build());
+      return;
+    }
     const existing = this.findOperations();
     if (existing !== null && !isIrDeclaration(existing.entry)) {
       const ts = loadTypeScript();
@@ -45,9 +57,23 @@ export class ContextFooterSink implements FooterSink {
       return;
     }
     const index = existing?.index ?? this.footer.push(emptyOperations()) - 1;
-    const member = build();
+    this.takeOwnership(index).members.push(build());
+  }
+
+  /** The owned entry, unless user code replaced or moved it in the footer since. */
+  private currentOwnedOperations(): OwnedOperations | null {
+    const owned = this.owned;
+    return owned !== null && this.footer[owned.index] === owned.entry ? owned : null;
+  }
+
+  /** Replace the IR entry at `index` with a copy whose members array only this sink holds. */
+  private takeOwnership(index: number): OwnedOperations {
     const operations = this.footer[index] as IrInterfaceDeclaration;
-    this.footer[index] = { ...operations, members: [...operations.members, member] };
+    const members: IrMember[] = [...operations.members];
+    const entry: IrInterfaceDeclaration = { ...operations, members };
+    this.footer[index] = entry;
+    this.owned = { entry, members, index };
+    return this.owned;
   }
 
   /** The first `operations` interface: the generator's (IR) or a user's (TypeScript). */
@@ -62,6 +88,12 @@ export class ContextFooterSink implements FooterSink {
   }
 }
 
+interface OwnedOperations {
+  readonly entry: IrInterfaceDeclaration;
+  readonly members: IrMember[];
+  readonly index: number;
+}
+
 function emptyOperations(): IrInterfaceDeclaration {
   return { kind: "interface", name: OPERATIONS_NAME, isExported: true, members: [], comments: [] };
 }

package/src/api/legacy-callback-warning.ts

@@ -1,5 +1,7 @@
-import type { GlobalContext, LegacyCallbackName } from "../types.js";
+import { WARNING_CODES, warningText } from "../domain/warnings.js";
+import type { LegacyCallbackName } from "../types.js";
 import { defaultLogger } from "./default-ports.js";
+import type { RunContext } from "./run-context.js";
 
 /** Where the IR callbacks are documented; the warning points users there. */
 export const IR_CALLBACKS_GUIDE_URL =
@@ -19,11 +21,13 @@ function message(name: LegacyCallbackName): string {
 }
 
 /** Warn once per run and callback; `silent` runs record the use but print nothing. */
-export function warnLegacyCallback(ctx: GlobalContext, name: LegacyCallbackName): void {
+export function warnLegacyCallback(ctx: RunContext, name: LegacyCallbackName): void {
   ctx.legacyCallbackWarnings ??= new Set();
   if (ctx.legacyCallbackWarnings.has(name)) {
     return;
   }
   ctx.legacyCallbackWarnings.add(name);
-  (ctx.logger ?? defaultLogger(ctx.silent)).warn(message(name));
+  (ctx.logger ?? defaultLogger(ctx.silent)).warn(
+    warningText(message(name), WARNING_CODES.LEGACY_CALLBACK_DEPRECATED),
+  );
 }

package/src/api/legacy-ts-helpers.ts

@@ -103,7 +103,7 @@ export function tsDedupe(types: TypeInput[]): ts.TypeNode[] {
 }
 
 /** @deprecated The generator keeps its own enum registry per run; kept for 1.x (ADR-004). */
-export const enumCache = new Map<string, ts.EnumDeclaration>();
+export const enumCache: Map<string, ts.EnumDeclaration> = new Map();
 
 /**
  * Create a TS enum (with sanitized name and members)
@@ -114,7 +114,7 @@ export function tsEnum(
   members: (string | number)[],
   metadata?: { name?: string; description?: string | null }[],
   options?: { export?: boolean; shouldCache?: boolean },
-) {
+): ts.EnumDeclaration {
   const ts = loadTypeScript();
   let enumName = sanitizeMemberName(name);
   enumName = `${enumName.charAt(0).toUpperCase()}${enumName.substring(1)}`;
@@ -149,7 +149,7 @@ export function tsArrayLiteralExpression(
   elementType: TypeInput,
   values: (string | number)[],
   options?: { export?: boolean; readonly?: boolean; injectFooter?: FooterEntry[] },
-) {
+): ts.VariableStatement {
   const ts = loadTypeScript();
   let variableName = sanitizeMemberName(name);
   variableName = `${variableName.charAt(0).toLowerCase()}${variableName.substring(1)}`;
@@ -223,7 +223,7 @@ function enumMemberName(value: string | number, explicitName: string | undefined
 export function tsEnumMember(
   value: string | number,
   metadata: { name?: string; description?: string | null } = {},
-) {
+): ts.EnumMember {
   const ts = loadTypeScript();
   const name = enumMemberName(value, metadata.name);
   const member = ts.factory.createEnumMember(name, toValueExpression(ts, value));
@@ -281,7 +281,9 @@ export function tsModifiers(modifiers: { readonly?: boolean; export?: boolean })
  * Create a valid property index
  * @deprecated Kept for 1.x; removed in 2.0 (ADR-004, decision 9).
  */
-export function tsPropertyIndex(index: string | number) {
+export function tsPropertyIndex(
+  index: string | number,
+): ts.Identifier | ts.NumericLiteral | ts.StringLiteral {
   const ts = loadTypeScript();
   if (
     (typeof index === "number" && !(index < 0)) ||

package/src/api/legacy-utils.ts

@@ -90,7 +90,7 @@ export type { ResolveRefOptions } from "./document-refs.js";
  * @deprecated Kept for 1.x; removed in 2.0 (ADR-004, decision 9).
  */
 export function resolveRef<T>(
-  schema: any,
+  schema: unknown,
   $ref: string,
   options: ResolveRefOptions,
 ): T | undefined {

package/src/api/openapi-ts.ts

@@ -3,6 +3,7 @@ import { withStackOverflowReported } from "../application/stack-overflow.js";
 import type { IrDeclaration } from "../domain/ir/nodes.js";
 import type { GeneratorOptions, SchemaSource } from "../types.js";
 import {
+  DEFAULT_REMOTE_DOCUMENT_LIMITS,
   defaultLogger,
   defaultRedoclyConfig,
   monotonicNow,
@@ -42,6 +43,7 @@ export async function defaultGeneratorPorts(options: GeneratorOptions): Promise<
     logger,
     now: monotonicNow,
     remoteRefTimeoutMs: REMOTE_REF_TIMEOUT_MS,
+    remoteDocumentLimits: DEFAULT_REMOTE_DOCUMENT_LIMITS,
   });
   return { loader, logger, redoc, now: monotonicNow };
 }

package/src/api/run-context.ts

@@ -0,0 +1,34 @@
+import type { Logger } from "../application/ports/logger.js";
+import type { DocumentFooter } from "../application/transform/transform-context.js";
+import type { GlobalContext, LegacyCallbackName, SchemaObject } from "../types.js";
+
+/**
+ * The context the generator builds for a run: the public `GlobalContext` plus the run's own
+ * state. The state is not part of the public type, so it can change in a minor release; every
+ * field is optional, so a context a user builds by hand is a valid `RunContext` without it.
+ * Callbacks receive this object as `options.ctx` and may spread it; the state travels with it.
+ */
+export interface RunContext extends GlobalContext {
+  readonly discriminators: GlobalContext["discriminators"] & {
+    /**
+     * With the `discriminator-values` fix: for each enum the scan added to a member and each
+     * inherited discriminator object, the enum of the owner's property and the location it is
+     * typed at.
+     */
+    readonly enumParents?: ReadonlyMap<
+      object,
+      { readonly schema: SchemaObject; readonly path: string }
+    >;
+    /**
+     * With the `discriminator-values` fix: for each schema, the properties of the discriminators
+     * it inherits besides `objects[ref]`, which it redefines too.
+     */
+    readonly otherProperties?: Readonly<Record<string, readonly string[]>>;
+  };
+  /** Footer state of this run (enum registry and enum naming), created on first use. */
+  runFooter?: DocumentFooter;
+  /** The deprecated callback forms this run has warned about (once each). */
+  legacyCallbackWarnings?: Set<LegacyCallbackName>;
+  /** Where this run reports warnings and debug output; without it, the terminal. */
+  logger?: Logger;
+}

package/src/api/transform-context.ts

@@ -11,22 +11,24 @@ import type {
   TransformDiagnostics,
   TransformOptions,
 } from "../application/transform/transform-context.js";
-import type { GlobalContext, TransformNodeOptions } from "../types.js";
+import type { TransformNodeOptions } from "../types.js";
 import { defaultLogger, monotonicNow } from "./default-ports.js";
 import { ContextFooterSink } from "./footer-sink.js";
+import type { RunContext } from "./run-context.js";
 import { schemaCallbacks } from "./schema-callbacks.js";
 
 /**
- * Builds the ported transformers' context from the original `GlobalContext`: options, refs,
- * discriminators, the run footer and the user callbacks (see `schema-callbacks.ts`).
+ * Builds the ported transformers' context from the original `GlobalContext` (in a run, a
+ * `RunContext`): options, refs, discriminators, the run footer and the user callbacks (see
+ * `schema-callbacks.ts`).
  */
 
-function transformOptions(ctx: GlobalContext): TransformOptions {
+function transformOptions(ctx: RunContext): TransformOptions {
   return {
     additionalProperties: ctx.additionalProperties,
     alphabetize: ctx.alphabetize,
     arrayLength: ctx.arrayLength,
-    binaryAsBlob: ctx.binaryAsBlob,
+    binaryAsBlob: ctx.binaryAsBlob ?? false,
     conditionalEnums: ctx.conditionalEnums,
     dedupeEnums: ctx.dedupeEnums,
     defaultNonNullable: ctx.defaultNonNullable,
@@ -50,7 +52,7 @@ function transformOptions(ctx: GlobalContext): TransformOptions {
 }
 
 /** One footer per run: it holds the enum registry, so it lives on the run's context. */
-function runFooter(ctx: GlobalContext): DocumentFooter {
+function runFooter(ctx: RunContext): DocumentFooter {
   ctx.runFooter ??= new RunFooter(new ContextFooterSink(ctx.injectFooter), ctx.dedupeEnums);
   return ctx.runFooter;
 }
@@ -60,7 +62,7 @@ const CASING: NameCasing = { pascalCase: (text) => changeCase.pascalCase(text) }
 /**
  * A monotonic clock and the run's logger (the default one for a user's own context), "ts" group.
  */
-function diagnostics(ctx: GlobalContext): TransformDiagnostics {
+function diagnostics(ctx: RunContext): TransformDiagnostics {
   const logger = ctx.logger ?? defaultLogger(ctx.silent);
   return {
     now: monotonicNow,
@@ -69,7 +71,7 @@ function diagnostics(ctx: GlobalContext): TransformDiagnostics {
 }
 
 /** The ported transformers' context for one call from a legacy transformer. */
-export function createTransformContext(ctx: GlobalContext): TransformContext {
+export function createTransformContext(ctx: RunContext): TransformContext {
   return {
     options: transformOptions(ctx),
     refs: { resolve: (ref) => ctx.resolve(ref) },

package/src/api/transform-schema.ts

@@ -16,6 +16,7 @@ import { documentDeclarations, type TransformedDocument } from "./document-decla
 import { excludedValuesWarning } from "./enum-values-warnings.js";
 import { type FooterEntry, isIrDeclaration } from "./footer-entry.js";
 import { ContextFooterSink } from "./footer-sink.js";
+import type { RunContext } from "./run-context.js";
 import { createTransformContext } from "./transform-context.js";
 
 const OPERATIONS_NAME = "operations";
@@ -46,11 +47,11 @@ interface EnumNameRecorder extends SharedEnumNames {
  */
 function sharedEnumNamesOf(
   document: DocumentObject,
-  ctx: GlobalContext,
+  ctx: RunContext,
   recorder: EnumNameRecorder,
 ): SharedEnumNames {
   const injectFooter: FooterEntry[] = [];
-  const scratch: GlobalContext = {
+  const scratch: RunContext = {
     ...ctx,
     injectFooter,
     runFooter: new RunFooter(new ContextFooterSink(injectFooter), true, recorder),
@@ -71,7 +72,7 @@ function enumNameRecorderOf(ctx: GlobalContext): EnumNameRecorder | null {
 }
 
 /** With a naming fix, `--enum` and `--dedupe-enums`, the run's footer names shared enums. */
-function withSharedEnumNames(document: DocumentObject, ctx: GlobalContext): void {
+function withSharedEnumNames(document: DocumentObject, ctx: RunContext): void {
   const recorder = ctx.runFooter === undefined ? enumNameRecorderOf(ctx) : null;
   if (recorder === null || !ctx.enum || !ctx.dedupeEnums) {
     return;
@@ -87,7 +88,7 @@ function withSharedEnumNames(document: DocumentObject, ctx: GlobalContext): void
 function enumValuesChecked(
   body: readonly IrDeclaration[],
   footer: FooterEntry[],
-  ctx: GlobalContext,
+  ctx: RunContext,
 ): FooterEntry[] {
   if (!ctx.enumValues) {
     return footer;
@@ -102,7 +103,7 @@ function enumValuesChecked(
 }
 
 /** @internal Root types, the footer, then the closing declarations (Phase 5, step 6). */
-export function transformDocument(schema: OpenAPI3, ctx: GlobalContext): TransformedDocument {
+export function transformDocument(schema: OpenAPI3, ctx: RunContext): TransformedDocument {
   const document = schema as DocumentObject;
   withSharedEnumNames(document, ctx);
   const context = createTransformContext(ctx);

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

@@ -1,4 +1,5 @@
 import { assertNever } from "../../domain/assert-never.js";
+import { DEFAULT_STRING_ENCODING } from "../../domain/ir/constructors.js";
 import type {
   IrIndexedAccessType,
   IrMember,
@@ -196,7 +197,7 @@ function printLeafType(type: IrLeafType): string {
     case "keyword":
       return type.keyword;
     case "stringLiteral":
-      return printStringLiteral(type.value, type.encoding);
+      return printStringLiteral(type.value, type.encoding ?? DEFAULT_STRING_ENCODING);
     case "numberLiteral":
       return printNumberLiteral(type.value);
     case "booleanLiteral":

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

@@ -24,7 +24,8 @@ import type { TransformContext } from "../transform-context.js";
 import { isExplodedQueryObject } from "./exploded-query.js";
 import { parameterType } from "./parameter.js";
 
-const PATH_TEMPLATE_RE = /\{([^}]+)\}/g;
+/** `[^{}]` keeps the scan linear: `[^}]` retried from every `{` of a long run of them. */
+const PATH_TEMPLATE_RE = /\{([^{}]+)\}/g;
 
 /** A parameter as written in the document, and the object its `$ref` points to. */
 interface ParameterEntry {

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

@@ -35,7 +35,8 @@ import {
 } from "./path-template-replace.js";
 import { assignabilityProof } from "./type-assignability.js";
 
-const PATH_PARAMETER_RE = /\{[^}]+\}/g;
+/** `[^{}]` keeps the scan linear: `[^}]` retried from every `{` of a long run of them. */
+const PATH_PARAMETER_RE = /\{[^{}]+\}/g;
 
 /** Placeholders by parameter schema type; anything else is a string placeholder. */
 const PLACEHOLDERS: ReadonlyMap<unknown, PathPlaceholder> = new Map([

package/src/application/transform/footer/evaluation.ts

@@ -23,6 +23,16 @@ export function unionType(types: readonly IrType[]): IrType {
   return types.length === 0 ? NEVER : { kind: "union", types };
 }
 
+export function intersectionType(types: readonly IrType[]): IrType {
+  return types.length === 1 ? (types[0] as IrType) : { kind: "intersection", types };
+}
+
+const NULLISH: ReadonlySet<string> = new Set(["null", "undefined"]);
+
+export function isNullish(type: IrType): boolean {
+  return type.kind === "keyword" && NULLISH.has(type.keyword);
+}
+
 export function propertyKey(name: IrPropertyName): string {
   return name.kind === "string" ? name.value : name.text;
 }

package/src/application/transform/footer/type-evaluation.ts

@@ -1,21 +1,16 @@
-import type { IrDeclaration, IrMember, IrType } from "../../../domain/ir/nodes.js";
+import type { IrDeclaration, IrType } from "../../../domain/ir/nodes.js";
 import {
   absorbed,
   type Evaluated,
   type Evaluation,
-  MISSING,
-  NEVER,
+  intersectionType,
+  isNullish,
   OPAQUE,
   propertyKey,
   unionType,
 } from "./evaluation.js";
-import {
-  declaredFirst,
-  extracted,
-  isNeverIntersection,
-  markerObject,
-  omitted,
-} from "./type-rules.js";
+import { indexType } from "./type-indexing.js";
+import { extracted, markerObject, omitted } from "./type-rules.js";
 
 /**
  * A small evaluator of the generated types, as TypeScript reads them, for the `--enum-values`
@@ -30,7 +25,6 @@ const MAX_EXPANSIONS = 200;
 const DEEP_PREFIX = "FlattenedDeepRequired<";
 /** How many members distributing an intersection may give; more is opaque. */
 const MAX_DISTRIBUTED = 64;
-const NULLISH: ReadonlySet<string> = new Set(["null", "undefined"]);
 
 export class TypeEvaluator {
   private readonly declared = new Map<string, IrType>();
@@ -168,127 +162,6 @@ export class TypeEvaluator {
 
   /** `value[index]` for a string literal, `string` or `number` index. */
   index(value: Evaluated, index: IrType): Evaluation {
-    const owner = this.expand(value);
-    if (owner.kind !== "type") {
-      return owner;
-    }
-    if (this.membersOf(owner).length > 1) {
-      return this.unionIndex(owner, index);
-    }
-    const { type } = owner;
-    switch (type.kind) {
-      case "object":
-        return this.memberType(owner, type.members, index);
-      case "intersection":
-        return this.partsIndex(owner, type.types, index);
-      case "union":
-        return this.unionIndex(owner, index);
-      case "array":
-        return isNumberIndex(index) ? this.flattened(owner, type.element) : builtInIndex(index);
-      case "keyword":
-        return type.keyword === "never" ? owner : builtInIndex(index);
-      default:
-        return builtInIndex(index);
-    }
-  }
-
-  private memberType(owner: Evaluated, members: readonly IrMember[], index: IrType): Evaluation {
-    const key = indexKey(index);
-    const property = members.find(
-      (member) => member.kind === "property" && key !== null && propertyKey(member.name) === key,
-    );
-    if (property !== undefined) {
-      return this.flattened(owner, property.type);
-    }
-    const signature = members.find((member) => member.kind === "indexSignature");
-    if (signature !== undefined) {
-      return this.flattened(owner, signature.type);
-    }
-    return key === null || isObjectBuiltIn(key) ? OPAQUE : MISSING;
-  }
-
-  private partsIndex(owner: Evaluated, parts: readonly IrType[], index: IrType): Evaluation {
-    if (isNeverIntersection(this, owner, parts)) {
-      return { ...owner, type: NEVER };
-    }
-    const found = parts.map((type) => this.index({ ...owner, type }, index));
-    if (found.some((part) => part.kind === "opaque")) {
-      return OPAQUE;
-    }
-    const read = parts.map((type, at) => ({ type, found: found[at] as Evaluation }));
-    const types = declaredFirst(this, owner, indexKey(index), read).flatMap((part) =>
-      part.kind === "type" ? [part.type] : [],
-    );
-    return types.length === 0 ? MISSING : { ...owner, type: intersectionType(types) };
+    return indexType(this, value, index);
   }
-
-  private unionIndex(owner: Evaluated, index: IrType): Evaluation {
-    const found = this.membersOf(owner).map((member) =>
-      member.kind === "type" ? this.index(member, index) : member,
-    );
-    if (found.some((member) => member.kind === "missing")) {
-      return MISSING;
-    }
-    if (found.some((member) => member.kind === "opaque")) {
-      return OPAQUE;
-    }
-    return { ...owner, type: unionType((found as Evaluated[]).map((member) => member.type)) };
-  }
-
-  /**
-   * A member read through `FlattenedDeepRequired`: a value that is only arrays (and `undefined` or
-   * `null`) is replaced by its elements, anything else loses `undefined` and `null`.
-   */
-  private flattened(owner: Evaluated, type: IrType): Evaluation {
-    const member: Evaluated = { ...owner, type };
-    if (!owner.deep) {
-      return this.expand(member);
-    }
-    const members = this.membersOf(member);
-    if (members.some((candidate) => candidate.kind !== "type")) {
-      return OPAQUE;
-    }
-    const present = (members as Evaluated[]).filter((candidate) => !isNullish(candidate.type));
-    const elements = present.map((candidate) => arrayElement(candidate.type));
-    if (present.length > 0 && elements.every((element) => element !== null)) {
-      return this.expand({ ...owner, type: unionType(elements as IrType[]) });
-    }
-    return { ...owner, type: unionType(present.map((candidate) => candidate.type)) };
-  }
-}
-
-function isNullish(type: IrType): boolean {
-  return type.kind === "keyword" && NULLISH.has(type.keyword);
-}
-
-/** The element of an expanded member; expanding already dropped `readonly`. */
-function arrayElement(type: IrType): IrType | null {
-  return type.kind === "array" ? type.element : null;
-}
-
-function intersectionType(types: readonly IrType[]): IrType {
-  return types.length === 1 ? (types[0] as IrType) : { kind: "intersection", types };
-}
-
-function indexKey(index: IrType): string | null {
-  if (index.kind === "stringLiteral") {
-    return index.value;
-  }
-  return index.kind === "numberLiteral" ? String(index.value) : null;
-}
-
-function isNumberIndex(index: IrType): boolean {
-  const key = indexKey(index);
-  return (index.kind === "keyword" && index.keyword === "number") || /^\d+$/.test(key ?? "");
-}
-
-function isObjectBuiltIn(key: string): boolean {
-  return key in {};
-}
-
-/** A key of a primitive or an array: a built-in member is opaque, any other key is missing. */
-function builtInIndex(index: IrType): Evaluation {
-  const key = indexKey(index);
-  const isBuiltIn = key === null || key in String.prototype || key in Array.prototype;
-  return isBuiltIn || key in Number.prototype ? OPAQUE : MISSING;
 }