Files
reverse-engineering-anything/src/domain/javascript/javascriptSemanticRequireOriginSlot.ts
T
morlutoandShuaixinHuang b46f4fcebd fix(javascript): preserve loader authority for exact suffixes (#9477)
* fix(javascript): require exact loader suffix case

* fix(javascript): share exact loader mode across import resolution

* test(process): align symlink fixture with filesystem checkpoints

* test(javascript): normalize the module resolution oracle path separators

* test(frida): assert the CLI spawn Evidence contract

* test(mcp): use an unsupported analysis-view parent

* test(browser): separate source-location line bounds from parity

* fix(javascript): preserve uncertain loader provenance

* test(javascript): cover uncertain require resolution

* fix(javascript): retain conditional Electron evidence

* fix(javascript): preserve timed semantic provenance

* fix(javascript): retain conditional builtin effects

* test(javascript): distinguish bundled host authority

* fix(javascript): preserve nested loader invocation identity

* test(javascript): qualify Electron fixture authority

* fix(javascript): preserve loader invocation authority

* fix(javascript): respect source order for resolver escapes

* fix(javascript): check nested loader callable mutations

* fix(javascript): retain conditional constructor requests

* fix(reference): retain constructor loader relationships

* fix(reference): follow nested loader callable paths

* refactor(javascript): share callable mutation interpretation

* fix(javascript): require exact package loader suffixes

* refactor(javascript): unify conditional relation evidence

* refactor(javascript): unify conditional node evidence

* fix(javascript): retain unknown authority for mixed case sources

* fix(javascript): preserve loader uncertainty for dotfiles

* fix(reference): classify javascript suffix dotfiles

* test(reference): cover suffix dotfiles through cli

* fix(javascript): retain equivalent conditional built-in origins

* fix(javascript): preserve wrapped resolver operation

* fix(javascript): retain nested conditional built-in receivers

* test(javascript): declare CommonJS in native addon fixtures

* fix(javascript): retain wrapped resolver candidates

* style: format merged native command schema

* fix(javascript): preserve uncertain loader authority

* test(javascript): require candidate preload evidence

* test(javascript): cover reference loader member writes

---------

Co-authored-by: ShuaixinHuang <1836656514@qq.com>
2026-11-09 13:21:24 +08:00

56 lines
1.9 KiB
TypeScript

import type * as t from "@babel/types";
import type { JavaScriptModuleOrigin } from "./javascriptSemanticIr.js";
import type { JavaScriptSemanticAnalysisState } from "./javascriptSemanticState.js";
/** An unshadowed literal require and the member path selected from its result. */
export interface JavaScriptRequireOrigin {
readonly origin: JavaScriptModuleOrigin;
readonly call: t.CallExpression | t.OptionalCallExpression;
}
export type JavaScriptRequireLoaderFact =
| "commonjs-loader"
| "factory-loader"
| "create-require"
| "local"
| "unknown";
type RequireOriginReader = (
node: t.Node | null | undefined,
state: JavaScriptSemanticAnalysisState,
) => JavaScriptRequireOrigin | undefined;
type RequireLoaderReader = (
node: t.CallExpression | t.OptionalCallExpression | t.NewExpression,
state: JavaScriptSemanticAnalysisState,
factoryBindingIds: ReadonlySet<string>,
) => JavaScriptRequireLoaderFact;
/**
* Require-origin queries are owned by javascriptSemanticRequireOrigin.ts, which
* also depends on evaluation. Lower layers read them through this slot so the
* import edge stays one way. The owner assigns both readers when it loads.
*/
export const semanticRequireOriginReaders: {
origin: RequireOriginReader | undefined;
candidate: RequireOriginReader | undefined;
loader: RequireLoaderReader | undefined;
} = { origin: undefined, candidate: undefined, loader: undefined };
export const readSemanticRequireOrigin: RequireOriginReader = (node, state) =>
semanticRequireOriginReaders.origin?.(node, state);
/** Includes conditional requests whose unbound wrapper is not established. */
export const readSemanticRequireOriginCandidate: RequireOriginReader = (
node,
state,
) => semanticRequireOriginReaders.candidate?.(node, state);
export const readSemanticRequireLoader: RequireLoaderReader = (
node,
state,
factoryBindingIds,
) =>
semanticRequireOriginReaders.loader?.(node, state, factoryBindingIds) ??
"unknown";