@simplysm/sd-cli 12.15.39 → 12.15.41

package/dist/pkg-builders/client/SdNgBundlerContext.d.ts

@@ -8,10 +8,11 @@ interface InitialFileRecord {
     depth: number;
 }
 export declare class SdNgBundlerContext {
-    #private;
     private readonly _pkgPath;
     private readonly _watch;
     private readonly _esbuildOptions;
+    private readonly _logger;
+    private _context?;
     constructor(_pkgPath: string, _watch: boolean, _esbuildOptions: esbuild.BuildOptions);
     bundleAsync(): Promise<{
         results: import("../../types/build/ISdBuildMessage").ISdBuildMessage[];
@@ -19,5 +20,6 @@ export declare class SdNgBundlerContext {
         outputFiles: esbuild.OutputFile[] | undefined;
         metafile: esbuild.Metafile | undefined;
     }>;
+    private _debug;
 }
 export {};

package/dist/pkg-builders/client/SdNgBundlerContext.js

@@ -3,22 +3,21 @@ import path from "path";
 import { SdLogger } from "@simplysm/sd-core-node";
 import { SdCliConvertMessageUtils } from "../../utils/SdCliConvertMessageUtils";
 export class SdNgBundlerContext {
-    #logger = SdLogger.get(["simplysm", "sd-cli", "SdNgBundlerContext"]);
-    #context;
     constructor(_pkgPath, _watch, _esbuildOptions) {
         this._pkgPath = _pkgPath;
         this._watch = _watch;
         this._esbuildOptions = _esbuildOptions;
+        this._logger = SdLogger.get(["simplysm", "sd-cli", "SdNgBundlerContext"]);
     }
     async bundleAsync() {
         let esbuildResult;
-        this.#debug(`Building...`);
+        this._debug(`Building...`);
         if (this._watch) {
-            if (this.#context == null) {
-                this.#context = await esbuild.context(this._esbuildOptions);
+            if (this._context == null) {
+                this._context = await esbuild.context(this._esbuildOptions);
             }
             try {
-                esbuildResult = await this.#context.rebuild();
+                esbuildResult = await this._context.rebuild();
             }
             catch (err) {
                 if ("warnings" in err || "errors" in err) {
@@ -42,8 +41,8 @@ export class SdNgBundlerContext {
                 }
             }
         }
-        this.#debug(`Build completed`);
-        this.#debug(`Converting results...`);
+        this._debug(`Build completed`);
+        this._debug(`Converting results...`);
         const results = SdCliConvertMessageUtils.convertToBuildMessagesFromEsbuild(esbuildResult, this._pkgPath);
         const initialFiles = new Map();
         for (const outputFile of esbuildResult.outputFiles ?? []) {
@@ -99,7 +98,7 @@ export class SdNgBundlerContext {
             metafile: esbuildResult.metafile,
         };
     }
-    #debug(...msg) {
-        this.#logger.debug(`[${path.basename(this._pkgPath)}] (${Object.keys(this._esbuildOptions.entryPoints).join(", ")})`, ...msg);
+    _debug(...msg) {
+        this._logger.debug(`[${path.basename(this._pkgPath)}] (${Object.keys(this._esbuildOptions.entryPoints).join(", ")})`, ...msg);
     }
 }

package/dist/pkg-builders/lib/SdCliIndexFileGenerator.d.ts

@@ -1,5 +1,4 @@
 export declare class SdCliIndexFileGenerator {
-    #private;
     cachedHash?: string;
     watchAsync(pkgPath: string, polyfills?: string[], excludes?: string[]): Promise<void>;
     runAsync(pkgPath: string, polyfills?: string[], excludes?: string[]): Promise<{
@@ -7,4 +6,6 @@ export declare class SdCliIndexFileGenerator {
         filePath: string;
         content: string;
     }>;
+    private _getFilePathsAsync;
+    private _getExcludesAsync;
 }

package/dist/pkg-builders/lib/SdCliIndexFileGenerator.js

@@ -7,7 +7,7 @@ export class SdCliIndexFileGenerator {
             ? HashUtils.get(await FsUtils.readFileAsync(indexFilePath))
             : undefined;
         const watcher = await SdFsWatcher.watchAsync([path.resolve(pkgPath, "src")], {
-            ignored: await this.#getExcludesAsync(pkgPath, excludes),
+            ignored: await this._getExcludesAsync(pkgPath, excludes),
         });
         watcher.onChange({ delay: 50 }, async (changeInfos) => {
             if (changeInfos.some((item) => ["add", "addDir", "unlink", "unlinkDir"].includes(item.event)))
@@ -25,7 +25,7 @@ export class SdCliIndexFileGenerator {
             }
         }
         // 내부 파일들 import
-        const filePaths = await this.#getFilePathsAsync(pkgPath, excludes);
+        const filePaths = await this._getFilePathsAsync(pkgPath, excludes);
         for (const filePath of filePaths.orderBy()) {
             const requirePath = PathUtils.posix(path.relative(path.dirname(indexFilePath), filePath))
                 .replace(/\.tsx?$/, "")
@@ -49,7 +49,7 @@ export class SdCliIndexFileGenerator {
             return { changed: false, filePath: indexFilePath, content };
         }
     }
-    async #getFilePathsAsync(pkgPath, excludes) {
+    async _getFilePathsAsync(pkgPath, excludes) {
         /*const indexFilePath = path.resolve(pkgPath, "src/index.ts");
     
         const tsconfig = await FsUtils.readJsonAsync(path.resolve(pkgPath, "tsconfig.json"));
@@ -57,10 +57,10 @@ export class SdCliIndexFileGenerator {
           tsconfig.files?.map((item) => path.resolve(pkgPath, item)) ?? [];*/
         return await FsUtils.globAsync(path.resolve(pkgPath, "src/**/*{.ts,.tsx}"), {
             nodir: true,
-            ignore: await this.#getExcludesAsync(pkgPath, excludes),
+            ignore: await this._getExcludesAsync(pkgPath, excludes),
         });
     }
-    async #getExcludesAsync(pkgPath, excludes) {
+    async _getExcludesAsync(pkgPath, excludes) {
         const indexFilePath = path.resolve(pkgPath, "src/index.ts");
         const tsconfig = await FsUtils.readJsonAsync(path.resolve(pkgPath, "tsconfig.json"));
         return [

package/dist/pkg-builders/lib/SdJsLibBuildRunner.d.ts

@@ -2,7 +2,7 @@ import { SdLogger, TNormPath } from "@simplysm/sd-core-node";
 import { SdBuildRunnerBase } from "../SdBuildRunnerBase";
 import { ISdBuildResult } from "../../types/build/ISdBuildResult";
 export declare class SdJsLibBuildRunner extends SdBuildRunnerBase<"library"> {
-    #private;
     protected _logger: SdLogger;
     protected _runAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult>;
+    private _lintAsync;
 }

package/dist/pkg-builders/lib/SdJsLibBuildRunner.js

@@ -20,7 +20,7 @@ export class SdJsLibBuildRunner extends SdBuildRunnerBase {
         const filePathSet = modifiedFileSet ??
             new Set(FsUtils.glob(path.resolve(this._opt.pkgPath, "src/**/*.js")).map((item) => PathUtils.norm(item)));
         this._debug("LINT...");
-        const lintResults = await this.#lintAsync(filePathSet);
+        const lintResults = await this._lintAsync(filePathSet);
         const messages = SdCliConvertMessageUtils.convertToBuildMessagesFromEslint(lintResults);
         this._debug(`LINT 완료`);
         return {
@@ -30,7 +30,7 @@ export class SdJsLibBuildRunner extends SdBuildRunnerBase {
             emitFileSet: new Set(),
         };
     }
-    async #lintAsync(fileSet) {
+    async _lintAsync(fileSet) {
         const lintFilePaths = Array.from(fileSet)
             .filter((item) => PathUtils.isChildPath(item, path.resolve(this._opt.pkgPath, "src")))
             .filter((item) => item.endsWith(".js"))

package/dist/pkg-builders/lib/SdTsLibBuildRunner.d.ts

@@ -2,7 +2,7 @@ import { SdLogger, TNormPath } from "@simplysm/sd-core-node";
 import { SdBuildRunnerBase } from "../SdBuildRunnerBase";
 import { ISdBuildResult } from "../../types/build/ISdBuildResult";
 export declare class SdTsLibBuildRunner extends SdBuildRunnerBase<"library"> {
-    #private;
     protected _logger: SdLogger;
+    private _builder?;
     protected _runAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult>;
 }

package/dist/pkg-builders/lib/SdTsLibBuildRunner.js

@@ -8,7 +8,6 @@ export class SdTsLibBuildRunner extends SdBuildRunnerBase {
         super(...arguments);
         this._logger = SdLogger.get(["simplysm", "sd-cli", "SdTsLibBuildRunner"]);
     }
-    #builder;
     async _runAsync(modifiedFileSet) {
         // 최초한번
         if (!modifiedFileSet) {
@@ -25,10 +24,10 @@ export class SdTsLibBuildRunner extends SdBuildRunnerBase {
                 }
             }
             this._debug(`BUILD 준비...`);
-            this.#builder = new SdTsLibBuilder(this._opt);
+            this._builder = new SdTsLibBuilder(this._opt);
         }
         this._debug(`BUILD...`);
-        const buildResult = await this.#builder.buildAsync(modifiedFileSet);
+        const buildResult = await this._builder.buildAsync(modifiedFileSet);
         this._debug(`빌드 완료`);
         return buildResult;
     }

package/dist/pkg-builders/lib/SdTsLibBuilder.d.ts

@@ -2,8 +2,9 @@ import { TNormPath } from "@simplysm/sd-core-node";
 import { ISdBuildResult } from "../../types/build/ISdBuildResult";
 import { ISdTsCompilerOptions } from "../../types/build/ISdTsCompilerOptions";
 export declare class SdTsLibBuilder {
-    #private;
     private readonly _opt;
+    private readonly _tsCompiler;
+    private readonly _outputHashCache;
     constructor(_opt: ISdTsCompilerOptions);
     buildAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult>;
 }

package/dist/pkg-builders/lib/SdTsLibBuilder.js

@@ -3,14 +3,13 @@ import { SdCliConvertMessageUtils } from "../../utils/SdCliConvertMessageUtils";
 import { FsUtils, HashUtils, PathUtils } from "@simplysm/sd-core-node";
 import { SdTsCompiler } from "../../ts-compiler/SdTsCompiler";
 export class SdTsLibBuilder {
-    #tsCompiler;
-    #outputHashCache = new Map();
     constructor(_opt) {
         this._opt = _opt;
-        this.#tsCompiler = new SdTsCompiler(_opt, false);
+        this._outputHashCache = new Map();
+        this._tsCompiler = new SdTsCompiler(_opt, false);
     }
     async buildAsync(modifiedFileSet) {
-        const tsCompileResult = await this.#tsCompiler.compileAsync(modifiedFileSet ?? new Set());
+        const tsCompileResult = await this._tsCompiler.compileAsync(modifiedFileSet ?? new Set());
         const emitFileSet = new Set();
         for (const emitFile of tsCompileResult.emitFileSet) {
             const emitFileInfos = tsCompileResult.emittedFilesCacheMap.get(emitFile);
@@ -18,11 +17,11 @@ export class SdTsLibBuilder {
                 for (const emitFileInfo of emitFileInfos) {
                     if (emitFileInfo.outAbsPath != null) {
                         const emitFilePath = PathUtils.norm(emitFileInfo.outAbsPath);
-                        const prevHash = this.#outputHashCache.get(emitFilePath);
+                        const prevHash = this._outputHashCache.get(emitFilePath);
                         const currHash = HashUtils.get(Buffer.from(emitFileInfo.text));
                         if (prevHash !== currHash) {
                             FsUtils.writeFile(emitFilePath, emitFileInfo.text);
-                            this.#outputHashCache.set(emitFilePath, currHash);
+                            this._outputHashCache.set(emitFilePath, currHash);
                             emitFileSet.add(emitFilePath);
                         }
                     }
@@ -33,11 +32,11 @@ export class SdTsLibBuilder {
                 for (const outputFile of globalStylesheetBundlingResult.outputFiles) {
                     const distPath = PathUtils.norm(this._opt.pkgPath, "dist", path.relative(this._opt.pkgPath, outputFile.path));
                     if (PathUtils.isChildPath(distPath, path.resolve(this._opt.pkgPath, "dist"))) {
-                        const prevHash = this.#outputHashCache.get(distPath);
+                        const prevHash = this._outputHashCache.get(distPath);
                         const currHash = HashUtils.get(Buffer.from(outputFile.text));
                         if (prevHash !== currHash) {
                             FsUtils.writeFile(distPath, outputFile.text);
-                            this.#outputHashCache.set(distPath, currHash);
+                            this._outputHashCache.set(distPath, currHash);
                             emitFileSet.add(distPath);
                         }
                     }

package/dist/pkg-builders/server/SdServerBuildRunner.d.ts

@@ -2,7 +2,9 @@ import { SdLogger, TNormPath } from "@simplysm/sd-core-node";
 import { SdBuildRunnerBase } from "../SdBuildRunnerBase";
 import { ISdBuildResult } from "../../types/build/ISdBuildResult";
 export declare class SdServerBuildRunner extends SdBuildRunnerBase<"server"> {
-    #private;
     protected _logger: SdLogger;
+    private _serverBundler?;
     protected _runAsync(modifiedFileSet?: Set<TNormPath>): Promise<ISdBuildResult>;
+    private _generateProductionFiles;
+    private _getExternalModules;
 }

package/dist/pkg-builders/server/SdServerBuildRunner.js

@@ -8,13 +8,12 @@ export class SdServerBuildRunner extends SdBuildRunnerBase {
         super(...arguments);
         this._logger = SdLogger.get(["simplysm", "sd-cli", "SdServerBuildRunner"]);
     }
-    #serverBundler;
     async _runAsync(modifiedFileSet) {
         // 최초
         if (!modifiedFileSet) {
-            const externalModules = this.#getExternalModules();
+            const externalModules = this._getExternalModules();
             if (!this._opt.watch?.dev) {
-                this.#generateProductionFiles(externalModules.filter((item) => item.exists).map((item) => item.name));
+                this._generateProductionFiles(externalModules.filter((item) => item.exists).map((item) => item.name));
             }
             if (!this._opt.watch?.noEmit) {
                 this._debug("GEN .config...");
@@ -22,16 +21,16 @@ export class SdServerBuildRunner extends SdBuildRunnerBase {
                 FsUtils.writeFile(confDistPath, JSON.stringify(this._pkgConf.configs ?? {}, undefined, 2));
             }
             this._debug(`BUILD 준비...`);
-            this.#serverBundler = new SdServerBundler(this._opt, {
+            this._serverBundler = new SdServerBundler(this._opt, {
                 external: externalModules.map((item) => item.name),
             });
         }
         this._debug(`BUILD...`);
-        const bundleResult = await this.#serverBundler.bundleAsync(modifiedFileSet);
+        const bundleResult = await this._serverBundler.bundleAsync(modifiedFileSet);
         this._debug(`빌드 완료`);
         return bundleResult;
     }
-    #generateProductionFiles(externals) {
+    _generateProductionFiles(externals) {
         const npmConf = FsUtils.readJson(path.resolve(this._opt.pkgPath, "package.json"));
         this._debug("GEN package.json...");
         {
@@ -150,7 +149,7 @@ Options = UnsafeLegacyRenegotiation`.trim());
 </configuration>`.trim());
         }
     }
-    #getExternalModules() {
+    _getExternalModules() {
         const loadedModuleNames = [];
         const results = [];
         const npmConfigMap = new Map();

package/dist/pkg-builders/server/SdServerBundler.d.ts

@@ -2,9 +2,14 @@ import { TNormPath } from "@simplysm/sd-core-node";
 import { ISdBuildResult } from "../../types/build/ISdBuildResult";
 import { ISdTsCompilerOptions } from "../../types/build/ISdTsCompilerOptions";
 export declare class SdServerBundler {
-    #private;
     private readonly _opt;
     private readonly _conf;
+    private readonly _logger;
+    private _context?;
+    private readonly _modifiedFileSet;
+    private readonly _resultCache;
+    private readonly _outputHashCache;
+    private readonly _esbuildOptions;
     constructor(_opt: ISdTsCompilerOptions, _conf: {
         external: string[];
     });

package/dist/pkg-builders/server/SdServerBundler.js

@@ -8,16 +8,14 @@ import { convertOutputFile } from "@angular/build/src/tools/esbuild/utils";
 import { resolveAssets } from "@angular/build/src/utils/resolve-assets";
 import { SdWorkerPathPlugin } from "../commons/SdWorkerPathPlugin";
 export class SdServerBundler {
-    #logger = SdLogger.get(["simplysm", "sd-cli", "SdServerBundler"]);
-    #context;
-    #modifiedFileSet = new Set();
-    #resultCache = {};
-    #outputHashCache = new Map();
-    #esbuildOptions;
     constructor(_opt, _conf) {
         this._opt = _opt;
         this._conf = _conf;
-        this.#esbuildOptions = {
+        this._logger = SdLogger.get(["simplysm", "sd-cli", "SdServerBundler"]);
+        this._modifiedFileSet = new Set();
+        this._resultCache = {};
+        this._outputHashCache = new Map();
+        this._esbuildOptions = {
             entryPoints: [
                 path.resolve(this._opt.pkgPath, "src/main.ts"),
                 // ...FsUtils.glob(path.resolve(this._opt.pkgPath, "src/workers/*.ts")),
@@ -80,23 +78,23 @@ const __filename = __fileURLToPath__(import.meta.url);
 const __dirname = __path__.dirname(__filename);`.trim(),
             },
             plugins: [
-                createSdServerPlugin(this._opt, this.#modifiedFileSet, this.#resultCache),
+                createSdServerPlugin(this._opt, this._modifiedFileSet, this._resultCache),
                 SdWorkerPathPlugin(path.resolve(this._opt.pkgPath, "dist")),
             ],
         };
     }
     async bundleAsync(modifiedFileSet) {
-        this.#modifiedFileSet.clear();
+        this._modifiedFileSet.clear();
         if (modifiedFileSet) {
-            this.#modifiedFileSet.adds(...modifiedFileSet);
+            this._modifiedFileSet.adds(...modifiedFileSet);
         }
         let esbuildResult;
         if (this._opt.watch) {
-            if (this.#context == null) {
-                this.#context = await esbuild.context(this.#esbuildOptions);
+            if (this._context == null) {
+                this._context = await esbuild.context(this._esbuildOptions);
             }
             try {
-                esbuildResult = await this.#context.rebuild();
+                esbuildResult = await this._context.rebuild();
             }
             catch (err) {
                 if ("warnings" in err || "errors" in err) {
@@ -109,7 +107,7 @@ const __dirname = __path__.dirname(__filename);`.trim(),
         }
         else {
             try {
-                esbuildResult = await esbuild.build(this.#esbuildOptions);
+                esbuildResult = await esbuild.build(this._esbuildOptions);
             }
             catch (err) {
                 if ("warnings" in err || "errors" in err) {
@@ -123,8 +121,8 @@ const __dirname = __path__.dirname(__filename);`.trim(),
         if (this._opt.watch?.noEmit) {
             return {
                 buildMessages: SdCliConvertMessageUtils.convertToBuildMessagesFromEsbuild(esbuildResult, this._opt.pkgPath),
-                watchFileSet: this.#resultCache.watchFileSet,
-                affectedFileSet: this.#resultCache.affectedFileSet,
+                watchFileSet: this._resultCache.watchFileSet,
+                affectedFileSet: this._resultCache.affectedFileSet,
                 emitFileSet: new Set(),
             };
         }
@@ -134,11 +132,11 @@ const __dirname = __path__.dirname(__filename);`.trim(),
                 const outputFiles = esbuildResult.outputFiles?.map((file) => convertOutputFile(file, BuildOutputFileType.Root)) ?? [];
                 for (const outputFile of outputFiles) {
                     const distFilePath = PathUtils.norm(this._opt.pkgPath, outputFile.path);
-                    const prevHash = this.#outputHashCache.get(distFilePath);
+                    const prevHash = this._outputHashCache.get(distFilePath);
                     const currHash = HashUtils.get(Buffer.from(outputFile.contents));
                     if (prevHash !== currHash) {
                         FsUtils.writeFile(distFilePath, outputFile.contents);
-                        this.#outputHashCache.set(distFilePath, currHash);
+                        this._outputHashCache.set(distFilePath, currHash);
                         emitFileSet.add(distFilePath);
                     }
                 }
@@ -148,11 +146,11 @@ const __dirname = __path__.dirname(__filename);`.trim(),
                     ...(this._opt.watch?.dev ? [{ input: "public-dev", glob: "**/*", output: "." }] : []),
                 ], this._opt.pkgPath);
                 for (const assetFile of assetFiles) {
-                    const prevHash = this.#outputHashCache.get(PathUtils.norm(assetFile.source));
+                    const prevHash = this._outputHashCache.get(PathUtils.norm(assetFile.source));
                     const currHash = HashUtils.get(FsUtils.readFileBuffer(assetFile.source));
                     if (prevHash !== currHash) {
                         FsUtils.copy(assetFile.source, path.resolve(this._opt.pkgPath, "dist", assetFile.destination));
-                        this.#outputHashCache.set(PathUtils.norm(assetFile.source), currHash);
+                        this._outputHashCache.set(PathUtils.norm(assetFile.source), currHash);
                         emitFileSet.add(PathUtils.norm(this._opt.pkgPath, "dist", assetFile.destination));
                     }
                 }
@@ -161,14 +159,14 @@ const __dirname = __path__.dirname(__filename);`.trim(),
                 esbuildResult = err;
                 for (const e of err.errors) {
                     if (e.detail != null) {
-                        this.#logger.error(e.detail);
+                        this._logger.error(e.detail);
                     }
                 }
             }
             return {
                 buildMessages: SdCliConvertMessageUtils.convertToBuildMessagesFromEsbuild(esbuildResult, this._opt.pkgPath),
-                watchFileSet: this.#resultCache.watchFileSet,
-                affectedFileSet: this.#resultCache.affectedFileSet,
+                watchFileSet: this._resultCache.watchFileSet,
+                affectedFileSet: this._resultCache.affectedFileSet,
                 emitFileSet: emitFileSet,
             };
         }

package/dist/ts-compiler/ScopePathSet.d.ts

@@ -1,6 +1,6 @@
 import { TNormPath } from "@simplysm/sd-core-node";
 export declare class ScopePathSet {
-    #private;
+    private readonly _data;
     constructor(arrOrSet?: TNormPath[] | Set<TNormPath>);
     inScope(filePath: string): boolean;
     toArray(): TNormPath[];

package/dist/ts-compiler/ScopePathSet.js

@@ -1,13 +1,12 @@
 import { PathUtils } from "@simplysm/sd-core-node";
 export class ScopePathSet {
-    #data;
     constructor(arrOrSet) {
-        this.#data = arrOrSet instanceof Set ? arrOrSet : new Set(arrOrSet);
+        this._data = arrOrSet instanceof Set ? arrOrSet : new Set(arrOrSet);
     }
     inScope(filePath) {
-        return Array.from(this.#data).some((scope) => PathUtils.isChildPath(filePath, scope));
+        return Array.from(this._data).some((scope) => PathUtils.isChildPath(filePath, scope));
     }
     toArray() {
-        return Array.from(this.#data);
+        return Array.from(this._data);
     }
 }

package/dist/ts-compiler/SdDepCache.d.ts

@@ -1,6 +1,38 @@
 import { TNormPath } from "@simplysm/sd-core-node";
 export declare class SdDepCache {
-    #private;
+    /**
+     * 각 파일이 export한 심볼 집합 (예: export const A → "A")
+     */
+    private readonly _exportCache;
+    /**
+     * import한 타겟과 그 심볼 정보
+     * - 값이 0이면 전체 import(import * 또는 리소스 import)
+     * - 값이 Set이면 선택적 심볼 import (예: import { A } ...)
+     */
+    private readonly _importCache;
+    /**
+     * re-export한 타겟과 그 심볼 정보
+     * - export * from ...
+     * - export { A as B } from ...
+     * - 값이 0이면 전체 reexport(export * from ...)
+     */
+    private readonly _reexportCache;
+    /**
+     * 역의존 정보 (revDep)
+     * - 특정 파일이 어떤 파일에게 의존(참조)되는지
+     * - symbol 기반 추적
+     */
+    private readonly _revDepCache;
+    /**
+     * 분석이 완료된 파일 경로
+     */
+    private readonly _collectedCache;
+    private readonly _exportSymbolCache;
+    /**
+     * .d.ts 또는 .js가 입력되었을 때 쌍으로 존재하는 파일 경로를 반환
+     * 예: "/a.d.ts" → ["/a.d.ts", "/a.js"]
+     */
+    private _getRelatedNPaths;
     /**
      * 분석이 완료된 파일로 표시
      */
@@ -25,9 +57,21 @@ export declare class SdDepCache {
         importSymbol: string;
         exportSymbol: string;
     } | 0): void;
+    /**
+     * 역의존 관계 등록 (revDep)
+     */
+    private _addRevDep;
     getAffectedFileMap(modifiedNPathSet: Set<TNormPath>): Map<TNormPath, Set<TNormPath>>;
     /**
      * 주어진 파일들 및 그 영향 범위에 해당하는 모든 캐시를 무효화
      */
     invalidates(fileNPathSet: Set<TNormPath>): void;
+    /**
+     * reexport된 경우 importSymbol → exportSymbol로 변환
+     */
+    private _convertImportSymbolToExportSymbol;
+    /**
+     * 해당 파일에서 export된 모든 심볼 (직접 + 재export 포함)
+     */
+    private _getExportSymbols;
 }