@hakobu/hakobu 1.0.0

package/lib-es5/commands.js

@@ -0,0 +1,376 @@
+"use strict";
+/**
+ * Hakobu diagnostic and inspection commands.
+ *
+ * These answer the questions developers ask before, during, and after packaging:
+ *   - targets:  What can I build for? What base binaries are cached?
+ *   - inspect:  What does Hakobu see in my project?
+ *   - doctor:   Is my project ready to package? What's wrong?
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandDoctor = exports.commandInspect = exports.commandTargets = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const promises_1 = require("fs/promises");
+const hakobu_fetch_1 = require("@hakobu/hakobu-fetch");
+// These are internal to hakobu-fetch but we import the compiled JS
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { EXPECTED_HASHES } = require('@hakobu/hakobu-fetch/lib-es5/expected');
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { localPlace } = require('@hakobu/hakobu-fetch/lib-es5/places');
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const fetchPkg = require('@hakobu/hakobu-fetch/package.json');
+const analyzer_1 = require("./analyzer");
+const { hostArch, hostPlatform, knownArchs, knownPlatforms, } = hakobu_fetch_1.system;
+// ─────────────────────────────────────────────────────────────────────
+// Shared formatting
+// ─────────────────────────────────────────────────────────────────────
+function bold(s) { return `\x1b[1m${s}\x1b[0m`; }
+function green(s) { return `\x1b[32m${s}\x1b[0m`; }
+function yellow(s) { return `\x1b[33m${s}\x1b[0m`; }
+function red(s) { return `\x1b[31m${s}\x1b[0m`; }
+function dim(s) { return `\x1b[2m${s}\x1b[0m`; }
+function severityIcon(s) {
+    if (s === 'error')
+        return red('x');
+    if (s === 'warning')
+        return yellow('!');
+    return dim('i');
+}
+// ─────────────────────────────────────────────────────────────────────
+// hakobu targets
+// ─────────────────────────────────────────────────────────────────────
+async function commandTargets() {
+    const nodeVersion = (0, hakobu_fetch_1.getNodeVersion)('node24');
+    const fetchVersion = fetchPkg.version;
+    console.log(bold('Hakobu Targets'));
+    console.log();
+    // Host
+    console.log(`  Host: ${bold(`${hostPlatform}-${hostArch}`)} (Node ${process.version})`);
+    console.log(`  Base: Node ${nodeVersion}`);
+    console.log();
+    // Published targets from expected-shas.json
+    const published = [];
+    for (const name of Object.keys(EXPECTED_HASHES)) {
+        // name format: hakobu-base-v24.14.0-linux-x64
+        const match = name.match(/^hakobu-base-(v[\d.]+)-([a-z]+)-([a-z0-9]+)$/);
+        if (!match)
+            continue;
+        const [, , platform, arch] = match;
+        // Check cache
+        const cachedPath = localPlace({
+            from: 'fetched',
+            arch,
+            nodeVersion,
+            platform,
+            version: fetchVersion,
+        });
+        let cached = false;
+        try {
+            const s = await (0, promises_1.stat)(cachedPath);
+            cached = s.size > 0;
+        }
+        catch { /* not cached */ }
+        published.push({ platform, arch, name, cached });
+    }
+    // Sort: host target first, then alphabetical
+    published.sort((a, b) => {
+        const aIsHost = a.platform === hostPlatform && a.arch === hostArch;
+        const bIsHost = b.platform === hostPlatform && b.arch === hostArch;
+        if (aIsHost && !bIsHost)
+            return -1;
+        if (!aIsHost && bIsHost)
+            return 1;
+        return `${a.platform}-${a.arch}`.localeCompare(`${b.platform}-${b.arch}`);
+    });
+    console.log('  Published base binaries:');
+    console.log();
+    for (const t of published) {
+        const isHost = t.platform === hostPlatform && t.arch === hostArch;
+        const label = `${t.platform}-${t.arch}`;
+        const hostTag = isHost ? dim(' (host)') : '';
+        const cacheTag = t.cached ? green(' cached') : dim(' remote');
+        console.log(`    ${t.cached ? green('*') : ' '} ${label}${hostTag}${cacheTag}`);
+    }
+    console.log();
+    console.log(dim('  * = locally cached base binary'));
+    console.log(dim(`  Cache: ${localPlace({ from: 'fetched', arch: 'x64', nodeVersion, platform: 'linux', version: fetchVersion }).replace(/fetched-.*$/, '')}`));
+}
+exports.commandTargets = commandTargets;
+// ─────────────────────────────────────────────────────────────────────
+// hakobu inspect <projectRoot>
+// ─────────────────────────────────────────────────────────────────────
+async function commandInspect(projectRoot) {
+    if (!projectRoot) {
+        console.error(red('Usage: hakobu inspect <project-root>'));
+        process.exit(1);
+    }
+    const resolved = path_1.default.resolve(projectRoot);
+    if (!fs_1.default.existsSync(resolved)) {
+        console.error(red(`Project root not found: ${resolved}`));
+        process.exit(1);
+    }
+    console.log(bold('Hakobu Project Inspection'));
+    console.log();
+    console.log(`  Project: ${resolved}`);
+    let manifest;
+    try {
+        manifest = await (0, analyzer_1.analyze)({ projectRoot: resolved });
+    }
+    catch (err) {
+        console.log();
+        console.log(red(`  Analysis failed: ${err.message}`));
+        if (err.remediation) {
+            console.log(`  Remediation: ${err.remediation}`);
+        }
+        process.exit(1);
+    }
+    // Entry
+    console.log();
+    console.log(`  ${bold('Entry')}`);
+    console.log(`    Path:      ${manifest.entry.snapshotPath}`);
+    console.log(`    Format:    ${manifest.entry.format === 'esm' ? green('ESM') : 'CJS'}`);
+    console.log(`    Detected:  ${manifest.entry.formatSource}`);
+    // Files summary
+    const files = Object.values(manifest.files);
+    const byKind = {};
+    for (const f of files) {
+        byKind[f.kind] = (byKind[f.kind] || 0) + 1;
+    }
+    console.log();
+    console.log(`  ${bold('Files')} (${files.length} total)`);
+    for (const [kind, count] of Object.entries(byKind).sort((a, b) => b[1] - a[1])) {
+        console.log(`    ${kind}: ${count}`);
+    }
+    // Packages
+    const pkgs = Object.values(manifest.packages);
+    if (pkgs.length > 0) {
+        console.log();
+        console.log(`  ${bold('Packages')} (${pkgs.length})`);
+        for (const pkg of pkgs.slice(0, 20)) {
+            const name = pkg.name || dim('(unnamed)');
+            const ver = pkg.version || '';
+            const type = pkg.type === 'module' ? green('ESM') : 'CJS';
+            console.log(`    ${name}${ver ? `@${ver}` : ''} ${dim(type)}`);
+        }
+        if (pkgs.length > 20) {
+            console.log(dim(`    ... and ${pkgs.length - 20} more`));
+        }
+    }
+    // Native addons
+    if (manifest.nativeAddons.length > 0) {
+        console.log();
+        console.log(`  ${bold('Native Addons')} (${manifest.nativeAddons.length})`);
+        for (const addon of manifest.nativeAddons) {
+            console.log(`    ${addon.snapshotPath}`);
+        }
+    }
+    // Externals
+    if (manifest.externals.length > 0) {
+        console.log();
+        console.log(`  ${bold('External Artifacts')} (${manifest.externals.length})`);
+        for (const ext of manifest.externals) {
+            console.log(`    ${ext.name} ${ext.required ? red('required') : dim('optional')}`);
+        }
+    }
+    // Warnings
+    printWarnings(manifest.warnings);
+    console.log();
+}
+exports.commandInspect = commandInspect;
+// ─────────────────────────────────────────────────────────────────────
+// hakobu doctor <projectRoot>
+// ─────────────────────────────────────────────────────────────────────
+async function commandDoctor(projectRoot, targetSpec) {
+    if (!projectRoot) {
+        console.error(red('Usage: hakobu doctor <project-root> [--target node24-macos-arm64]'));
+        process.exit(1);
+    }
+    const resolved = path_1.default.resolve(projectRoot);
+    if (!fs_1.default.existsSync(resolved)) {
+        console.error(red(`Project root not found: ${resolved}`));
+        process.exit(1);
+    }
+    console.log(bold('Hakobu Doctor'));
+    console.log();
+    const checks = [];
+    // Check 1: Project root has package.json
+    const pkgJsonPath = path_1.default.join(resolved, 'package.json');
+    if (fs_1.default.existsSync(pkgJsonPath)) {
+        const pkg = JSON.parse(fs_1.default.readFileSync(pkgJsonPath, 'utf8'));
+        checks.push({
+            name: 'package.json',
+            status: 'ok',
+            detail: `${pkg.name || '(unnamed)'}@${pkg.version || '0.0.0'}`,
+        });
+    }
+    else {
+        checks.push({
+            name: 'package.json',
+            status: 'fail',
+            detail: 'Not found. Hakobu needs a package.json to determine the project name and entry.',
+        });
+    }
+    // Check 2: Entrypoint exists
+    let manifest = null;
+    try {
+        manifest = await (0, analyzer_1.analyze)({ projectRoot: resolved });
+        checks.push({
+            name: 'Entrypoint',
+            status: 'ok',
+            detail: `${manifest.entry.snapshotPath} (${manifest.entry.format})`,
+        });
+    }
+    catch (err) {
+        checks.push({
+            name: 'Entrypoint',
+            status: 'fail',
+            detail: err.message,
+        });
+    }
+    // Check 3: Analysis warnings
+    if (manifest) {
+        const errors = manifest.warnings.filter(w => w.severity === 'error');
+        const warns = manifest.warnings.filter(w => w.severity === 'warning');
+        if (errors.length > 0) {
+            checks.push({
+                name: 'Analysis',
+                status: 'fail',
+                detail: `${errors.length} error(s): ${errors[0].message}`,
+            });
+        }
+        else if (warns.length > 0) {
+            checks.push({
+                name: 'Analysis',
+                status: 'warn',
+                detail: `${warns.length} warning(s)`,
+            });
+        }
+        else {
+            checks.push({
+                name: 'Analysis',
+                status: 'ok',
+                detail: `${Object.keys(manifest.files).length} files, no issues`,
+            });
+        }
+    }
+    // Check 4: Target base binary
+    const target = parseTargetForDoctor(targetSpec);
+    const nodeVersion = (0, hakobu_fetch_1.getNodeVersion)('node24');
+    const fetchVersion = fetchPkg.version;
+    // Check if base is published
+    const expectedName = `hakobu-base-${nodeVersion}-${target.platform}-${target.arch}`;
+    const isPublished = !!EXPECTED_HASHES[expectedName];
+    if (isPublished) {
+        // Check if cached
+        const cachedPath = localPlace({
+            from: 'fetched',
+            arch: target.arch,
+            nodeVersion,
+            platform: target.platform,
+            version: fetchVersion,
+        });
+        let isCached = false;
+        try {
+            const s = await (0, promises_1.stat)(cachedPath);
+            isCached = s.size > 0;
+        }
+        catch { /* not cached */ }
+        if (isCached) {
+            checks.push({
+                name: `Base binary (${target.platform}-${target.arch})`,
+                status: 'ok',
+                detail: `Cached at ${cachedPath}`,
+            });
+        }
+        else {
+            checks.push({
+                name: `Base binary (${target.platform}-${target.arch})`,
+                status: 'ok',
+                detail: 'Available remotely (will be fetched during packaging)',
+            });
+        }
+    }
+    else {
+        checks.push({
+            name: `Base binary (${target.platform}-${target.arch})`,
+            status: 'fail',
+            detail: `No published base for ${target.platform}-${target.arch}. Available: ${Object.keys(EXPECTED_HASHES).map(n => n.replace(/^hakobu-base-v[\d.]+-/, '')).join(', ')}`,
+        });
+    }
+    // Check 5: Native addons (if any)
+    if (manifest && manifest.nativeAddons.length > 0) {
+        if (target.platform !== hostPlatform || target.arch !== hostArch) {
+            checks.push({
+                name: 'Native addons',
+                status: 'warn',
+                detail: `${manifest.nativeAddons.length} native addon(s) detected. Cross-platform packaging of native addons requires rebuilding for the target.`,
+            });
+        }
+        else {
+            checks.push({
+                name: 'Native addons',
+                status: 'ok',
+                detail: `${manifest.nativeAddons.length} addon(s) — host-target match`,
+            });
+        }
+    }
+    // Print results
+    let hasFailure = false;
+    for (const check of checks) {
+        const icon = check.status === 'ok' ? green('OK') : check.status === 'warn' ? yellow('!!') : red('XX');
+        console.log(`  ${icon}  ${check.name}`);
+        console.log(`      ${check.detail}`);
+        if (check.status === 'fail')
+            hasFailure = true;
+    }
+    // Print manifest warnings if available
+    if (manifest && manifest.warnings.length > 0) {
+        printWarnings(manifest.warnings);
+    }
+    console.log();
+    if (hasFailure) {
+        console.log(red('  Some checks failed. Fix the issues above before packaging.'));
+    }
+    else {
+        console.log(green('  All checks passed. Ready to package.'));
+    }
+}
+exports.commandDoctor = commandDoctor;
+// ─────────────────────────────────────────────────────────────────────
+// Shared helpers
+// ─────────────────────────────────────────────────────────────────────
+function printWarnings(warnings) {
+    if (warnings.length === 0)
+        return;
+    console.log();
+    console.log(`  ${bold('Warnings')} (${warnings.length})`);
+    for (const w of warnings) {
+        console.log(`    ${severityIcon(w.severity)} [${w.category}] ${w.message}`);
+        if (w.file)
+            console.log(dim(`      in ${w.file}`));
+        if (w.suggestion)
+            console.log(dim(`      fix: ${w.suggestion}`));
+    }
+}
+function parseTargetForDoctor(spec) {
+    if (!spec) {
+        return { platform: hostPlatform, arch: hostArch };
+    }
+    const parts = spec.split('-');
+    let platform = hostPlatform;
+    let arch = hostArch;
+    for (const part of parts) {
+        if (part.startsWith('node'))
+            continue;
+        if (knownPlatforms.includes(part))
+            platform = part;
+        else if (knownArchs.includes(part))
+            arch = part;
+    }
+    return { platform, arch };
+}
+//# sourceMappingURL=commands.js.map

package/lib-es5/common.js

@@ -0,0 +1,328 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isESMFile = exports.isESMPackage = exports.toNormalizedRealPath = exports.removeUplevels = exports.stripSnapshot = exports.insideSnapshot = exports.snapshotify = exports.substituteDenominator = exports.retrieveDenominator = exports.unlikelyJavascript = exports.isDotNODE = exports.isDotJSON = exports.isDotJS = exports.isPackageJson = exports.normalizePath = exports.isRootPath = exports.ALIAS_AS_RESOLVABLE = exports.ALIAS_AS_RELATIVE = exports.STORE_STAT = exports.STORE_LINKS = exports.STORE_CONTENT = exports.STORE_BLOB = void 0;
+const assert_1 = __importDefault(require("assert"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.STORE_BLOB = 0;
+exports.STORE_CONTENT = 1;
+exports.STORE_LINKS = 2;
+exports.STORE_STAT = 3;
+exports.ALIAS_AS_RELATIVE = 0; // require("./file.js") // file or directory
+exports.ALIAS_AS_RESOLVABLE = 1; // require("package")
+const win32 = process.platform === 'win32';
+const hasURL = typeof URL !== 'undefined';
+function uppercaseDriveLetter(f) {
+    if (f.slice(1, 3) !== ':\\')
+        return f;
+    return f[0].toUpperCase() + f.slice(1);
+}
+function removeTrailingSlashes(f) {
+    if (f === '/') {
+        return f; // dont remove from "/"
+    }
+    if (f.slice(1) === ':\\') {
+        return f; // dont remove from "D:\"
+    }
+    let last = f.length - 1;
+    while (true) {
+        const char = f.charAt(last);
+        if (char === '\\') {
+            f = f.slice(0, -1);
+            last -= 1;
+        }
+        else if (char === '/') {
+            f = f.slice(0, -1);
+            last -= 1;
+        }
+        else {
+            break;
+        }
+    }
+    return f;
+}
+const isUrl = (p) => hasURL && p instanceof URL;
+function pathToString(p, win) {
+    let result;
+    if (Buffer.isBuffer(p)) {
+        result = p.toString();
+    }
+    else if (isUrl(p)) {
+        result = win ? p.pathname.replace(/^\//, '') : p.pathname;
+    }
+    else {
+        result = p;
+    }
+    return result;
+}
+function isRootPath(p) {
+    let file = pathToString(p, false);
+    if (file === '.') {
+        file = path_1.default.resolve(file);
+    }
+    return path_1.default.dirname(file) === p;
+}
+exports.isRootPath = isRootPath;
+function normalizePath(f) {
+    let file = pathToString(f, win32);
+    if (!/^.:$/.test(file)) {
+        file = path_1.default.normalize(file);
+    } // 'c:' -> 'c:.'
+    if (win32) {
+        file = uppercaseDriveLetter(file);
+    }
+    return removeTrailingSlashes(file);
+}
+exports.normalizePath = normalizePath;
+function isPackageJson(file) {
+    return path_1.default.basename(file) === 'package.json';
+}
+exports.isPackageJson = isPackageJson;
+function isDotJS(file) {
+    return ['.js', '.cjs'].includes(path_1.default.extname(file));
+}
+exports.isDotJS = isDotJS;
+function isDotJSON(file) {
+    return path_1.default.extname(file) === '.json';
+}
+exports.isDotJSON = isDotJSON;
+function isDotNODE(file) {
+    return path_1.default.extname(file) === '.node';
+}
+exports.isDotNODE = isDotNODE;
+function unlikelyJavascript(file) {
+    const ext = path_1.default.extname(file);
+    // Check single extensions
+    if (['.css', '.html', '.json', '.vue'].includes(ext)) {
+        return true;
+    }
+    // Check for .d.ts files (compound extension)
+    if (file.endsWith('.d.ts')) {
+        return true;
+    }
+    return false;
+}
+exports.unlikelyJavascript = unlikelyJavascript;
+function replaceSlashes(file, slash) {
+    if (/^.:\\/.test(file)) {
+        if (slash === '/') {
+            return file.slice(2).replace(/\\/g, '/');
+        }
+    }
+    else if (/^\//.test(file)) {
+        if (slash === '\\') {
+            return `C:${file.replace(/\//g, '\\')}`;
+        }
+    }
+    return file;
+}
+function injectSnapshot(file) {
+    if (/^.:\\/.test(file)) {
+        // C:\path\to
+        if (file.length === 3) {
+            // C:\
+            file = file.slice(0, -1);
+        }
+        // by convention, on windows we use C:\\snapshot
+        return `C:\\snapshot${file.slice(2)}`;
+    }
+    if (/^\//.test(file)) {
+        // /home/user/project
+        if (file.length === 1) {
+            // /
+            file = file.slice(0, -1);
+        }
+        return `/snapshot${file}`;
+    }
+    return file;
+}
+function longestCommonLength(s1, s2) {
+    const length = Math.min(s1.length, s2.length);
+    for (let i = 0; i < length; i += 1) {
+        if (s1.charCodeAt(i) !== s2.charCodeAt(i)) {
+            return i;
+        }
+    }
+    return length;
+}
+function withoutNodeModules(file) {
+    return file.split(`${path_1.default.sep}node_modules${path_1.default.sep}`)[0];
+}
+function retrieveDenominator(files) {
+    (0, assert_1.default)(files.length > 0);
+    let s1 = withoutNodeModules(files[0]) + path_1.default.sep;
+    for (let i = 1; i < files.length; i += 1) {
+        const s2 = withoutNodeModules(files[i]) + path_1.default.sep;
+        s1 = s1.slice(0, longestCommonLength(s1, s2));
+    }
+    if (s1 === '') {
+        return win32 ? 2 : 0;
+    }
+    return s1.lastIndexOf(path_1.default.sep);
+}
+exports.retrieveDenominator = retrieveDenominator;
+function substituteDenominator(f, denominator) {
+    const rootLength = win32 ? 2 : 0;
+    return f.slice(0, rootLength) + f.slice(denominator);
+}
+exports.substituteDenominator = substituteDenominator;
+function snapshotify(file, slash) {
+    return injectSnapshot(replaceSlashes(file, slash));
+}
+exports.snapshotify = snapshotify;
+function insideSnapshot(f) {
+    f = pathToString(f, win32);
+    if (typeof f !== 'string') {
+        return false;
+    }
+    if (win32) {
+        const slice112 = f.slice(1, 12);
+        return (slice112 === ':\\snapshot\\' ||
+            slice112 === ':/snapshot\\' ||
+            slice112 === ':\\snapshot/' ||
+            slice112 === ':/snapshot/' ||
+            slice112 === ':\\snapshot' ||
+            slice112 === ':/snapshot');
+    }
+    const slice010 = f.slice(0, 10);
+    return slice010 === '/snapshot/' || slice010 === '/snapshot';
+}
+exports.insideSnapshot = insideSnapshot;
+function stripSnapshot(f) {
+    const file = normalizePath(f);
+    if (/^.:\\snapshot$/.test(file)) {
+        return `${file[0]}:\\**\\`;
+    }
+    if (/^.:\\snapshot\\/.test(file)) {
+        return `${file[0]}:\\**${file.slice(11)}`;
+    }
+    if (/^\/snapshot$/.test(file)) {
+        return '/**/';
+    }
+    if (/^\/snapshot\//.test(file)) {
+        return `/**${file.slice(9)}`;
+    }
+    return f; // not inside
+}
+exports.stripSnapshot = stripSnapshot;
+function removeUplevels(f) {
+    if (win32) {
+        while (true) {
+            if (f.slice(0, 3) === '..\\') {
+                f = f.slice(3);
+            }
+            else if (f === '..') {
+                f = '.';
+            }
+            else {
+                break;
+            }
+        }
+        return f;
+    }
+    while (true) {
+        if (f.slice(0, 3) === '../') {
+            f = f.slice(3);
+        }
+        else if (f === '..') {
+            f = '.';
+        }
+        else {
+            break;
+        }
+    }
+    return f;
+}
+exports.removeUplevels = removeUplevels;
+function toNormalizedRealPath(requestPath) {
+    const file = normalizePath(requestPath);
+    if (fs_1.default.existsSync(file)) {
+        return fs_1.default.realpathSync(file);
+    }
+    return file;
+}
+exports.toNormalizedRealPath = toNormalizedRealPath;
+/**
+ * Find the nearest package.json file by walking up the directory tree
+ * @param filePath - Starting file path
+ * @returns Path to package.json or null if not found
+ */
+function findNearestPackageJson(filePath) {
+    let dir = path_1.default.dirname(filePath);
+    const { root } = path_1.default.parse(dir);
+    while (dir !== root) {
+        const packageJsonPath = path_1.default.join(dir, 'package.json');
+        if (fs_1.default.existsSync(packageJsonPath)) {
+            return packageJsonPath;
+        }
+        dir = path_1.default.dirname(dir);
+    }
+    return null;
+}
+// Caches for ESM detection performance optimization
+const packageJsonCache = new Map();
+const esmPackageCache = new Map();
+/**
+ * Check if a package.json indicates an ESM package
+ * @param packageJsonPath - Path to package.json
+ * @returns true if "type": "module" is set
+ */
+function isESMPackage(packageJsonPath) {
+    // Check cache first
+    if (esmPackageCache.has(packageJsonPath)) {
+        return esmPackageCache.get(packageJsonPath);
+    }
+    try {
+        const content = fs_1.default.readFileSync(packageJsonPath, 'utf8');
+        const pkg = JSON.parse(content);
+        const result = pkg.type === 'module';
+        esmPackageCache.set(packageJsonPath, result);
+        return result;
+    }
+    catch {
+        esmPackageCache.set(packageJsonPath, false);
+        return false;
+    }
+}
+exports.isESMPackage = isESMPackage;
+/**
+ * Determine if a file should be treated as ESM
+ * Based on file extension and nearest package.json "type" field
+ *
+ * @param filePath - The file path to check
+ * @returns true if file should be treated as ESM
+ */
+function isESMFile(filePath) {
+    // .mjs files are always ESM
+    if (filePath.endsWith('.mjs')) {
+        return true;
+    }
+    // .cjs files are never ESM
+    if (filePath.endsWith('.cjs')) {
+        return false;
+    }
+    // For .js files, check nearest package.json for "type": "module"
+    if (filePath.endsWith('.js')) {
+        const dir = path_1.default.dirname(filePath);
+        // Check cache first
+        if (packageJsonCache.has(dir)) {
+            const cached = packageJsonCache.get(dir);
+            if (cached) {
+                return isESMPackage(cached);
+            }
+            return false;
+        }
+        // Compute and cache
+        const packageJsonPath = findNearestPackageJson(filePath);
+        packageJsonCache.set(dir, packageJsonPath);
+        if (packageJsonPath) {
+            return isESMPackage(packageJsonPath);
+        }
+    }
+    return false;
+}
+exports.isESMFile = isESMFile;
+//# sourceMappingURL=common.js.map