@geastack/compiler 1.0.15

package/dist/semantics/callable-origins.js

@@ -0,0 +1,354 @@
+import { operandOf, resultOf } from './model/operands.js';
+/**
+ * Exact source-Function provenance carried by semantic results.
+ *
+ * Structural callable types are deliberately absent: two unrelated functions
+ * may have the same signature and therefore the same StructuralTypeId. An
+ * allocation is the only provenance root, because normalization puts its
+ * checker-authenticated FunctionId on the operation. A binding preserves that
+ * identity only when every write to the cell is itself already proven to be
+ * the same function; aliases therefore compose, while reassignment, unions and
+ * unknown writes fail closed.
+ */
+const callableOriginsByGraph = new WeakMap();
+export const callableOriginsOf = (graph) => {
+    const known = callableOriginsByGraph.get(graph);
+    if (known)
+        return known;
+    const origins = new Map();
+    const writes = new Map();
+    for (const operation of graph.operations.values()) {
+        if (operation.family === 'allocation' && operation.allocated === 'function-object' && operation.callable !== null) {
+            const value = resultOf(operation, 'value');
+            if (value)
+                origins.set(value.id, operation.callable);
+            continue;
+        }
+        if (operation.family !== 'binding' || (operation.action !== 'initialize' && operation.action !== 'write'))
+            continue;
+        const bucket = writes.get(operation.declaration);
+        if (bucket)
+            bucket.push(operation);
+        else
+            writes.set(operation.declaration, [operation]);
+    }
+    const cells = new Map();
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const [declaration, operations] of writes) {
+            if (cells.has(declaration))
+                continue;
+            let candidate = null;
+            let complete = true;
+            for (const operation of operations) {
+                const source = operation.operands.find((operand) => operand.evaluation.kind !== 'provenance')?.source;
+                const origin = source?.kind === 'result' ? origins.get(source.result) : undefined;
+                if (origin === undefined || (candidate !== null && candidate !== origin)) {
+                    complete = false;
+                    break;
+                }
+                candidate = origin;
+            }
+            if (!complete || candidate === null)
+                continue;
+            cells.set(declaration, candidate);
+            changed = true;
+        }
+        for (const operation of graph.operations.values()) {
+            // A `[[Set]]` publishes the RECEIVER it wrote into, not the stored value
+            // (`producers/properties.ts` says so where it mints the result), so the
+            // Function object the store threads onward is the one it was handed.
+            // Writing an expando onto a callable was the second view of a boxed
+            // callable that kept a native carrier while the object it restates was
+            // `dynamic`.
+            if (operation.family === 'property' && operation.internalMethod === 'set') {
+                const receiver = operandOf(operation, 'receiver');
+                const stored = receiver?.source.kind === 'result' ? origins.get(receiver.source.result) : undefined;
+                const value = resultOf(operation, 'value');
+                if (stored !== undefined && value && !origins.has(value.id)) {
+                    origins.set(value.id, stored);
+                    changed = true;
+                }
+            }
+            if (operation.family !== 'binding')
+                continue;
+            const origin = cells.get(operation.declaration);
+            if (origin === undefined)
+                continue;
+            const value = resultOf(operation, 'value');
+            if (value && !origins.has(value.id)) {
+                origins.set(value.id, origin);
+                changed = true;
+            }
+            // The REFERENCE this read takes `GetValue` of denotes the same Function
+            // object the read produces -- ECMA-262 6.2.5.5 is one step over one cell,
+            // and nothing between them can be a different function. Left unstamped,
+            // a reference result was the one view of a boxed callable that kept a
+            // native carrier while its own cell was `dynamic`, so `--dynamic-fallback`
+            // emitted `CallableConstructorObject v = <gea::Value cell>` and the C++
+            // did not compile (`dynamic-callable-abi-recovery.runtime.js`).
+            for (const operand of operation.operands) {
+                if (operand.source.kind !== 'result')
+                    continue;
+                const cited = graph.operations.get(graph.results.get(operand.source.result) ?? '');
+                if (cited?.family !== 'reference' || cited.form !== 'identifier')
+                    continue;
+                if (origins.has(operand.source.result))
+                    continue;
+                origins.set(operand.source.result, origin);
+                changed = true;
+            }
+        }
+    }
+    callableOriginsByGraph.set(graph, origins);
+    return origins;
+};
+/**
+ * Which source functions own a `prototype` object, keyed by the same
+ * checker-authenticated `FunctionId` `callableOriginsOf` resolves a value to.
+ *
+ * The fact itself is the declaration's (`producers/shared.ts`'s
+ * `ownPrototypePropertyOf`); this only indexes it by function, and only from
+ * the allocation that states it -- a function whose allocation states nothing
+ * is absent here, and absence is the third answer, never `false`.
+ */
+const ownPrototypeFactsByGraph = new WeakMap();
+const ownPrototypeFactsOf = (graph) => {
+    const known = ownPrototypeFactsByGraph.get(graph);
+    if (known)
+        return known;
+    const facts = new Map();
+    for (const operation of graph.operations.values()) {
+        if (operation.family !== 'allocation' || operation.callable === null)
+            continue;
+        if (operation.ownPrototypeProperty === undefined)
+            continue;
+        facts.set(operation.callable, operation.ownPrototypeProperty);
+    }
+    ownPrototypeFactsByGraph.set(graph, facts);
+    return facts;
+};
+/**
+ * Whether the callable this operation reads through owns a `prototype`
+ * object -- `null` where the graph cannot prove either answer.
+ *
+ * The one authority for the question `function-and-constructor` used to answer
+ * by accident. That carrier owns a `prototype` because the checker gave the
+ * value a construct signature, and `function-value-dispatch` was read as
+ * owning none for the mirror-image reason -- which made "how is this value
+ * invoked" and "does the declaration behind it have a `prototype`" one answer.
+ * They are the same answer for every function until one is written as an
+ * ordinary `function` and used only as a call, which is exactly where a
+ * `Factory.prototype` read landed on a carrier that denied having one.
+ *
+ * `null` is returned for a value with no proven origin (a parameter, a union
+ * of two functions, a reassigned cell) and for a generator, whose allocation
+ * deliberately states nothing. Both keep the read refused rather than
+ * answering `undefined` for a property that exists.
+ */
+export const callableOwnPrototypeAt = (graph, operation) => {
+    const receiver = operandOf(operation, 'receiver');
+    if (receiver?.source.kind !== 'result')
+        return null;
+    const origin = callableOriginsOf(graph).get(receiver.source.result);
+    if (origin === undefined)
+        return null;
+    return ownPrototypeFactsOf(graph).get(origin) ?? null;
+};
+/** A computed key can overwrite either explicit-this builtin. */
+export const unknownCallableOwnProperty = '*';
+const propertyNameOf = (operation, role, ordinal = 0) => {
+    const key = operandOf(operation, role, ordinal);
+    return key?.source.kind === 'constant' && key.source.literal === 'string' ? key.source.text : unknownCallableOwnProperty;
+};
+/** Semantic results proven to carry the one global Function.prototype object. */
+const functionPrototypeOriginsByGraph = new WeakMap();
+const functionPrototypeOriginsOf = (graph) => {
+    const known = functionPrototypeOriginsByGraph.get(graph);
+    if (known)
+        return known;
+    const origins = new Set();
+    const writes = new Map();
+    for (const operation of graph.operations.values()) {
+        if (operation.family === 'property' && operation.internalMethod === 'get' && operation.intrinsicValue === 'function-prototype') {
+            const value = resultOf(operation, 'value');
+            if (value)
+                origins.add(value.id);
+        }
+        if (operation.family !== 'binding' || (operation.action !== 'initialize' && operation.action !== 'write'))
+            continue;
+        const bucket = writes.get(operation.declaration);
+        if (bucket)
+            bucket.push(operation);
+        else
+            writes.set(operation.declaration, [operation]);
+    }
+    const cells = new Set();
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const [declaration, operations] of writes) {
+            if (cells.has(declaration))
+                continue;
+            const complete = operations.length > 0 &&
+                operations.every((operation) => {
+                    const source = operation.operands.find((operand) => operand.evaluation.kind !== 'provenance')?.source;
+                    return source?.kind === 'result' && origins.has(source.result);
+                });
+            if (!complete)
+                continue;
+            cells.add(declaration);
+            changed = true;
+        }
+        for (const operation of graph.operations.values()) {
+            if (operation.family === 'binding' && cells.has(operation.declaration)) {
+                const value = resultOf(operation, 'value');
+                if (value && !origins.has(value.id)) {
+                    origins.add(value.id);
+                    changed = true;
+                }
+            }
+            if (operation.family === 'invocation' && operation.intrinsicMutation !== undefined && operation.intrinsicMutation !== 'reflect-set') {
+                const target = operandOf(operation, 'argument', 0);
+                const value = resultOf(operation, 'value');
+                if (target?.source.kind === 'result' && origins.has(target.source.result) && value && !origins.has(value.id)) {
+                    origins.add(value.id);
+                    changed = true;
+                }
+            }
+        }
+    }
+    functionPrototypeOriginsByGraph.set(graph, origins);
+    return origins;
+};
+const callableWriteTargetsByGraph = new WeakMap();
+const callableWriteTargetsOf = (graph) => {
+    const known = callableWriteTargetsByGraph.get(graph);
+    if (known)
+        return known;
+    const targets = [];
+    for (const operation of graph.operations.values()) {
+        if (operation.family === 'property') {
+            if (operation.internalMethod !== 'set' && operation.internalMethod !== 'delete' && operation.internalMethod !== 'define-own-property')
+                continue;
+            const receiver = operandOf(operation, 'receiver');
+            if (receiver?.source.kind !== 'result')
+                continue;
+            targets.push({ result: receiver.source.result, name: propertyNameOf(operation, 'key') });
+            continue;
+        }
+        if (operation.family !== 'invocation' || operation.intrinsicMutation === undefined)
+            continue;
+        const target = operandOf(operation, 'argument', 0);
+        if (target?.source.kind !== 'result')
+            continue;
+        const name = operation.intrinsicMutation === 'object-assign' || operation.intrinsicMutation === 'object-define-properties'
+            ? unknownCallableOwnProperty
+            : propertyNameOf(operation, 'argument', 1);
+        targets.push({ result: target.source.result, name });
+    }
+    callableWriteTargetsByGraph.set(graph, targets);
+    return targets;
+};
+/**
+ * Own-property writes grouped by the exact Function object they PROVABLY
+ * target -- the half of `callableMutationFactsOf` that needs no plan.
+ *
+ * Published separately because `representation/publish.ts` has to ask it: a
+ * read of `call`/`apply`/`bind` off a Function the program overwrote yields
+ * that object's own dynamic property table, not the `Function.prototype`
+ * method `lib.es5.d.ts` types the read as, and the carrier has to say so
+ * before any plan exists. A write whose target object is unknown is absent
+ * here and present in `anonymousProperties` below; that asymmetry is the
+ * whole reason the two views are separate, and it is why this one is a
+ * SUBSET -- never a superset -- of what the certify stage refuses on.
+ */
+const callableOwnWritesByGraph = new WeakMap();
+export const callableOwnPropertyWritesOf = (graph, origins = callableOriginsOf(graph)) => {
+    const known = callableOwnWritesByGraph.get(graph);
+    if (known)
+        return known;
+    const writes = new Map();
+    const prototypeOrigins = functionPrototypeOriginsOf(graph);
+    for (const target of callableWriteTargetsOf(graph)) {
+        if (prototypeOrigins.has(target.result))
+            continue;
+        const origin = origins.get(target.result);
+        if (origin === undefined)
+            continue;
+        const bucket = writes.get(origin);
+        if (bucket)
+            bucket.add(target.name);
+        else
+            writes.set(origin, new Set([target.name]));
+    }
+    callableOwnWritesByGraph.set(graph, writes);
+    return writes;
+};
+const callableMutationFactsByPlan = new WeakMap();
+const canCarryCallableObject = (plan, result) => {
+    const representation = plan.selected.get(result);
+    if (representation === undefined)
+        return false;
+    switch (representation.kind) {
+        case 'function':
+        case 'function-family':
+        case 'function-value-family':
+        case 'function-value-dispatch':
+        case 'function-and-constructor':
+        case 'generic-function-set':
+        case 'dynamic':
+            return true;
+        default:
+            return false;
+    }
+};
+/**
+ * Own-property mutations grouped by the exact Function object they target.
+ *
+ * This deliberately records more than writes that dominate a particular
+ * read: absence from the whole-program set is the proof a static
+ * `Function.prototype.call`/`apply` rewrite needs. A write in an exclusive or
+ * later branch may conservatively keep the ordinary property call, but can
+ * never be skipped as if it did not exist.
+ */
+export const callableMutationFactsOf = (graph, plan, origins = callableOriginsOf(graph)) => {
+    const known = callableMutationFactsByPlan.get(plan);
+    if (known)
+        return known;
+    const anonymousWrites = new Set();
+    const prototypeWrites = new Set();
+    const prototypeOrigins = functionPrototypeOriginsOf(graph);
+    for (const target of callableWriteTargetsOf(graph)) {
+        if (prototypeOrigins.has(target.result)) {
+            prototypeWrites.add(target.name);
+            continue;
+        }
+        if (origins.get(target.result) !== undefined)
+            continue;
+        if (canCarryCallableObject(plan, target.result))
+            anonymousWrites.add(target.name);
+    }
+    const facts = {
+        ownProperties: callableOwnPropertyWritesOf(graph, origins),
+        anonymousProperties: anonymousWrites,
+        functionPrototypeProperties: prototypeWrites
+    };
+    callableMutationFactsByPlan.set(plan, facts);
+    return facts;
+};
+/** One shared proof used by preflight and IR lowering before skipping [[Get]]. */
+export const callableBuiltinResolution = (facts, functionId, member) => {
+    const prototype = facts.functionPrototypeProperties;
+    if (prototype.has(member) || prototype.has(unknownCallableOwnProperty))
+        return 'prototype-mutated';
+    const unknown = facts.anonymousProperties;
+    if (unknown.has(member) || unknown.has(unknownCallableOwnProperty))
+        return 'ordinary-property';
+    const own = functionId === null ? undefined : facts.ownProperties.get(functionId);
+    if (own?.has(member) || own?.has(unknownCallableOwnProperty))
+        return 'ordinary-property';
+    return 'builtin';
+};
+export const callableBuiltinIsUnshadowed = (facts, functionId, member) => callableBuiltinResolution(facts, functionId, member) === 'builtin';

package/dist/semantics/class-alias.d.ts

@@ -0,0 +1,7 @@
+import ts from 'typescript';
+/**
+ * A const whose initializer is a class value hidden only by type assertions.
+ * The assertions allocate nothing and the const cannot change, so reading the
+ * inner class preserves the runtime identity used by heritage and `super()`.
+ */
+export declare const transparentConstClassAliasTarget: (checker: ts.TypeChecker, node: ts.Expression) => ts.Identifier | null;

package/dist/semantics/class-alias.js

@@ -0,0 +1,37 @@
+import ts from 'typescript';
+const transparentExpression = (node) => {
+    let current = node;
+    while (ts.isParenthesizedExpression(current) ||
+        ts.isAsExpression(current) ||
+        ts.isTypeAssertionExpression(current) ||
+        ts.isSatisfiesExpression(current) ||
+        ts.isNonNullExpression(current)) {
+        current = current.expression;
+    }
+    return current;
+};
+const classDeclarationOf = (checker, symbol) => {
+    const resolved = (symbol.flags & ts.SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(symbol) : symbol;
+    const declaration = resolved.valueDeclaration ?? resolved.declarations?.find((candidate) => ts.isClassLike(candidate));
+    return declaration && ts.isClassLike(declaration) ? declaration : null;
+};
+/**
+ * A const whose initializer is a class value hidden only by type assertions.
+ * The assertions allocate nothing and the const cannot change, so reading the
+ * inner class preserves the runtime identity used by heritage and `super()`.
+ */
+export const transparentConstClassAliasTarget = (checker, node) => {
+    if (!ts.isIdentifier(node))
+        return null;
+    const symbol = checker.getSymbolAtLocation(node);
+    const declaration = symbol?.valueDeclaration;
+    if (!declaration || !ts.isVariableDeclaration(declaration) || !declaration.initializer)
+        return null;
+    if (!ts.isVariableDeclarationList(declaration.parent) || (declaration.parent.flags & ts.NodeFlags.Const) === 0)
+        return null;
+    const target = transparentExpression(declaration.initializer);
+    if (!ts.isIdentifier(target))
+        return null;
+    const targetSymbol = checker.getSymbolAtLocation(target);
+    return targetSymbol && classDeclarationOf(checker, targetSymbol) ? target : null;
+};

package/dist/semantics/class-heritage.d.ts

@@ -0,0 +1,34 @@
+import ts from 'typescript';
+import type { DeclarationId } from '../identity/ids.js';
+import type { IdentityTable } from './normalize/identities.js';
+/**
+ * Which classes each class INHERITS FROM, transitively -- the one fact two
+ * separate carrier questions both need and neither can answer on its own.
+ *
+ * `representation/derive.ts` reduces `T & AggregateOperation` -- what
+ * `operation instanceof AggregateOperation` narrows a `T extends
+ * AbstractOperation` parameter to -- and a reduction is only sound when one
+ * member is provably the other's ancestor, in which case the intersection IS
+ * the more-derived class. `conversion/build.ts` enumerates the widening from
+ * `class-ref(MongoRuntimeError)` to `class-ref(MongoError)` that `previous ??
+ * new MongoRuntimeError(...)` needs, and a widening is only sound in the
+ * ancestor direction. Both live below the semantic layer and neither may
+ * import `typescript`, so the answer is resolved once here and installed as a
+ * policy, the same way `KeyedCollectionPolicy` and `DateDeclarationPolicy`
+ * are.
+ *
+ * The CHECKER answers it, not the heritage syntax: `class D extends mixin(B)`
+ * states no name to read, and `getBaseTypes` follows the same chain
+ * assignability does. That also makes this agree with
+ * `projection/classes.ts`'s own `base` link by construction -- that one is
+ * read off the evaluated heritage value's carrier for the same reason, so the
+ * two never disagree about what a class extends, they only differ in how far
+ * they follow it (one link versus the whole chain).
+ *
+ * Interfaces a class `implements` are deliberately absent. This states class
+ * INHERITANCE -- shared storage and a shared struct base -- and an
+ * implemented interface shares neither; `records.ts` emits `struct D : B` for
+ * the base only. Claiming an interface here would license an upcast to a
+ * carrier no C++ base subobject backs.
+ */
+export declare const classHeritageOf: (checker: ts.TypeChecker, identities: IdentityTable, files: readonly ts.SourceFile[], reparentedBaseOf?: (node: ts.ClassLikeDeclaration) => ts.ClassLikeDeclaration | null) => ReadonlyMap<DeclarationId, readonly DeclarationId[]>;

package/dist/semantics/class-heritage.js

@@ -0,0 +1,104 @@
+import ts from 'typescript';
+import { transparentConstClassAliasTarget } from './class-alias.js';
+/**
+ * Which classes each class INHERITS FROM, transitively -- the one fact two
+ * separate carrier questions both need and neither can answer on its own.
+ *
+ * `representation/derive.ts` reduces `T & AggregateOperation` -- what
+ * `operation instanceof AggregateOperation` narrows a `T extends
+ * AbstractOperation` parameter to -- and a reduction is only sound when one
+ * member is provably the other's ancestor, in which case the intersection IS
+ * the more-derived class. `conversion/build.ts` enumerates the widening from
+ * `class-ref(MongoRuntimeError)` to `class-ref(MongoError)` that `previous ??
+ * new MongoRuntimeError(...)` needs, and a widening is only sound in the
+ * ancestor direction. Both live below the semantic layer and neither may
+ * import `typescript`, so the answer is resolved once here and installed as a
+ * policy, the same way `KeyedCollectionPolicy` and `DateDeclarationPolicy`
+ * are.
+ *
+ * The CHECKER answers it, not the heritage syntax: `class D extends mixin(B)`
+ * states no name to read, and `getBaseTypes` follows the same chain
+ * assignability does. That also makes this agree with
+ * `projection/classes.ts`'s own `base` link by construction -- that one is
+ * read off the evaluated heritage value's carrier for the same reason, so the
+ * two never disagree about what a class extends, they only differ in how far
+ * they follow it (one link versus the whole chain).
+ *
+ * Interfaces a class `implements` are deliberately absent. This states class
+ * INHERITANCE -- shared storage and a shared struct base -- and an
+ * implemented interface shares neither; `records.ts` emits `struct D : B` for
+ * the base only. Claiming an interface here would license an upcast to a
+ * carrier no C++ base subobject backs.
+ */
+export const classHeritageOf = (checker, identities, files, 
+// `Object.setPrototypeOf(C.prototype, B.prototype)` makes `B` the class `C`
+// inherits from exactly as `extends B` would for member lookup and
+// `instanceof`; see `prototype-reparenting.ts` for when that is modelled.
+reparentedBaseOf = () => null) => {
+    const declarationOf = (type) => {
+        const symbol = type.getSymbol();
+        const node = symbol?.declarations?.find((candidate) => ts.isClassLike(candidate));
+        if (!node || !ts.isClassLike(node))
+            return null;
+        return { node, id: identities.declarationIdOf(node) };
+    };
+    const heritage = new Map();
+    const active = new Set();
+    const ancestorsOf = (node, id) => {
+        const known = heritage.get(id);
+        if (known)
+            return known;
+        // A cycle is not expressible in TypeScript, but a malformed or partially
+        // resolved program can still present one, and answering the empty chain
+        // for the node already being walked keeps this total rather than
+        // recursing until the stack runs out.
+        if (active.has(id))
+            return [];
+        active.add(id);
+        const symbol = checker.getSymbolAtLocation(node.name ?? node);
+        const declared = symbol ? checker.getDeclaredTypeOfSymbol(symbol) : null;
+        const chain = [];
+        const syntacticBase = node.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0]?.expression;
+        const aliasedBase = syntacticBase ? transparentConstClassAliasTarget(checker, syntacticBase) : null;
+        const aliasedSymbol = aliasedBase ? checker.getSymbolAtLocation(aliasedBase) : undefined;
+        const aliasedDeclaration = aliasedSymbol ? identities.declarationOfSymbol(aliasedSymbol) : null;
+        if (aliasedDeclaration && ts.isClassLike(aliasedDeclaration)) {
+            const baseId = identities.declarationIdOf(aliasedDeclaration);
+            chain.push(baseId);
+            for (const further of ancestorsOf(aliasedDeclaration, baseId))
+                if (!chain.includes(further))
+                    chain.push(further);
+        }
+        const reparented = reparentedBaseOf(node);
+        if (reparented) {
+            const baseId = identities.declarationIdOf(reparented);
+            chain.push(baseId);
+            for (const further of ancestorsOf(reparented, baseId))
+                if (!chain.includes(further))
+                    chain.push(further);
+        }
+        for (const base of declared?.isClassOrInterface() ? checker.getBaseTypes(declared) : []) {
+            const resolved = declarationOf(base);
+            if (!resolved)
+                continue;
+            if (!chain.includes(resolved.id))
+                chain.push(resolved.id);
+            for (const further of ancestorsOf(resolved.node, resolved.id)) {
+                if (!chain.includes(further))
+                    chain.push(further);
+            }
+        }
+        active.delete(id);
+        heritage.set(id, chain);
+        return chain;
+    };
+    for (const file of files) {
+        const visit = (node) => {
+            if (ts.isClassLike(node))
+                ancestorsOf(node, identities.declarationIdOf(node));
+            ts.forEachChild(node, visit);
+        };
+        visit(file);
+    }
+    return heritage;
+};

package/dist/semantics/commonjs-wrapper.d.ts

@@ -0,0 +1,69 @@
+import ts from 'typescript';
+import type { CommonJsWrapperDeclaration } from '../plugins/model.js';
+export type CommonJsGlobal = 'require' | 'exports' | 'module';
+export type CommonJsIdentifierIdentity = {
+    readonly kind: 'wrapper';
+    readonly global: CommonJsGlobal;
+} | {
+    readonly kind: 'provenance-failure';
+} | {
+    readonly kind: 'ordinary';
+};
+export declare const commonJsWrapperVariableOf: (node: ts.Node) => ts.VariableDeclaration | null;
+/** Whether a `var` declaration shares the outer CommonJS wrapper's VariableEnvironment. */
+export declare const isCommonJsWrapperVarDeclaration: (node: ts.VariableDeclaration) => boolean;
+export declare const commonJsBindingIdentifiers: (name: ts.BindingName) => readonly ts.Identifier[];
+/**
+ * A lexical `var` only aliases Node's wrapper parameter when the compiler has
+ * already classified this source as CommonJS.  Syntax is deliberately not
+ * enough: the same declaration in an `.mjs` file or a `type: module` package
+ * owns a distinct local binding.
+ *
+ * The checker fills `impliedNodeFormat` only under Node16/NodeNext module
+ * resolution; this compiler resolves as a bundler (`program.ts`), so the
+ * field was never set and every source read as "format unknown", which the
+ * rule below answers as "not a wrapper" -- no `var require` in a `type:
+ * commonjs` package ever authenticated. The fact itself does not depend on
+ * the resolution mode: it is the nearest package.json's `type`, or the
+ * `.cjs`/`.mjs` extension, decided exactly as Node's loader decides it. So
+ * the same walk is asked of TypeScript directly, under the one mode that
+ * makes it answer. A file the walk cannot place still answers nothing, and
+ * nothing is never CommonJS.
+ */
+export declare const isCommonJsSourceFile: (file: ts.SourceFile, formats: Map<ts.SourceFile, ts.ResolutionMode>) => boolean;
+/**
+ * The program's source text with every bare top-level `var` redeclaration of
+ * a wrapper name blanked, keyed by resolved file name, for the CommonJS files
+ * that carry one.
+ *
+ * `var require` at the top of a CommonJS module is what Node's own wrapper
+ * makes of it: a function-scoped redeclaration of the wrapper's parameter,
+ * which changes nothing at run time -- the name still holds the loader's
+ * `require`. TypeScript reads the same statement as a module-local `var` with
+ * no initializer and, under `strict`, gives it the evolving type every read
+ * sees as `undefined`: `const load = require; load('./x')` is then TS18048
+ * and TS2722, and `load`'s carrier is typed from nothing. The checker cannot
+ * be told that a local redeclares an outer parameter, so the statement is
+ * blanked before the final program is built: the identifier then resolves to
+ * the host's authenticated global declaration, which is what it names.
+ *
+ * Blanked rather than cut so every other position in the file is unchanged
+ * (`diagnostic-source-preparation.ts` makes the same choice). Only the bare
+ * form qualifies: an initializer is a real write the wrapper identity must
+ * see and refuse, a type annotation is the author's own statement about the
+ * name, an exported declaration is a module's surface, and a `var` inside a
+ * function is a different binding altogether. An ESM file is left alone --
+ * there the `var` is a genuine local the identity layer must NOT authenticate.
+ */
+export declare const withoutBareWrapperRedeclarations: (program: ts.Program, globals: ReadonlySet<string>, prepared: ReadonlyMap<string, string>) => Map<string, string>;
+/**
+ * One authentication result shared by host binding and static-require analysis.
+ * The configured path and declaration spelling establish the host identity;
+ * module-scope `var` declarations may join it only because Node's wrapper has
+ * already introduced that exact parameter cell. No block binding, nested var,
+ * local function, import, or caller-owned ambient declaration is admitted.
+ */
+export declare const createCommonJsWrapperIdentity: (checker: ts.TypeChecker, files: readonly ts.SourceFile[], globals: ReadonlyMap<string, CommonJsWrapperDeclaration>) => {
+    readonly classify: (identifier: ts.Identifier) => CommonJsIdentifierIdentity;
+    readonly globalOfDeclaration: (declaration: ts.Declaration) => CommonJsGlobal | null;
+};