@scriptc/compiler 0.0.34 → 0.0.36

package/dist/frontend/tsc-codes.js

@@ -0,0 +1,109 @@
+/** Compiler options adopted from the project during preflight. */
+export const ADOPTED_OPTIONS = [
+    "strict",
+    "noImplicitAny",
+    "strictNullChecks",
+    "strictFunctionTypes",
+    "strictBindCallApply",
+    "strictPropertyInitialization",
+    "strictBuiltinIteratorReturn",
+    "noImplicitThis",
+    "alwaysStrict",
+    "useUnknownInCatchVariables",
+    "noUncheckedIndexedAccess",
+    "exactOptionalPropertyTypes",
+    "noImplicitOverride",
+    "noPropertyAccessFromIndexSignature",
+    "noImplicitReturns",
+    "noFallthroughCasesInSwitch",
+    "noUnusedLocals",
+    "noUnusedParameters",
+    "allowUnusedLabels",
+    "allowUnreachableCode",
+    "skipLibCheck",
+    // Import-form interop knobs: they only change which import FORMS
+    // typecheck (default imports of CJS-shaped types) — the import fence
+    // rejects unsupported forms with SC-diagnostics either way, and a
+    // SC1012 "not supported yet" beats a raw TS1259 at the same site.
+    "esModuleInterop",
+    "allowSyntheticDefaultImports",
+];
+/* The JAVASCRIPT strictness stance (the JS-input design made real):
+ * JavaScript sources carry no annotations, so tsc's strictness families
+ * that exist to demand annotations — or to reject dynamically-typed
+ * idioms that are ordinary, working JS — cannot be satisfied by the
+ * program's author at all. The design already says where inference gaps
+ * land: exactly where `any` lands in TS (island under --dynamic, honest
+ * fences without). So for JS FILES ONLY, these tsc families are not
+ * preflight gates; the values involved stay `any`/loose and every use
+ * meets the lowerer's per-site fences instead. TypeScript sources keep
+ * the full strict gate — nothing here weakens the default for annotated
+ * programs. */
+export const JS_RELAXED_TSC_CODES = new Set([
+    // implicit any (params, variables, elements, this, returns, rest,
+    // construct signatures, index reads over shapes with no index
+    // signature — typeof globalThis)
+    2683, 7005, 7006, 7008, 7009, 7010, 7015, 7017, 7019, 7022, 7023, 7024, 7031, 7034, 7053,
+    // strict-null narrowing demands (possibly null/undefined receivers)
+    2531, 2532, 2533, 18047, 18048, 18049,
+    // assignability/arity/callability of dynamic call shapes (valid JS,
+    // checked at runtime by Node; the lowerer re-checks every lowered form
+    // per site) and member/existence probes over dynamic shapes (expando
+    // properties, capability probes — the lowerer fences unknown members
+    // per site with the SC2020 family)
+    2322, 2339, 2345, 2349, 2351, 2367, 2554, 2555, 2556, 2769,
+    2740, // 2322's elaborated "missing the following properties" form
+    2305, 2551, 2724, 2731,
+    // excess object-literal properties against a JSDoc-inferred contextual
+    // type (and the did-you-mean variant): ordinary, working JS — the extra
+    // key rides the object at runtime exactly as written (the formatter idiom's
+    // expand-patterns passes an ignoreUnknown member its own JSDoc type
+    // never declared)
+    2353, 2561,
+    // JSDoc TYPE-SPACE claims that fail to check: a value name in a type
+    // position (2749/2702), generic constraints and index types spelled in
+    // typedefs (2344/2536/2538), an async @returns that is not Promise
+    // (1064), and 2366's no-ending-return against a JSDoc-declared return
+    // type. The claims are documentation — Node never reads them; the
+    // values keep their runtime behavior and every use meets the per-site
+    // fences (the pattern's source carries dozens of each).
+    2749, 2702, 2344, 2536, 2538, 1064, 2366,
+    // strict-null demands on dynamic shapes, continued: iterating/invoking
+    // possibly-undefined values (runtime re-checks at the site)
+    2488, 2721, 2722,
+    // an UNUSED @ts-expect-error: the directive annotated an error visible
+    // under the project's OWN tsconfig world — scriptc's world deliberately
+    // differs (adopted options, hidden declaration twins), and an unused
+    // suppression changes nothing at runtime
+    2578,
+    // a lib-floor demand (es2024+ members under the es2023 lib): the member
+    // types as the error-any and its use fences per site with the honest
+    // no-lowering story instead of gating the whole program
+    2550,
+    // `export *` ambiguity (2308): Node DEFINES this case — ambiguous names
+    // are excluded from the star surface — where tsc asks for an explicit
+    // re-export; and 2305's did-you-mean sibling 2614 joins 2305
+    2308, 2614,
+    // 2740's sibling elaboration ("Property X is missing in type Y")
+    2741,
+    // unresolvable modules: Node throws WHEN the require executes — the
+    // binding types as any and reached uses fence (never a silent pass)
+    2307, 2792,
+    // useUnknownInCatchVariables' annotation demand ("'e' is of type
+    // 'unknown'", "Object is of type 'unknown'"): a JS catch clause CANNOT
+    // annotate its variable, so the demand is unsatisfiable in source —
+    // exactly the implicit-any story above. The values stay 'unknown' and
+    // every use meets the lowerer's per-site unknown fences (member reads
+    // ride the checked-dynamic tree; unsupported operations fence loudly).
+    18046, 2571,
+]);
+/* Arithmetic on an `any` operand (TS2362/2363/2365 fire when the other
+ * side is bigint-ish): plain JS — relaxed only when 'any' participates. */
+export const JS_ANY_OPERATOR_CODES = new Set([2362, 2363, 2365]);
+/** True for JavaScript source file NAMES (.js/.mjs/.cjs/.jsx) — the files
+ * whose types come entirely from inference (checkJs + JSDoc) and whose JS
+ * relaxation stance applies. */
+export function isJsSourceFileName(fileName) {
+    return /\.(js|mjs|cjs|jsx)$/.test(fileName);
+}
+//# sourceMappingURL=tsc-codes.js.map

package/dist/frontend/tsc-codes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsc-codes.js","sourceRoot":"","sources":["../../src/frontend/tsc-codes.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,QAAQ;IACR,eAAe;IACf,kBAAkB;IAClB,qBAAqB;IACrB,qBAAqB;IACrB,8BAA8B;IAC9B,6BAA6B;IAC7B,gBAAgB;IAChB,cAAc;IACd,4BAA4B;IAC5B,0BAA0B;IAC1B,4BAA4B;IAC5B,oBAAoB;IACpB,oCAAoC;IACpC,mBAAmB;IACnB,4BAA4B;IAC5B,gBAAgB;IAChB,oBAAoB;IACpB,mBAAmB;IACnB,sBAAsB;IACtB,cAAc;IACd,iEAAiE;IACjE,qEAAqE;IACrE,kEAAkE;IAClE,kEAAkE;IAClE,iBAAiB;IACjB,8BAA8B;CACtB,CAAC;AAEX;;;;;;;;;;eAUe;AACf,MAAM,CAAC,MAAM,oBAAoB,GAAwB,IAAI,GAAG,CAAC;IAC/D,kEAAkE;IAClE,8DAA8D;IAC9D,iCAAiC;IACjC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI;IACxF,oEAAoE;IACpE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK;IACrC,oEAAoE;IACpE,uEAAuE;IACvE,qEAAqE;IACrE,qEAAqE;IACrE,mCAAmC;IACnC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI;IAC1D,IAAI,EAAE,4DAA4D;IAClE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI;IACtB,uEAAuE;IACvE,wEAAwE;IACxE,4EAA4E;IAC5E,oEAAoE;IACpE,kBAAkB;IAClB,IAAI,EAAE,IAAI;IACV,qEAAqE;IACrE,uEAAuE;IACvE,mEAAmE;IACnE,sEAAsE;IACtE,kEAAkE;IAClE,sEAAsE;IACtE,wDAAwD;IACxD,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI;IACxC,uEAAuE;IACvE,4DAA4D;IAC5D,IAAI,EAAE,IAAI,EAAE,IAAI;IAChB,uEAAuE;IACvE,wEAAwE;IACxE,qEAAqE;IACrE,yCAAyC;IACzC,IAAI;IACJ,wEAAwE;IACxE,qEAAqE;IACrE,wDAAwD;IACxD,IAAI;IACJ,wEAAwE;IACxE,sEAAsE;IACtE,6DAA6D;IAC7D,IAAI,EAAE,IAAI;IACV,iEAAiE;IACjE,IAAI;IACJ,oEAAoE;IACpE,oEAAoE;IACpE,IAAI,EAAE,IAAI;IACV,iEAAiE;IACjE,uEAAuE;IACvE,oEAAoE;IACpE,sEAAsE;IACtE,sEAAsE;IACtE,uEAAuE;IACvE,KAAK,EAAE,IAAI;CACZ,CAAC,CAAC;AAEH;2EAC2E;AAC3E,MAAM,CAAC,MAAM,qBAAqB,GAAwB,IAAI,GAAG,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;AAEtF;;gCAEgC;AAChC,MAAM,UAAU,kBAAkB,CAAC,QAAgB;IACjD,OAAO,qBAAqB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AAC9C,CAAC"}

package/dist/frontend/{types.d.ts → type-mapper.d.ts}

@@ -1,6 +1,6 @@
 import * as ts from "./ts7/adapter.js";
-import type { IrRecordShape, IrType, IrUnionDef } from "../ir/nodes.js";
-import { typeKey } from "../ir/nodes.js";
+import type { IrRecordShape, IrType, IrUnionDef } from "../ir/ir.js";
+import { typeKey } from "../ir/ir.js";
 export { typeKey };
 /** The ambient TYPE names of the fetch slice. Under --dynamic their
  * values live in the embedded engine and map to island handles (jsval).
@@ -158,16 +158,6 @@ export declare class UnionRegistry {
  * can't — it never sees IR types). `seen` breaks recursive shapes/unions:
  * a back-reference renders as "..." instead of expanding forever. */
 export declare function formatIrType(t: IrType, shapes: ShapeRegistry, unions: UnionRegistry, seen?: Set<string>): string;
-/** True when the declaration sits inside `declare module "<name>"` (or
- * its node:-prefixed twin) — the disambiguator for builtin-module type
- * names that repeat across modules (net.Server vs http.Server). Both
- * @types/node and the shipped fallback declare builtins this way. */
-/** ES OrdinaryOwnPropertyKeys order over string keys: canonical array
- * indices (the exact string spelling of an integer in [0, 2^32-1)) come
- * first in ascending numeric order, everything else follows in the given
- * (insertion/declaration) order. This is JS's enumeration order for the
- * objects records model — Object.keys, JSON.stringify, spread, inspect. */
-export declare function esOwnKeyOrder(names: string[]): string[];
 /** True when a type contains a record anywhere (the trigger for the
  * shape-mismatch diagnostic SC2002 — non-record mismatches are tsc's or
  * the validator's business). */
@@ -354,19 +344,6 @@ export declare function withUndefinedArm(t: IrType, unions: UnionRegistry): IrTy
  * Object.keys over such a shape omits the member (a pin — every excluded
  * member is a function the key walk would name). */
 export declare function isGenericCallableMemberType(t: ts.Type, checker: ts.TypeChecker): boolean;
-/** The `string | object`-family collapse domain (mapTypeInner's union
- * rule): arms the checked-dynamic representation holds FAITHFULLY, so a
- * union carrying a dyn arm beside only these maps to DYN wholesale.
- * Scalars and units are the checked-dynamic tree's own kinds (value-exact ===/typeof);
- * records and arrays qualify exactly when the dynFrom conversion can
- * build them (canConvertToDyn — JSON-safe data plus bytes-bearing
- * composites), entering as dyn data under the documented deep-copy
- * stance. Everything else — class instances, Maps/Sets, functions
- * (closure identity and `x === String` narrowing live in the typed union
- * machinery), promises, regexes, generators, handles, nested unions —
- * would DEGRADE (identity, methods, dispatch) riding dyn, so those arms
- * keep their existing homes and fences. */
-export declare function dynSubsumableUnionArm(arm: IrType, ctx: TypeMapperCtx): boolean;
 /** When an unmapped type is a SUPPORTED container/composite whose failure
  * lives in a component, answer a message tail naming the component (the
  * SC2009 story); null when the shape itself is the blocker (the caller

package/dist/frontend/{types.js → type-mapper.js}

@@ -1,8 +1,9 @@
+import { InternalCompilerError } from "../errors.js";
 import * as ts from "./ts7/adapter.js";
-import { arrayOf, BOOL, bytesOf, canConvertToDyn, CHILD_T, DATE_T, DYN, F64, funcOf, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, JSVAL, mapOf, NULL_T, PROCSTREAM_T, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, setOf, STRING, SYMBOL_T, typeEquals, typeKey, UNDEFINED_T, VOID } from "../ir/nodes.js";
+import { arrayOf, BOOL, bytesOf, canConvertToDyn, CHILD_T, DATE_T, DYN, F64, funcOf, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, JSVAL, mapOf, NULL_T, PROCSTREAM_T, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, setOf, STRING, SYMBOL_T, typeEquals, typeKey, UNDEFINED_T, VOID } from "../ir/ir.js";
 import { isJsSourceFile, isNodeTypesPath } from "./program.js";
-import { accessorSlotProp } from "../ir/nodes.js";
-// typeKey moved to ir/nodes.ts (the backend needs it too, for per-type
+import { accessorSlotProp } from "../ir/ir.js";
+// typeKey moved to ir/ir.ts (the backend needs it too, for per-type
 // helper interning); re-exported here so frontend call sites keep their
 // import path.
 export { typeKey };
@@ -226,7 +227,7 @@ export class ShapeRegistry {
     finalizeRecursive(t, fields, indexValue, declaredOrder) {
         const id = this.recIds.get(t);
         if (id === undefined)
-            throw new Error("shape registry bug: finalizeRecursive without a placeholder");
+            throw new InternalCompilerError("shape registry bug: finalizeRecursive without a placeholder");
         if (this.pendingRec.has(id)) {
             const shape = this.byId.get(id);
             shape.fields = fields;
@@ -335,7 +336,7 @@ export class UnionRegistry {
     finalizeRecursive(t, arms) {
         const id = this.recIds.get(t);
         if (id === undefined)
-            throw new Error("union registry bug: finalizeRecursive without a placeholder");
+            throw new InternalCompilerError("union registry bug: finalizeRecursive without a placeholder");
         if (this.pendingRec.has(id)) {
             const def = this.byId.get(id);
             def.arms.push(...arms);
@@ -512,7 +513,7 @@ export function formatIrType(t, shapes, unions, seen = new Set()) {
         default: {
             const _exhaustive = t;
             void _exhaustive;
-            throw new Error("unreachable");
+            throw new InternalCompilerError("unreachable");
         }
     }
 }
@@ -525,7 +526,7 @@ export function formatIrType(t, shapes, unions, seen = new Set()) {
  * first in ascending numeric order, everything else follows in the given
  * (insertion/declaration) order. This is JS's enumeration order for the
  * objects records model — Object.keys, JSON.stringify, spread, inspect. */
-export function esOwnKeyOrder(names) {
+function esOwnKeyOrder(names) {
     const isArrayIndex = (name) => {
         const n = Number(name);
         return Number.isInteger(n) && n >= 0 && n < 4294967295 && String(n) === name;
@@ -590,7 +591,7 @@ export function containsUnion(t) {
             return false;
     }
 }
-/** lower-calls.ts's bodyReadsArguments, duplicated here (types.ts must not
+/** lower-calls.ts's bodyReadsArguments, duplicated here (type-mapper.ts must not
  * import from lowering/ — that edge is a module cycle): does the function's
  * OWN body read `arguments`? Nested plain functions/methods own theirs
  * (skipped); arrows see the enclosing one (descended). */
@@ -886,7 +887,7 @@ function mapTypeInner(type, ctx) {
     // falls through to the general union branch below, whose per-part
     // recursion re-enters here with the pure enum parts.
     if (flags & ts.TypeFlags.EnumLike) {
-        const parts = widened.isUnionType() ? widened.getTypes() : [widened];
+        const parts = widened.isUnionType() ? ts.constituentTypes(widened) : [widened];
         if (parts.every((p) => p.flags & ts.TypeFlags.EnumLike)) {
             let hasNum = false;
             let hasStr = false;
@@ -982,35 +983,8 @@ function mapTypeInner(type, ctx) {
         // keeps its static array-of-handles representation.
         if (elem?.kind === "jsval" && !(elemTs.flags & ts.TypeFlags.Any))
             return JSVAL;
-        // RegExp elements ride REF (scr_regex_retain_v/release_v, no trace —
-        // a regex holds only its bytecode and source): the derived-pattern
-        // idiom `[bases].map(ps => new RegExp(...))` builds real regex
-        // arrays, elements flow into the regex intrinsics unchanged, and
-        // indexOf/includes/=== are the REF kind's pointer identity — exactly
-        // JS object identity for RegExp values.
-        if (!elem ||
-            elem.kind === "void" ||
-            elem.kind === "date" ||
-            elem.kind === "map" ||
-            elem.kind === "set" ||
-            elem.kind === "url" ||
-            elem.kind === "searchParams" ||
-            elem.kind === "stats" ||
-            elem.kind === "fileHandle" ||
-            elem.kind === "spawnRes" ||
-            elem.kind === "netSocket" ||
-            elem.kind === "dgramSocket" ||
-            elem.kind === "testCtx" ||
-            elem.kind === "httpReq" ||
-            elem.kind === "httpRes" ||
-            elem.kind === "httpClientReq" ||
-            elem.kind === "secureCtx" ||
-            elem.kind === "fsWatcher" ||
-            elem.kind === "childStream" ||
-            elem.kind === "procStream" ||
-            elem.kind === "generator") {
-            return null; // ScrArr has no closure/map/regex/url element kinds yet
-        }
+        if (!elem)
+            return null;
         // A dyn ELEMENT makes the WHOLE array the checked-dynamic value:
         // `unknown[]`, `object[]`, and the collapsed `(string | object)[]`
         // (the plugins-slot shape) — the checked-dynamic tree has real arrays, so length/
@@ -1021,6 +995,11 @@ function mapTypeInner(type, ctx) {
         // array literal) and typed sources convert per element at the slot.
         if (elem.kind === "dyn")
             return DYN;
+        // The shared predicate is the runtime/backend storage contract. In
+        // particular, valid standalone values such as Map/Set/Date and opaque
+        // handles do not automatically have an array element representation.
+        if (!isSupportedArrayElem(elem))
+            return null;
         // ChildProcess[] (the running-apps list) and Server[] (the [...set]
         // drain of the auxiliary-server registries): handles are ordinary
         // refcounted REF elements (their `_v` adapters, no trace — both drop
@@ -1112,7 +1091,7 @@ function mapTypeInner(type, ctx) {
         ]);
         let handle = null;
         let refined = true;
-        for (const part of widened.getTypes()) {
+        for (const part of ts.constituentTypes(widened)) {
             const mapped = mapType(part, ctx);
             if (mapped && HANDLE_KINDS.has(mapped.kind)) {
                 if (handle !== null && handle.kind !== mapped.kind) {
@@ -2295,7 +2274,7 @@ function mapTypeInner(type, ctx) {
         const sensitivityAtEntry = contextResolutions;
         try {
             const byKey = new Map();
-            for (const part of widened.getTypes()) {
+            for (const part of ts.constituentTypes(widened)) {
                 // A `void` PART is inhabited only by undefined (`Promise<void> |
                 // void` return types, `string | void`): it becomes the undefinedT
                 // unit arm, exactly like an undefined part — the value either
@@ -2324,7 +2303,7 @@ function mapTypeInner(type, ctx) {
                     return JSVAL;
                 if (!mapped) {
                     // Before failing the whole union, let a LATER jsval part absorb.
-                    for (const rest of widened.getTypes()) {
+                    for (const rest of ts.constituentTypes(widened)) {
                         if (mapType(rest, ctx)?.kind === "jsval")
                             return JSVAL;
                     }
@@ -2442,13 +2421,13 @@ function mapNarrowedTypeParam(type, ctx) {
             return (allowNull = true);
         // A companion UNION (`T & ({} | null)`): each part is an allowance.
         if (c.isUnionType())
-            return c.getTypes().every(visitCompanion);
+            return ts.constituentTypes(c).every(visitCompanion);
         return false;
     };
     const visitPart = (part) => {
         if (!part.isIntersectionType())
             return false;
-        for (const p of part.getTypes()) {
+        for (const p of ts.constituentTypes(part)) {
             if (p.flags & ts.TypeFlags.TypeParameter) {
                 if (tp && tp !== p)
                     return false; // two different parameters: not this pattern
@@ -2460,7 +2439,7 @@ function mapNarrowedTypeParam(type, ctx) {
         }
         return true;
     };
-    const parts = type.isUnionType() ? type.getTypes() : [type];
+    const parts = type.isUnionType() ? ts.constituentTypes(type) : [type];
     if (!parts.every(visitPart) || !tp)
         return undefined;
     const bound = resolveTypeParam(tp);
@@ -2765,7 +2744,7 @@ export function genResultRecord(yieldT, retT, shapes, unions) {
  * a value). */
 export function isUnitOnlyTsType(t) {
     const UNIT = ts.TypeFlags.Undefined | ts.TypeFlags.Void | ts.TypeFlags.Null;
-    const parts = t.isUnionType() ? t.getTypes() : [t];
+    const parts = t.isUnionType() ? ts.constituentTypes(t) : [t];
     return parts.every((p) => (p.flags & UNIT) !== 0);
 }
 /** IR-level `t | undefined`, canonicalized and fenced exactly like the
@@ -2814,7 +2793,7 @@ function mapHybridCallableIntersection(widened, ctx) {
     if (checker.getCallSignatures(widened).length !== 1)
         return null;
     let funcPart = null;
-    for (const part of widened.getTypes()) {
+    for (const part of ts.constituentTypes(widened)) {
         if (checker.getCallSignatures(part).length > 0) {
             if (funcPart)
                 return null; // exactly one callable part
@@ -2872,7 +2851,7 @@ function isMappedShape(t) {
 function recordProvenanceOk(t, ctx) {
     const { checker } = ctx;
     if (t.isIntersectionType()) {
-        return t.getTypes().every((part) => {
+        return ts.constituentTypes(t).every((part) => {
             const partSym = part.getSymbol();
             return (part.flags & ts.TypeFlags.Object) !== 0 &&
                 !(partSym && partSym.flags & ts.SymbolFlags.Class) &&
@@ -2999,7 +2978,7 @@ function mapRecordTypeInner(widened, ctx) {
     if (indexInfos.length > 0) {
         const stringKey = (k) => (k.flags & ts.TypeFlags.String) !== 0 ||
             (k.isIntersectionType() &&
-                k.getTypes().every((p) => (p.flags & ts.TypeFlags.String) !== 0 ||
+                ts.constituentTypes(k).every((p) => (p.flags & ts.TypeFlags.String) !== 0 ||
                     ((p.flags & ts.TypeFlags.Object) !== 0 &&
                         checker.getPropertiesOfType(p).length === 0 &&
                         checker.getCallSignatures(p).length === 0 &&
@@ -3123,7 +3102,7 @@ function mapRecordTypeInner(widened, ctx) {
                 // OBJECT-LITERAL get/set accessors (TS sources): the property has
                 // no data slot — the shape carries reserved closure fields instead
                 // (`%get:x` invoked per read, `%set:x` per write; see
-                // accessorSlotProp in ir/nodes.ts). Type-literal and interface
+                // accessorSlotProp in ir/ir.ts). Type-literal and interface
                 // accessor MEMBERS map the same way so accessor records cross
                 // annotated boundaries (`function f(p: { get x(): number })`) —
                 // tsc lets a plain DATA property satisfy such a member, but the
@@ -3283,7 +3262,7 @@ const STDLIB_CONTAINERS = {
  * machinery), promises, regexes, generators, handles, nested unions —
  * would DEGRADE (identity, methods, dispatch) riding dyn, so those arms
  * keep their existing homes and fences. */
-export function dynSubsumableUnionArm(arm, ctx) {
+function dynSubsumableUnionArm(arm, ctx) {
     switch (arm.kind) {
         case "dyn":
         case "f64":
@@ -3392,7 +3371,7 @@ export function describeComponentBlocker(widened, ctx) {
     // arm kind with no union home. Unions have no symbol, so a null answer
     // falls through to the residual fence, never to a false lib claim.
     if (widened.isUnionType()) {
-        const parts = widened.getTypes();
+        const parts = ts.constituentTypes(widened);
         const UNIT = ts.TypeFlags.Undefined | ts.TypeFlags.Void | ts.TypeFlags.Null;
         const dataArms = parts.filter((p) => (p.flags & UNIT) === 0);
         // A union carrying an 'object'/'unknown'-flavored arm rides the
@@ -3505,4 +3484,4 @@ export function describeRecordMemberBlocker(widened, ctx) {
     }
     return null;
 }
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=type-mapper.js.map