@pixel-point/toolcraft 0.0.15 → 0.0.17

package/templates/starter/scripts/toolcraft-product-boundary.mjs

@@ -1,195 +1,182 @@
 #!/usr/bin/env node
 
 import fs from "node:fs";
-import fsPromises from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { collectToolcraftFrameworkOwnedLocalPaths } from "./toolcraft-source-ownership.mjs";
-import { collectToolcraftSourceInventory } from "./toolcraft-source-inventory.mjs";
+import { createToolcraftPrivateEvidenceImportViolation } from "./toolcraft-product-evidence-import-policy.mjs";
+import { isToolcraftTypeScriptCompilerAvailable } from "./toolcraft-typescript-source-evidence.mjs";
 
 function compareCodeUnits(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
-async function resolveProtectedFilePaths(rootDir, protectedFilePaths) {
-  if (protectedFilePaths) return [...protectedFilePaths];
-
-  return collectToolcraftFrameworkOwnedLocalPaths(rootDir);
-}
-
 export async function evaluateToolcraftProductBoundary({
+  aliases,
   allowMissingCompiler = false,
+  inventory: providedInventory,
+  localDependencyGraph: providedLocalDependencyGraph,
   protectedFilePaths,
   rootDir,
 } = {}) {
   const resolvedRootDir =
     rootDir ?? path.resolve(fileURLToPath(new URL("..", import.meta.url)));
-  const inventory = await collectToolcraftSourceInventory({
-    protectedFilePaths: await resolveProtectedFilePaths(
-      resolvedRootDir,
-      protectedFilePaths,
-    ),
-    rootDir: resolvedRootDir,
-    sourceRoots: ["src", "e2e"],
-  });
-  const productEntries = inventory.entries.filter(
-    (entry) => entry.owner === "product" && entry.role === "production",
-  );
-  const violations = [];
-  let collectToolcraftModuleSpecifiers;
-  let inspectToolcraftProductCss;
-  let inspectToolcraftProductSource;
-  let inspectToolcraftModuleLoading;
-  let inspectToolcraftReservedEvidenceAccess;
-
-  try {
-    ({
-      collectToolcraftModuleSpecifiers,
-      inspectToolcraftProductCss,
-      inspectToolcraftProductSource,
-    } = await import("./toolcraft-product-boundary-ast.mjs"));
-    ({
-      inspectToolcraftModuleLoading,
-      inspectToolcraftReservedEvidenceAccess,
-    } = await import("./toolcraft-product-evidence-boundary-ast.mjs"));
-  } catch (error) {
-    const isMissingTypeScript =
-      error?.code === "ERR_MODULE_NOT_FOUND" &&
-      String(error.message).includes("package 'typescript'");
-    if (!allowMissingCompiler || !isMissingTypeScript) throw error;
-
+  if (!isToolcraftTypeScriptCompilerAvailable()) {
+    if (!allowMissingCompiler) {
+      throw new Error(
+        "TypeScript is required to evaluate the Toolcraft product boundary.",
+      );
+    }
     return {
-      filesystemViolations: inventory.filesystemViolations,
-      productSourceCount: productEntries.length,
+      filesystemViolations: [],
+      productSourceCount: 0,
       skippedReason:
-        "TypeScript is not installed; product AST boundary validation is deferred until dependencies are installed.",
+        "Toolcraft product boundary check passed (dependency-backed graph and AST checks are deferred until dependencies are installed).",
       violations: [],
     };
   }
-
-  const entryByAbsolutePath = new Map(
-    inventory.entries.map((entry) => [path.resolve(entry.absolutePath), entry]),
+  const [
+    { createToolcraftLocalDependencyGraph },
+    dependencyResolution,
+    { collectToolcraftFrameworkOwnedLocalPaths },
+    { collectToolcraftSourceInventory },
+  ] = await Promise.all([
+    import("./toolcraft-local-dependency-graph.mjs"),
+    import("./toolcraft-product-dependency-resolution.mjs"),
+    import("./toolcraft-source-ownership.mjs"),
+    import("./toolcraft-source-inventory.mjs"),
+  ]);
+  const resolvedProtectedFilePaths =
+    protectedFilePaths ??
+    (await collectToolcraftFrameworkOwnedLocalPaths(resolvedRootDir));
+  const inventory =
+    providedInventory ??
+    (await collectToolcraftSourceInventory({
+      includeResourceFiles: true,
+      protectedFilePaths: resolvedProtectedFilePaths,
+      rootDir: resolvedRootDir,
+      sourceRoots: ["src", "e2e"],
+    }));
+  const configuredAliases =
+    aliases ??
+    (await dependencyResolution.loadToolcraftLocalModuleAliases({
+      rootDir: resolvedRootDir,
+      tsconfigPaths: ["tsconfig.json"],
+    }));
+  const localDependencyGraph =
+    providedLocalDependencyGraph ??
+    (await createToolcraftLocalDependencyGraph({
+      aliases: [
+        ...configuredAliases,
+        ...dependencyResolution.createToolcraftDefaultSourceAliases(
+          resolvedRootDir,
+        ),
+      ],
+      entries: inventory.entries,
+      rootDir: resolvedRootDir,
+    }));
+  const productEntries = localDependencyGraph.entries.filter(
+    (entry) =>
+      /^(?:e2e|src)\//u.test(entry.repoPath) &&
+      entry.owner === "product" &&
+      entry.role === "production" &&
+      (dependencyResolution.toolcraftModuleExtensions.includes(
+        path.extname(entry.repoPath),
+      ) ||
+        /\.css$/u.test(entry.repoPath)),
   );
-  const moduleExtensions = [
-    ".ts",
-    ".tsx",
-    ".mts",
-    ".cts",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".css",
-  ];
-
-  function resolveLocalEntry(entry, moduleSpecifier) {
-    let basePath;
-    if (moduleSpecifier.startsWith("@/") || moduleSpecifier.startsWith("#/")) {
-      basePath = path.resolve(resolvedRootDir, "src", moduleSpecifier.slice(2));
-    } else if (moduleSpecifier.startsWith("/")) {
-      basePath = path.resolve(resolvedRootDir, moduleSpecifier.slice(1));
-    } else if (moduleSpecifier.startsWith(".")) {
-      basePath = path.resolve(path.dirname(entry.absolutePath), moduleSpecifier);
-    } else {
-      return {};
-    }
-
-    const candidates = [
-      basePath,
-      ...moduleExtensions.map((extension) => `${basePath}${extension}`),
-      ...moduleExtensions.map((extension) => path.join(basePath, `index${extension}`)),
-    ];
-    const importedEntry = candidates
-      .map((candidate) => entryByAbsolutePath.get(candidate))
-      .find(Boolean);
-    const unscannedSourcePath = importedEntry
-      ? undefined
-      : candidates.find(
-          (candidate) =>
-            moduleExtensions.includes(path.extname(candidate)) &&
-            fs.existsSync(candidate) &&
-            fs.statSync(candidate).isFile(),
-        );
-
-    return { importedEntry, unscannedSourcePath };
+  const violations = [];
+  const entryByRepoPath = new Map(
+    localDependencyGraph.entries.map((entry) => [entry.repoPath, entry]),
+  );
+  const importsByImporter = new Map();
+  for (const evidence of localDependencyGraph.moduleImports) {
+    const importerEvidence = importsByImporter.get(evidence.importerRepoPath) ?? [];
+    importerEvidence.push(evidence);
+    importsByImporter.set(evidence.importerRepoPath, importerEvidence);
   }
+  const appendPrivateEvidenceImportViolations = (entry) => {
+    for (const moduleImport of importsByImporter.get(entry.repoPath) ?? []) {
+      const violation = createToolcraftPrivateEvidenceImportViolation({
+        importerRepoPath: entry.repoPath,
+        moduleImport,
+      });
+      if (violation) violations.push(violation);
+    }
+  };
 
   for (const entry of productEntries) {
+    const sourceRecord = localDependencyGraph.sourceRecords.get(entry.repoPath);
     if (/\.css$/u.test(entry.repoPath)) {
-      violations.push(
-        ...inspectToolcraftProductCss({
-          ...entry,
-          rawSource: await fsPromises.readFile(entry.absolutePath, "utf8"),
-        }),
-      );
+      violations.push(...sourceRecord.cssEvidence.violations);
       continue;
     }
     if (!/\.[cm]?[jt]sx?$/u.test(entry.repoPath)) continue;
-    const rawSource = await fsPromises.readFile(entry.absolutePath, "utf8");
+    const boundaryEvidence = sourceRecord.boundaryEvidence;
+    if (!boundaryEvidence) {
+      throw new Error(
+        `Canonical dependency graph is missing TypeScript boundary evidence for ${entry.repoPath}.`,
+      );
+    }
     violations.push(
-      ...inspectToolcraftProductSource({
-        ...entry,
-        rawSource,
-        rootDir: resolvedRootDir,
-      }),
-      ...inspectToolcraftReservedEvidenceAccess({
-        ...entry,
-        rawSource,
-      }),
+      ...boundaryEvidence.productSourceViolations,
+      ...boundaryEvidence.reservedEvidenceViolations,
+      ...boundaryEvidence.playwrightAuthorityViolations,
     );
-    for (const moduleSpecifier of collectToolcraftModuleSpecifiers({
-      ...entry,
-      rawSource,
-    })) {
-      const { importedEntry, unscannedSourcePath } = resolveLocalEntry(
-        entry,
-        moduleSpecifier,
-      );
-      if (unscannedSourcePath) {
+    appendPrivateEvidenceImportViolations(entry);
+    for (const evidence of importsByImporter.get(entry.repoPath) ?? []) {
+      if (evidence.resolution === "outside-inventory") {
         violations.push({
           column: 1,
           kind: "source-boundary-escape",
           line: 1,
-          message: `Product production source must stay under the scanned src boundary. Move ${path.relative(resolvedRootDir, unscannedSourcePath)} under src before importing it.`,
+          message: `Product production source must stay under the scanned src boundary. Move ${evidence.resolvedRepoPath} under src before importing it.`,
           repoPath: entry.repoPath,
         });
       }
+      const importedEntry = entryByRepoPath.get(evidence.resolvedRepoPath);
       if (
         importedEntry?.role === "test" ||
         importedEntry?.role === "test-support" ||
-        /(?:^|\/)[^/]+\.(?:test|spec)(?:\.[cm]?[jt]sx?)?$/u.test(moduleSpecifier)
+        ((evidence.resolution === "outside-inventory" ||
+          evidence.resolution === "unresolved-local") &&
+          /(?:^|\/)[^/]+\.(?:test|spec)(?:\.[cm]?[jt]sx?)?$/u.test(
+            evidence.specifier,
+          ))
       ) {
         violations.push({
           column: 1,
           kind: "production-test-import",
           line: 1,
-          message: `Production source must not import test or test-support module ${moduleSpecifier}. Move reusable product code into an explicit production module.`,
+          message: `Production source must not import test or test-support module ${evidence.specifier}. Move reusable product code into an explicit production module.`,
           repoPath: entry.repoPath,
         });
       }
     }
   }
 
-  for (const entry of inventory.entries) {
+  for (const entry of localDependencyGraph.entries) {
     if (
+      !/^(?:e2e|src)\//u.test(entry.repoPath) ||
       entry.owner !== "product" ||
       (entry.role !== "test" && entry.role !== "test-support") ||
       !/\.[cm]?[jt]sx?$/u.test(entry.repoPath)
     ) {
       continue;
     }
-    const rawSource = await fsPromises.readFile(entry.absolutePath, "utf8");
+    const sourceRecord = localDependencyGraph.sourceRecords.get(entry.repoPath);
+    const boundaryEvidence = sourceRecord.boundaryEvidence;
+    if (!boundaryEvidence) {
+      throw new Error(
+        `Canonical dependency graph is missing TypeScript boundary evidence for ${entry.repoPath}.`,
+      );
+    }
     violations.push(
-      ...inspectToolcraftReservedEvidenceAccess({
-        ...entry,
-        rawSource,
-      }),
-      ...inspectToolcraftModuleLoading({
-        ...entry,
-        rawSource,
-      }),
+      ...boundaryEvidence.reservedEvidenceViolations,
+      ...boundaryEvidence.playwrightAuthorityViolations,
+      ...boundaryEvidence.moduleLoadingViolations,
     );
+    appendPrivateEvidenceImportViolations(entry);
   }
 
   return {

package/templates/starter/scripts/toolcraft-product-boundary.test.mjs

@@ -101,6 +101,94 @@ test("finds built-in controls through re-exports, aliases, namespaces, and dynam
   );
 });
 
+test("keeps model import, topology, and repair infrastructure runtime-owned", async (context) => {
+  const rootDir = await createFixture(context, {
+    "src/features/direct-loaders.ts": `
+      import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
+      import { FBXLoader } from "three/addons/loaders/FBXLoader.js";
+      void GLTFLoader;
+      void FBXLoader;
+    `,
+    "src/features/gltf-transform.ts": `
+      import { NodeIO } from "@gltf-transform/core";
+      void NodeIO;
+    `,
+    "src/features/runtime-internals.ts": `
+      export { createModelImportCoordinator } from "@/toolcraft/runtime/model-import";
+      export async function loadRepairInternals() {
+        return import("@/toolcraft/runtime/model-import/topology");
+      }
+    `,
+    "src/features/safe-three-renderer.ts": `
+      import { Scene, WebGLRenderer } from "three";
+      export const scene = new Scene();
+      export const rendererType = WebGLRenderer;
+    `,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({ rootDir });
+
+  assert.equal(result.violations.length, 5);
+  assert.equal(
+    result.violations.every(
+      (violation) => violation.kind === "runtime-model-import-ownership",
+    ),
+    true,
+  );
+  assert.equal(
+    result.violations.some((violation) =>
+      violation.repoPath.endsWith("safe-three-renderer.ts"),
+    ),
+    false,
+  );
+});
+
+test("keeps artifact encoding and download mechanics runtime-owned", async (context) => {
+  const rootDir = await createFixture(context, {
+    "src/features/export-mechanics.ts": `
+      import { createToolcraftPngExportCanvas } from "@/toolcraft/runtime";
+      import { Output } from "mediabunny";
+      export function exportArtifact(canvas: HTMLCanvasElement) {
+        const recorder = new MediaRecorder(canvas.captureStream());
+        const encoder = new VideoEncoder({ error() {}, output() {} });
+        canvas.toBlob(() => undefined);
+        canvas.toDataURL();
+        URL.createObjectURL(new Blob());
+        void createToolcraftPngExportCanvas;
+        void Output;
+        void recorder;
+        void encoder;
+      }
+    `,
+    "src/features/safe-renderer.ts": `
+      export const renderFrame = ({ context }) => context.fillRect(0, 0, 1, 1);
+    `,
+    "src/features/shadowed-globals.ts": `
+      export function localNames(MediaRecorder, VideoEncoder, URL) {
+        void new MediaRecorder();
+        void new VideoEncoder();
+        URL.createObjectURL();
+      }
+    `,
+  });
+
+  const result = await evaluateToolcraftProductBoundary({ rootDir });
+
+  assert.equal(result.violations.length, 8);
+  assert.equal(
+    result.violations.every(
+      (violation) => violation.kind === "runtime-export-ownership",
+    ),
+    true,
+  );
+  assert.equal(
+    result.violations.some((violation) =>
+      violation.repoPath.endsWith("shadowed-globals.ts"),
+    ),
+    false,
+  );
+});
+
 test("ignores tests but checks a product bridge imported by production", async (context) => {
   const rootDir = await createFixture(context, {
     "src/features/bridge.ts": `
@@ -259,6 +347,10 @@ test("rejects product source imported from outside the scanned source roots", as
     result.violations.map((violation) => violation.kind),
     ["source-boundary-escape"],
   );
+  assert.match(
+    result.violations[0].message,
+    /Move outside-product\.tsx under src before importing it/u,
+  );
 });
 
 test("rejects global style injection from product JSX", async (context) => {

package/templates/starter/scripts/toolcraft-product-dependency-resolution.mjs

@@ -1,128 +1,36 @@
+import fsSync from "node:fs";
 import fs from "node:fs/promises";
-import { createRequire } from "node:module";
 import path from "node:path";
 
-const require = createRequire(import.meta.url);
-let compilerLoadAttempted = false;
-let typescriptCompiler;
-
-function getTypeScriptCompiler() {
-  if (compilerLoadAttempted) return typescriptCompiler;
-  compilerLoadAttempted = true;
-  try {
-    const importedCompiler = require("typescript");
-    typescriptCompiler = importedCompiler.default ?? importedCompiler;
-  } catch (error) {
-    if (error?.code !== "MODULE_NOT_FOUND") throw error;
-  }
-  return typescriptCompiler;
-}
-
-export function isToolcraftDependencyCompilerAvailable() {
-  return Boolean(getTypeScriptCompiler());
-}
+import { getToolcraftTypeScriptCompiler } from "./toolcraft-typescript-source-evidence.mjs";
 
 export const toolcraftModuleExtensions = [
-  ".ts",
-  ".tsx",
-  ".mts",
-  ".cts",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs",
+  ".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs",
 ];
 
+export function createToolcraftDefaultSourceAliases(rootDir) {
+  return [
+    {
+      match: "@/*",
+      replacement: path.resolve(rootDir, "src/*"),
+    },
+    {
+      match: "#/*",
+      replacement: path.resolve(rootDir, "src/*"),
+    },
+  ];
+}
+
 const javascriptToTypeScriptExtensions = new Map([
   [".js", [".ts", ".tsx"]],
   [".jsx", [".tsx", ".ts"]],
-  [".mjs", [".mts"]],
-  [".cjs", [".cts"]],
+  [".mjs", [".mts"]], [".cjs", [".cts"]],
 ]);
 
 function compareCodeUnits(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
-function scriptKind(filePath, ts) {
-  if (/\.tsx$/iu.test(filePath)) return ts.ScriptKind.TSX;
-  if (/\.jsx$/iu.test(filePath)) return ts.ScriptKind.JSX;
-  if (/\.[cm]?js$/iu.test(filePath)) return ts.ScriptKind.JS;
-  return ts.ScriptKind.TS;
-}
-
-function importDeclarationIsTypeOnly(node, ts) {
-  const clause = node.importClause;
-  if (!clause) return false;
-  if (clause.isTypeOnly) return true;
-  if (clause.name || !clause.namedBindings) return false;
-  return (
-    ts.isNamedImports(clause.namedBindings) &&
-    clause.namedBindings.elements.length > 0 &&
-    clause.namedBindings.elements.every((element) => element.isTypeOnly)
-  );
-}
-
-function exportDeclarationIsTypeOnly(node, ts) {
-  if (node.isTypeOnly) return true;
-  return (
-    node.exportClause &&
-    ts.isNamedExports(node.exportClause) &&
-    node.exportClause.elements.length > 0 &&
-    node.exportClause.elements.every((element) => element.isTypeOnly)
-  );
-}
-
-export function collectToolcraftStaticModuleSpecifiers(filePath, source) {
-  const ts = getTypeScriptCompiler();
-  if (!ts) return [];
-  const sourceFile = ts.createSourceFile(
-    filePath,
-    source,
-    ts.ScriptTarget.Latest,
-    true,
-    scriptKind(filePath, ts),
-  );
-  const specifiers = new Set();
-
-  function visit(node) {
-    if (
-      ts.isImportDeclaration(node) &&
-      !importDeclarationIsTypeOnly(node, ts) &&
-      ts.isStringLiteralLike(node.moduleSpecifier)
-    ) {
-      specifiers.add(node.moduleSpecifier.text);
-    } else if (
-      ts.isExportDeclaration(node) &&
-      !exportDeclarationIsTypeOnly(node, ts) &&
-      node.moduleSpecifier &&
-      ts.isStringLiteralLike(node.moduleSpecifier)
-    ) {
-      specifiers.add(node.moduleSpecifier.text);
-    } else if (
-      ts.isImportEqualsDeclaration(node) &&
-      !node.isTypeOnly &&
-      ts.isExternalModuleReference(node.moduleReference) &&
-      node.moduleReference.expression &&
-      ts.isStringLiteralLike(node.moduleReference.expression)
-    ) {
-      specifiers.add(node.moduleReference.expression.text);
-    } else if (
-      ts.isCallExpression(node) &&
-      node.arguments.length === 1 &&
-      ts.isStringLiteralLike(node.arguments[0]) &&
-      (node.expression.kind === ts.SyntaxKind.ImportKeyword ||
-        (ts.isIdentifier(node.expression) && node.expression.text === "require"))
-    ) {
-      specifiers.add(node.arguments[0].text);
-    }
-    ts.forEachChild(node, visit);
-  }
-
-  visit(sourceFile);
-  return [...specifiers].sort(compareCodeUnits);
-}
-
 function getExportTarget(value) {
   if (typeof value === "string") return value;
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
@@ -150,7 +58,7 @@ export async function loadToolcraftLocalModuleAliases({
   tsconfigPaths = [],
 }) {
   const aliases = [];
-  const ts = getTypeScriptCompiler();
+  const ts = getToolcraftTypeScriptCompiler();
   if (ts) {
     for (const configEntry of tsconfigPaths) {
       const relativeConfigPath =
@@ -235,11 +143,35 @@ function aliasCandidates(specifier, importerRepoPath, aliases) {
   return candidates;
 }
 
-function resolveModuleCandidate(basePath, entryByAbsolutePath) {
+function cleanModuleSpecifier(specifier) {
+  const withoutQuery = specifier.replace(/\?.*$/u, "");
+  return withoutQuery.startsWith("#")
+    ? withoutQuery
+    : withoutQuery.replace(/#.*$/u, "");
+}
+
+export function isToolcraftLocalDependencySpecifier({
+  aliases,
+  importer,
+  specifier,
+}) {
+  const cleanSpecifier = cleanModuleSpecifier(specifier);
+  return (
+    cleanSpecifier.startsWith(".") ||
+    cleanSpecifier.startsWith("/") ||
+    aliasCandidates(cleanSpecifier, importer.repoPath, aliases).length > 0
+  );
+}
+
+function resolveModuleCandidate(
+  basePath,
+  entryByAbsolutePath,
+  { allowUnscanned = false, unscannedExtensions = toolcraftModuleExtensions } = {},
+) {
   const normalizedBase = path.resolve(basePath);
   const candidates = [normalizedBase];
   const extension = path.extname(normalizedBase);
-  if (!extension) {
+  if (!toolcraftModuleExtensions.includes(extension)) {
     candidates.push(
       ...toolcraftModuleExtensions.map((item) => `${normalizedBase}${item}`),
       ...toolcraftModuleExtensions.map((item) =>
@@ -251,20 +183,28 @@ function resolveModuleCandidate(basePath, entryByAbsolutePath) {
       candidates.push(`${normalizedBase.slice(0, -extension.length)}${replacement}`);
     }
   }
-  return candidates.find((candidate) => entryByAbsolutePath.has(candidate));
+  const inventoriedCandidate = candidates.find((candidate) =>
+    entryByAbsolutePath.has(candidate),
+  );
+  if (inventoriedCandidate || !allowUnscanned) return inventoriedCandidate;
+  return candidates.find(
+    (candidate) =>
+      unscannedExtensions.includes(path.extname(candidate)) &&
+      fsSync.existsSync(candidate) &&
+      fsSync.statSync(candidate).isFile(),
+  );
 }
 
 export function resolveToolcraftLocalDependency({
   aliases,
+  allowUnscanned = false,
   entryByAbsolutePath,
   importer,
   rootDir,
   specifier,
+  unscannedExtensions,
 }) {
-  const withoutQuery = specifier.replace(/\?.*$/u, "");
-  const cleanSpecifier = withoutQuery.startsWith("#")
-    ? withoutQuery
-    : withoutQuery.replace(/#.*$/u, "");
+  const cleanSpecifier = cleanModuleSpecifier(specifier);
   const baseCandidates = cleanSpecifier.startsWith(".")
     ? [path.resolve(path.dirname(importer.absolutePath), cleanSpecifier)]
     : cleanSpecifier.startsWith("/")
@@ -272,7 +212,10 @@ export function resolveToolcraftLocalDependency({
       : aliasCandidates(cleanSpecifier, importer.repoPath, aliases);
 
   for (const basePath of baseCandidates) {
-    const resolved = resolveModuleCandidate(basePath, entryByAbsolutePath);
+    const resolved = resolveModuleCandidate(basePath, entryByAbsolutePath, {
+      allowUnscanned,
+      unscannedExtensions,
+    });
     if (resolved) return resolved;
   }
   return undefined;