@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/topology/ts-oracle-batch.js

@@ -0,0 +1,529 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkImportabilityBatch = checkImportabilityBatch;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const tsconfig_loader_1 = require("./tsconfig-loader");
+const ts_oracle_host_1 = require("./ts-oracle-host");
+function checkImportabilityBatch(workspaceRoot, candidates, options = {}) {
+    const startedAt = Date.now();
+    const root = path.resolve(workspaceRoot);
+    const diagnostics = [];
+    const results = [];
+    const groups = [];
+    const grouped = groupCandidates(candidates);
+    const parsedConfigCache = new Map();
+    const baselineProgramCache = new Map();
+    const resolutionHost = (0, ts_oracle_host_1.createWorkspaceModuleResolutionHost)(root);
+    const totals = {
+        configMs: 0,
+        resolutionMs: 0,
+        baselineProgramMs: 0,
+        virtualProgramMs: 0,
+        diagnosticMapMs: 0
+    };
+    for (const [groupIndex, group] of grouped.entries()) {
+        options.progress?.({
+            phase: "group-start",
+            index: groupIndex + 1,
+            total: grouped.length,
+            tsconfig: group.tsconfig,
+            importer: group.importer,
+            candidates: group.candidates.length
+        });
+        const groupStartedAt = Date.now();
+        const configStartedAt = Date.now();
+        const absoluteConfig = path.resolve(root, group.tsconfig);
+        const parsed = readParsedConfig(absoluteConfig, parsedConfigCache, diagnostics);
+        const configMs = Date.now() - configStartedAt;
+        totals.configMs += configMs;
+        if (!parsed) {
+            for (const candidate of group.candidates) {
+                results.push({
+                    candidateId: candidate.id,
+                    status: "unknown",
+                    resolution: "unresolved",
+                    project: "not-checked",
+                    diagnostics: [{ code: "TS_ORACLE_BATCH_TSCONFIG_NOT_FOUND", message: "Could not parse candidate tsconfig.", file: candidate.consumerTsconfig }]
+                });
+            }
+            continue;
+        }
+        const compositePolicy = createCompositeProjectPolicy(root, parsed.parsed);
+        const importer = path.resolve(root, group.importer);
+        const resolutionStartedAt = Date.now();
+        const resolvedCandidates = [];
+        const projectCandidates = [];
+        for (const candidate of group.candidates) {
+            const resolvedModule = typescript_1.default.resolveModuleName(candidate.specifier, importer, parsed.parsed.options, resolutionHost).resolvedModule;
+            const resolvedFile = resolvedModule?.resolvedFileName ? path.resolve(resolvedModule.resolvedFileName) : null;
+            const resolution = !resolvedFile
+                ? "unresolved"
+                : candidateMatchesResolvedTarget(root, candidate, resolvedFile)
+                    ? "resolved"
+                    : "target-mismatch";
+            const row = { candidate, resolvedFile, resolution };
+            resolvedCandidates.push(row);
+            if (resolution === "resolved" && resolvedFile) {
+                const compositeDiagnostic = compositePolicy(candidate, resolvedFile);
+                if (compositeDiagnostic) {
+                    results.push({
+                        candidateId: candidate.id,
+                        resolution,
+                        project: "invalid",
+                        status: statusFor(resolution, "invalid"),
+                        resolvedFile: toDisplayPath(root, resolvedFile),
+                        diagnostics: [compositeDiagnostic]
+                    });
+                    continue;
+                }
+                projectCandidates.push(row);
+            }
+            else {
+                results.push({
+                    candidateId: candidate.id,
+                    resolution,
+                    project: "not-checked",
+                    status: statusFor(resolution, "not-checked"),
+                    ...(resolvedFile ? { resolvedFile: toDisplayPath(root, resolvedFile) } : {}),
+                    diagnostics: []
+                });
+            }
+        }
+        const resolutionMs = Date.now() - resolutionStartedAt;
+        totals.resolutionMs += resolutionMs;
+        const baselineStartedAt = Date.now();
+        let baselineCacheHit = true;
+        let baselineKeys = new Set();
+        let baselineDiagnostics = [];
+        let baselineProgram;
+        if (projectCandidates.length > 0) {
+            baselineProgram = readBaselineProgram(absoluteConfig, parsed.parsed, baselineProgramCache, importer, root, options);
+            baselineCacheHit = baselineProgram.buildMs === 0;
+            baselineDiagnostics = collectProjectDiagnosticsFromProgram(baselineProgram, importer);
+            baselineKeys = new Set(baselineDiagnostics.map(diagnosticKey));
+        }
+        const baselineProgramMs = Date.now() - baselineStartedAt;
+        totals.baselineProgramMs += baselineProgramMs;
+        const virtualStartedAt = Date.now();
+        const introduced = projectCandidates.length > 0
+            ? collectProjectDiagnostics(parsed.parsed, importer, buildVirtualSource(importer, projectCandidates.map((item) => item.candidate)))
+                .filter((diagnostic) => !baselineKeys.has(diagnosticKey(diagnostic)))
+            : [];
+        const virtualProgramMs = Date.now() - virtualStartedAt;
+        totals.virtualProgramMs += virtualProgramMs;
+        const mapStartedAt = Date.now();
+        const introducedDiagnostics = introduced.map((diagnostic) => (0, tsconfig_loader_1.toOracleDiagnostic)("TS_ORACLE_PROJECT_DIAGNOSTIC", diagnostic));
+        const blockingBaselineDiagnostics = baselineDiagnostics
+            .filter(isBlockingBaselineDiagnostic)
+            .map((diagnostic) => (0, tsconfig_loader_1.toOracleDiagnostic)("TS_ORACLE_PROJECT_DIAGNOSTIC", diagnostic));
+        for (const item of projectCandidates) {
+            const candidate = item.candidate;
+            const relatedDiagnostics = [
+                ...introducedDiagnostics.filter((diagnostic) => diagnosticMatchesCandidate(root, diagnostic, candidate)),
+                ...blockingBaselineDiagnostics.filter((diagnostic) => diagnosticMatchesCandidate(root, diagnostic, candidate))
+            ];
+            const project = relatedDiagnostics.length > 0 ? "invalid" : "valid";
+            results.push({
+                candidateId: candidate.id,
+                resolution: item.resolution,
+                project,
+                status: statusFor(item.resolution, project),
+                ...(item.resolvedFile ? { resolvedFile: toDisplayPath(root, item.resolvedFile) } : {}),
+                diagnostics: relatedDiagnostics.map((diagnostic) => displayDiagnostic(root, diagnostic))
+            });
+        }
+        const diagnosticMapMs = Date.now() - mapStartedAt;
+        totals.diagnosticMapMs += diagnosticMapMs;
+        const summary = {
+            tsconfig: group.tsconfig,
+            importer: group.importer,
+            candidates: group.candidates.length,
+            resolvedCandidates: projectCandidates.length,
+            projectCheckedCandidates: projectCandidates.length,
+            resolutionOnlyCandidates: group.candidates.length - projectCandidates.length,
+            introducedDiagnostics: introduced.length,
+            baselineCacheHit,
+            timings: {
+                configMs,
+                resolutionMs,
+                baselineProgramMs,
+                virtualProgramMs,
+                diagnosticMapMs,
+                totalMs: Date.now() - groupStartedAt
+            }
+        };
+        groups.push(summary);
+        options.progress?.({
+            phase: "group-done",
+            index: groupIndex + 1,
+            total: grouped.length,
+            tsconfig: group.tsconfig,
+            importer: group.importer,
+            candidates: group.candidates.length,
+            resolvedCandidates: summary.resolvedCandidates,
+            projectCheckedCandidates: summary.projectCheckedCandidates,
+            resolutionOnlyCandidates: summary.resolutionOnlyCandidates,
+            baselineCacheHit,
+            timings: summary.timings
+        });
+    }
+    return {
+        results,
+        groups,
+        diagnostics: diagnostics.map((diagnostic) => displayDiagnostic(root, diagnostic)),
+        timings: {
+            totalMs: Date.now() - startedAt,
+            ...totals
+        }
+    };
+}
+function readParsedConfig(configPath, cache, diagnostics) {
+    const key = path.resolve(configPath);
+    if (!cache.has(key)) {
+        cache.set(key, (0, tsconfig_loader_1.parseTsConfig)(key, diagnostics));
+    }
+    return cache.get(key) ?? null;
+}
+function readBaselineProgram(configPath, parsed, cache, importer, root, options) {
+    const key = path.resolve(configPath);
+    const cached = cache.get(key);
+    if (cached) {
+        return {
+            ...cached,
+            buildMs: 0
+        };
+    }
+    const startedAt = Date.now();
+    const mode = options.semanticPoolMode ?? "shadow";
+    if (options.semanticContextPool && mode === "active") {
+        try {
+            const pooled = options.semanticContextPool.acquireProgram({
+                focusFile: importer,
+                ownerConfig: configPath,
+                projectScope: "owner"
+            });
+            const program = pooled.program;
+            const entry = {
+                program,
+                optionsDiagnostics: program.getOptionsDiagnostics(),
+                globalDiagnostics: program.getGlobalDiagnostics(),
+                // Preserve operation-local baselineCacheHit semantics: the first group
+                // remains a local miss even when its Program came from the session pool.
+                buildMs: Math.max(1, Date.now() - startedAt)
+            };
+            options.semanticPoolObservation?.({
+                mode,
+                status: "activated",
+                tsconfig: toDisplayPath(root, configPath),
+                importer: toDisplayPath(root, importer),
+                cache: pooled.cache
+            });
+            pooled.release();
+            cache.set(key, entry);
+            return entry;
+        }
+        catch (error) {
+            options.semanticPoolObservation?.({
+                mode,
+                status: "fallback",
+                tsconfig: toDisplayPath(root, configPath),
+                importer: toDisplayPath(root, importer),
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    const program = typescript_1.default.createProgram(parsed.fileNames, parsed.options);
+    const entry = {
+        program,
+        optionsDiagnostics: program.getOptionsDiagnostics(),
+        globalDiagnostics: program.getGlobalDiagnostics(),
+        buildMs: Date.now() - startedAt
+    };
+    if (options.semanticContextPool && mode === "shadow") {
+        try {
+            const pooled = options.semanticContextPool.acquireProgram({
+                focusFile: importer,
+                ownerConfig: configPath,
+                projectScope: "owner"
+            });
+            const diagnosticsEqual = stableDiagnosticSnapshotsEqual(collectProjectDiagnosticsFromProgram(entry, importer), collectProjectDiagnosticsFromProgram({
+                program: pooled.program,
+                optionsDiagnostics: pooled.program.getOptionsDiagnostics(),
+                globalDiagnostics: pooled.program.getGlobalDiagnostics(),
+                buildMs: 0
+            }, importer));
+            const sourceFilesEqual = stableStringArrayEqual(program.getSourceFiles().map((source) => normalizeFile(source.fileName)), pooled.program.getSourceFiles().map((source) => normalizeFile(source.fileName)));
+            const currentSourceFiles = new Set(program.getSourceFiles().map((source) => normalizeFile(source.fileName)));
+            const pooledSourceFiles = new Set(pooled.program.getSourceFiles().map((source) => normalizeFile(source.fileName)));
+            options.semanticPoolObservation?.({
+                mode,
+                status: diagnosticsEqual && sourceFilesEqual ? "parity" : "mismatch",
+                tsconfig: toDisplayPath(root, configPath),
+                importer: toDisplayPath(root, importer),
+                cache: pooled.cache,
+                diagnosticsEqual,
+                sourceFilesEqual,
+                ...(!sourceFilesEqual ? {
+                    sourceFilesAdded: [...pooledSourceFiles].filter((file) => !currentSourceFiles.has(file)).sort(),
+                    sourceFilesRemoved: [...currentSourceFiles].filter((file) => !pooledSourceFiles.has(file)).sort()
+                } : {})
+            });
+            pooled.release();
+        }
+        catch (error) {
+            options.semanticPoolObservation?.({
+                mode,
+                status: "fallback",
+                tsconfig: toDisplayPath(root, configPath),
+                importer: toDisplayPath(root, importer),
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    cache.set(key, entry);
+    return entry;
+}
+function stableDiagnosticSnapshotsEqual(left, right) {
+    return JSON.stringify(left.map(exactDiagnosticSnapshot)) === JSON.stringify(right.map(exactDiagnosticSnapshot));
+}
+function exactDiagnosticSnapshot(diagnostic) {
+    return {
+        file: diagnostic.file ? normalizeFile(diagnostic.file.fileName) : null,
+        start: diagnostic.start ?? null,
+        length: diagnostic.length ?? null,
+        code: diagnostic.code,
+        category: diagnostic.category,
+        message: typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, "\n")
+    };
+}
+function stableStringArrayEqual(left, right) {
+    return JSON.stringify([...left].sort()) === JSON.stringify([...right].sort());
+}
+function normalizeFile(file) {
+    const normalized = path.normalize(path.resolve(file));
+    return typescript_1.default.sys.useCaseSensitiveFileNames ? normalized : normalized.toLowerCase();
+}
+function groupCandidates(candidates) {
+    const groups = new Map();
+    for (const candidate of candidates) {
+        const key = candidate.consumerTsconfig;
+        const group = groups.get(key) ?? {
+            tsconfig: candidate.consumerTsconfig,
+            importer: candidate.representativeImporterFile,
+            candidates: []
+        };
+        group.candidates.push(candidate);
+        group.importer = [group.importer, candidate.representativeImporterFile].sort((left, right) => left.localeCompare(right))[0] ?? group.importer;
+        groups.set(key, group);
+    }
+    return [...groups.values()].sort((left, right) => left.tsconfig.localeCompare(right.tsconfig) || left.importer.localeCompare(right.importer));
+}
+function buildVirtualSource(importer, candidates) {
+    const original = typescript_1.default.sys.readFile(importer) ?? "";
+    const imports = candidates.map((candidate, index) => {
+        const binding = `__aib_oracle_${index}`;
+        return `import * as ${binding} from ${JSON.stringify(candidate.specifier)}; void ${binding};`;
+    }).join("\n");
+    return `${original}\n${imports}\n`;
+}
+function collectProjectDiagnostics(parsed, fromFile, virtualSource, wholeProject = false) {
+    const host = typescript_1.default.createCompilerHost(parsed.options, true);
+    const baseGetSourceFile = host.getSourceFile.bind(host);
+    host.readFile = (fileName) => virtualSource && sameSourceFile(fileName, fromFile) ? virtualSource : typescript_1.default.sys.readFile(fileName);
+    host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+        if (virtualSource && sameSourceFile(fileName, fromFile)) {
+            return typescript_1.default.createSourceFile(fileName, virtualSource, languageVersionOrOptions, true);
+        }
+        return baseGetSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+    };
+    const program = typescript_1.default.createProgram(parsed.fileNames, parsed.options, host);
+    const source = program.getSourceFile(fromFile);
+    if (wholeProject) {
+        return [
+            ...program.getOptionsDiagnostics(),
+            ...program.getGlobalDiagnostics(),
+            ...program.getSyntacticDiagnostics(),
+            ...program.getSemanticDiagnostics()
+        ];
+    }
+    return [
+        ...program.getOptionsDiagnostics(),
+        ...program.getGlobalDiagnostics(),
+        ...(source ? program.getSyntacticDiagnostics(source) : []),
+        ...(source ? program.getSemanticDiagnostics(source) : [])
+    ];
+}
+function collectProjectDiagnosticsFromProgram(entry, fromFile, wholeProject = false) {
+    if (wholeProject) {
+        return [
+            ...entry.optionsDiagnostics,
+            ...entry.globalDiagnostics,
+            ...entry.program.getSyntacticDiagnostics(),
+            ...entry.program.getSemanticDiagnostics()
+        ];
+    }
+    const source = entry.program.getSourceFile(fromFile);
+    return [
+        ...entry.optionsDiagnostics,
+        ...entry.globalDiagnostics,
+        ...(source ? entry.program.getSyntacticDiagnostics(source) : []),
+        ...(source ? entry.program.getSemanticDiagnostics(source) : [])
+    ];
+}
+function diagnosticMatchesCandidate(root, diagnostic, candidate) {
+    const text = `${diagnostic.file ?? ""}\n${diagnostic.message}`;
+    return text.includes(candidate.specifier) ||
+        text.includes(candidate.targetFile) ||
+        text.includes(path.resolve(root, candidate.targetFile)) ||
+        Boolean(candidate.targetRoot && (text.includes(candidate.targetRoot) ||
+            text.includes(path.resolve(root, candidate.targetRoot))));
+}
+function isBlockingBaselineDiagnostic(diagnostic) {
+    return diagnostic.code === 6307;
+}
+function createCompositeProjectPolicy(root, parsed) {
+    if (parsed.options.composite !== true) {
+        return () => null;
+    }
+    const projectFiles = new Set(parsed.fileNames.map((file) => normalizeRealPath(file)));
+    return (candidate, resolvedFile) => {
+        const normalizedResolved = normalizeRealPath(resolvedFile);
+        if (projectFiles.has(normalizedResolved)) {
+            return null;
+        }
+        if (isDeclarationFile(resolvedFile) || isGeneratedOutputPath(resolvedFile)) {
+            return null;
+        }
+        if (candidate.source === "package-dependency" && candidate.targetRoot) {
+            const targetRoot = normalizeRealPath(path.resolve(root, candidate.targetRoot));
+            if (isPathInsideOrEqual(normalizedResolved, targetRoot)) {
+                return null;
+            }
+        }
+        if (!isSourceImplementationFile(resolvedFile)) {
+            return null;
+        }
+        return {
+            code: "TS_ORACLE_COMPOSITE_PROJECT_FILE_OUTSIDE_SET",
+            message: [
+                "Resolved source file is outside the composite project file set.",
+                `specifier: ${candidate.specifier}`,
+                `resolved: ${toDisplayPath(root, resolvedFile)}`
+            ].join("\n"),
+            file: toDisplayPath(root, resolvedFile)
+        };
+    };
+}
+function statusFor(resolution, project) {
+    if (resolution === "unresolved") {
+        return "unresolved";
+    }
+    if (resolution === "target-mismatch") {
+        return "target-mismatch";
+    }
+    if (project === "invalid") {
+        return "resolves-but-project-invalid";
+    }
+    return "valid";
+}
+function diagnosticKey(diagnostic) {
+    return [
+        diagnostic.code,
+        diagnostic.file?.fileName ?? "",
+        diagnostic.start ?? "",
+        diagnostic.length ?? "",
+        typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, "\n")
+    ].join("|");
+}
+function displayDiagnostic(root, diagnostic) {
+    return {
+        ...diagnostic,
+        ...(diagnostic.file ? { file: toDisplayPath(root, diagnostic.file) } : {})
+    };
+}
+function sameSourceFile(left, right) {
+    return normalizeSourceFile(left) === normalizeSourceFile(right);
+}
+function candidateMatchesResolvedTarget(root, candidate, resolvedFile) {
+    if (sameSourceFile(resolvedFile, path.resolve(root, candidate.targetFile))) {
+        return true;
+    }
+    if (!candidate.targetRoot) {
+        return false;
+    }
+    return isPathInsideOrEqual(realPathSafe(resolvedFile), realPathSafe(path.resolve(root, candidate.targetRoot)));
+}
+function isPathInsideOrEqual(candidate, parent) {
+    const relative = path.relative(path.resolve(parent), path.resolve(candidate));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function realPathSafe(file) {
+    try {
+        return fs.realpathSync.native(file);
+    }
+    catch {
+        return path.resolve(file);
+    }
+}
+function normalizeSourceFile(file) {
+    const resolved = path.resolve(file).replace(/\\/g, "/").toLowerCase();
+    return resolved.endsWith(".d.ts") ? resolved.slice(0, -5) : withoutSourceExtension(resolved);
+}
+function normalizeRealPath(file) {
+    return realPathSafe(file).replace(/\\/g, "/").toLowerCase();
+}
+function isDeclarationFile(file) {
+    return /\.d\.[cm]?[tj]s$/i.test(file);
+}
+function isSourceImplementationFile(file) {
+    return /\.(?:[cm]?[tj]sx?)$/i.test(file) && !isDeclarationFile(file);
+}
+function isGeneratedOutputPath(file) {
+    const normalized = file.replace(/\\/g, "/").toLowerCase();
+    return normalized.includes("/dist/") || normalized.includes("/build/") || normalized.includes("/out/");
+}
+function withoutSourceExtension(file) {
+    return file.replace(/\.(d\.)?[cm]?[tj]sx?$/i, "");
+}
+function toDisplayPath(root, file) {
+    const relative = path.relative(root, path.resolve(file)).replace(/\\/g, "/");
+    return relative === "" ? "." : relative.startsWith("..") ? path.resolve(file).replace(/\\/g, "/") : relative;
+}

package/dist/topology/ts-oracle-host.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkspaceModuleResolutionHost = createWorkspaceModuleResolutionHost;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+function createWorkspaceModuleResolutionHost(workspaceRoot) {
+    const root = path.resolve(workspaceRoot);
+    return {
+        fileExists: (fileName) => isPathInsideWorkspace(root, fileName) && typescript_1.default.sys.fileExists(fileName),
+        readFile: (fileName) => isPathInsideWorkspace(root, fileName) ? typescript_1.default.sys.readFile(fileName) : undefined,
+        directoryExists: (directoryName) => isPathInsideWorkspace(root, directoryName) && (typescript_1.default.sys.directoryExists?.(directoryName) ?? fs.existsSync(directoryName)),
+        getDirectories: (directoryName) => isPathInsideWorkspace(root, directoryName) ? typescript_1.default.sys.getDirectories?.(directoryName) ?? [] : [],
+        realpath: (fileName) => isPathInsideWorkspace(root, fileName) ? typescript_1.default.sys.realpath?.(fileName) ?? realPathSafe(fileName) : path.resolve(fileName),
+        useCaseSensitiveFileNames: typeof typescript_1.default.sys.useCaseSensitiveFileNames === "function"
+            ? typescript_1.default.sys.useCaseSensitiveFileNames
+            : () => Boolean(typescript_1.default.sys.useCaseSensitiveFileNames),
+        getCurrentDirectory: () => root
+    };
+}
+function isPathInsideWorkspace(root, fileName) {
+    const absolute = path.resolve(fileName);
+    const relative = path.relative(root, absolute);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function realPathSafe(fileName) {
+    try {
+        return fs.realpathSync.native(fileName);
+    }
+    catch {
+        return path.resolve(fileName);
+    }
+}

package/dist/topology/ts-oracle-model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });