@hakobu/hakobu 1.0.0

package/lib-es5/analyzer.js

@@ -0,0 +1,687 @@
+"use strict";
+/**
+ * Hakobu Project Analyzer
+ *
+ * Analyzes a Node.js project and produces a normalized PackagingManifest.
+ * This is the bridge between user config and the packaging pipeline.
+ *
+ * ESM-first: follows Node 24 semantics. .js format is determined by the
+ * nearest package.json "type" field. Packages with "exports" are flagged
+ * when the analyzer cannot fully resolve them.
+ */
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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.analyze = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const babel = __importStar(require("@babel/parser"));
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const exports_resolver_1 = require("./exports-resolver");
+// ─────────────────────────────────────────────────────────────────────
+// Diagnostic helper
+// ─────────────────────────────────────────────────────────────────────
+function diag(severity, category, message, file, suggestion) {
+    return { severity, category, message, file, suggestion };
+}
+const packageJsonCache = new Map();
+// ─────────────────────────────────────────────────────────────────────
+// Package.json utilities
+// ─────────────────────────────────────────────────────────────────────
+function findNearestPackageJson(fromDir) {
+    const root = path_1.default.parse(fromDir).root;
+    let dir = fromDir;
+    const visited = [];
+    while (dir !== root) {
+        if (packageJsonCache.has(dir)) {
+            const cached = packageJsonCache.get(dir);
+            for (const d of visited)
+                packageJsonCache.set(d, cached);
+            return cached;
+        }
+        visited.push(dir);
+        const pjPath = path_1.default.join(dir, 'package.json');
+        if (fs_1.default.existsSync(pjPath)) {
+            try {
+                const data = JSON.parse(fs_1.default.readFileSync(pjPath, 'utf8'));
+                const result = { path: pjPath, data };
+                for (const d of visited)
+                    packageJsonCache.set(d, result);
+                return result;
+            }
+            catch {
+                // Invalid JSON — keep walking
+            }
+        }
+        dir = path_1.default.dirname(dir);
+    }
+    for (const d of visited)
+        packageJsonCache.set(d, null);
+    return null;
+}
+function readPackageJson(pjPath) {
+    try {
+        return JSON.parse(fs_1.default.readFileSync(pjPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+// ─────────────────────────────────────────────────────────────────────
+// Module format detection (Node 24 semantics)
+// ─────────────────────────────────────────────────────────────────────
+function detectModuleFormat(filePath, explicitFormat) {
+    if (explicitFormat) {
+        return { format: explicitFormat, source: 'explicit' };
+    }
+    const ext = path_1.default.extname(filePath);
+    // Node 24 rule 1: .mjs → always ESM
+    if (ext === '.mjs')
+        return { format: 'esm', source: 'extension' };
+    // Node 24 rule 2: .cjs → always CJS
+    if (ext === '.cjs')
+        return { format: 'cjs', source: 'extension' };
+    // Node 24 rule 3: .js → check nearest package.json "type"
+    const pj = findNearestPackageJson(path_1.default.dirname(filePath));
+    if (pj?.data.type === 'module')
+        return { format: 'esm', source: 'package-type' };
+    // Default: CJS (Node's default when no "type" field)
+    return { format: 'cjs', source: 'package-type' };
+}
+// ─────────────────────────────────────────────────────────────────────
+// File classification
+// ─────────────────────────────────────────────────────────────────────
+/**
+ * Recursively walk a directory and call the callback for each file.
+ */
+function walkDirRecursive(dir, cb) {
+    let entries;
+    try {
+        entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walkDirRecursive(fullPath, cb);
+        }
+        else if (entry.isFile()) {
+            cb(fullPath);
+        }
+    }
+}
+function classifyFile(filePath) {
+    const ext = path_1.default.extname(filePath);
+    const base = path_1.default.basename(filePath);
+    if (base === 'package.json')
+        return 'package-json';
+    if (ext === '.node')
+        return 'native-addon';
+    if (ext === '.wasm')
+        return 'wasm';
+    if (ext === '.json')
+        return 'json';
+    if (['.js', '.mjs', '.cjs'].includes(ext))
+        return 'script';
+    return 'asset';
+}
+// ─────────────────────────────────────────────────────────────────────
+// Snapshot path computation
+// ─────────────────────────────────────────────────────────────────────
+function toSnapshotPath(absolutePath, projectRoot, appId) {
+    const relative = path_1.default.relative(projectRoot, absolutePath);
+    const posix = relative.split(path_1.default.sep).join('/');
+    return `/snapshot/${appId}/${posix}`;
+}
+function extractDependencies(filePath, format) {
+    let source;
+    try {
+        source = fs_1.default.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    /**
+     * Try to extract a directory hint from a dynamic require argument.
+     * Recognizes patterns like:
+     *   path.join(__dirname, 'models', variable)  → 'models'
+     *   __dirname + '/models/' + variable         → 'models'
+     */
+    function extractDirHint(node) {
+        // path.join(__dirname, 'subdir', ...)
+        if (node.type === 'CallExpression' &&
+            node.callee?.type === 'MemberExpression' &&
+            node.callee.property?.name === 'join' &&
+            node.arguments?.length >= 3) {
+            const args = node.arguments;
+            if (args[0]?.type === 'Identifier' && args[0].name === '__dirname' &&
+                args[1]?.type === 'StringLiteral') {
+                return args[1].value;
+            }
+        }
+        // __dirname + '/subdir/' + ... (BinaryExpression with string concat)
+        if (node.type === 'BinaryExpression' && node.operator === '+') {
+            const left = node.left;
+            if (left?.type === 'BinaryExpression' && left.operator === '+') {
+                if (left.left?.type === 'Identifier' && left.left.name === '__dirname' &&
+                    left.right?.type === 'StringLiteral') {
+                    const dir = left.right.value.replace(/^\/|\/$/g, '');
+                    if (dir)
+                        return dir;
+                }
+            }
+        }
+        return undefined;
+    }
+    const deps = [];
+    try {
+        const ast = babel.parse(source, {
+            sourceType: format === 'esm' ? 'module' : 'script',
+            plugins: ['importMeta', 'dynamicImport'],
+            allowImportExportEverywhere: true,
+            allowReturnOutsideFunction: true,
+            errorRecovery: true,
+        });
+        (0, traverse_1.default)(ast, {
+            ImportDeclaration(p) {
+                deps.push({ specifier: p.node.source.value, dynamic: false, kind: 'import' });
+            },
+            CallExpression(p) {
+                const { callee, arguments: args } = p.node;
+                // require(...)
+                if (callee.type === 'Identifier' && callee.name === 'require' && args.length >= 1) {
+                    if (args[0].type === 'StringLiteral') {
+                        deps.push({ specifier: args[0].value, dynamic: false, kind: 'require' });
+                    }
+                    else {
+                        // Try to extract directory hint from path.join(__dirname, 'subdir', variable)
+                        const dirHint = extractDirHint(args[0]);
+                        deps.push({ specifier: '<dynamic>', dynamic: true, kind: 'require', dirHint });
+                    }
+                }
+                // import(...)
+                if (callee.type === 'Import' && args.length >= 1) {
+                    if (args[0].type === 'StringLiteral') {
+                        deps.push({ specifier: args[0].value, dynamic: false, kind: 'import-dynamic' });
+                    }
+                    else {
+                        deps.push({ specifier: '<dynamic>', dynamic: true, kind: 'import-dynamic' });
+                    }
+                }
+            },
+            ExportNamedDeclaration(p) {
+                if (p.node.source) {
+                    deps.push({ specifier: p.node.source.value, dynamic: false, kind: 'export-from' });
+                }
+            },
+            ExportAllDeclaration(p) {
+                deps.push({ specifier: p.node.source.value, dynamic: false, kind: 'export-from' });
+            },
+        });
+    }
+    catch {
+        // Parse failure — return what we have
+    }
+    return deps;
+}
+// ─────────────────────────────────────────────────────────────────────
+// Module resolution (ESM-aware)
+// ─────────────────────────────────────────────────────────────────────
+const builtinSet = new Set([
+    'assert', 'async_hooks', 'buffer', 'child_process', 'cluster',
+    'console', 'constants', 'crypto', 'dgram', 'diagnostics_channel',
+    'dns', 'domain', 'events', 'fs', 'http', 'http2', 'https',
+    'inspector', 'module', 'net', 'os', 'path', 'perf_hooks',
+    'process', 'punycode', 'querystring', 'readline', 'repl',
+    'stream', 'string_decoder', 'sys', 'test', 'timers', 'tls',
+    'trace_events', 'tty', 'url', 'util', 'v8', 'vm', 'wasi',
+    'worker_threads', 'zlib', 'sqlite',
+]);
+function isBuiltin(specifier) {
+    return specifier.startsWith('node:') || builtinSet.has(specifier.split('/')[0]);
+}
+const RESOLVE_EXTENSIONS = ['.js', '.mjs', '.cjs', '.json', '.node'];
+function resolveRelative(specifier, fromDir) {
+    const base = path_1.default.resolve(fromDir, specifier);
+    if (fs_1.default.existsSync(base) && fs_1.default.statSync(base).isFile())
+        return base;
+    for (const ext of RESOLVE_EXTENSIONS) {
+        const withExt = base + ext;
+        if (fs_1.default.existsSync(withExt) && fs_1.default.statSync(withExt).isFile())
+            return withExt;
+    }
+    if (fs_1.default.existsSync(base) && fs_1.default.statSync(base).isDirectory()) {
+        for (const ext of RESOLVE_EXTENSIONS) {
+            const indexFile = path_1.default.join(base, `index${ext}`);
+            if (fs_1.default.existsSync(indexFile))
+                return indexFile;
+        }
+        const dirPj = path_1.default.join(base, 'package.json');
+        if (fs_1.default.existsSync(dirPj)) {
+            const pj = readPackageJson(dirPj);
+            if (pj?.main) {
+                const mainPath = path_1.default.resolve(base, pj.main);
+                if (fs_1.default.existsSync(mainPath))
+                    return mainPath;
+                for (const ext of RESOLVE_EXTENSIONS) {
+                    if (fs_1.default.existsSync(mainPath + ext))
+                        return mainPath + ext;
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Resolve a bare package specifier. ESM-aware: when a package has an
+ * "exports" field, the analyzer flags that it used legacy fallback
+ * resolution, which may produce incorrect results for ESM-only exports.
+ */
+function resolvePackage(specifier, fromFile, warnings, conditions = exports_resolver_1.CJS_CONDITIONS) {
+    const pkgName = specifier.startsWith('@')
+        ? specifier.split('/').slice(0, 2).join('/')
+        : specifier.split('/')[0];
+    const subpath = specifier.slice(pkgName.length) || '.';
+    let dir = path_1.default.dirname(fromFile);
+    const root = path_1.default.parse(dir).root;
+    while (dir !== root) {
+        const pkgDir = path_1.default.join(dir, 'node_modules', pkgName);
+        if (fs_1.default.existsSync(pkgDir)) {
+            const pkgJsonPath = path_1.default.join(pkgDir, 'package.json');
+            const pj = fs_1.default.existsSync(pkgJsonPath) ? readPackageJson(pkgJsonPath) : null;
+            const hasExports = pj?.exports != null;
+            // ── Exports map resolution ──
+            // When "exports" is present, Node uses ONLY the exports map.
+            // "main" is ignored for bare specifiers.
+            if (hasExports) {
+                const normalizedSubpath = '.' + specifier.slice(pkgName.length);
+                const exportsResult = (0, exports_resolver_1.resolveExports)(pj.exports, normalizedSubpath, conditions);
+                if (exportsResult && typeof exportsResult === 'string') {
+                    const resolved = resolveRelative(exportsResult, pkgDir);
+                    if (resolved)
+                        return resolved;
+                }
+                // exports present but couldn't resolve — do NOT fall back to main/index
+                warnings.push(diag('warning', 'exports-not-resolved', `Could not resolve '${specifier}' via exports map in '${pkgName}'.`, fromFile, `Check that the exports map exposes this subpath.`));
+                return null;
+            }
+            // ── Legacy resolution (no exports) ──
+            if (subpath === '.') {
+                if (pj?.main) {
+                    const resolved = resolveRelative(pj.main, pkgDir);
+                    if (resolved)
+                        return resolved;
+                }
+                const resolved = resolveRelative('./index', pkgDir);
+                if (resolved)
+                    return resolved;
+            }
+            else {
+                const resolved = resolveRelative(subpath, pkgDir);
+                if (resolved)
+                    return resolved;
+            }
+            warnings.push(diag('warning', 'unresolved-import', `Could not resolve '${specifier}' within ${pkgDir}`, fromFile, 'Check that the package exports this path.'));
+            return null;
+        }
+        dir = path_1.default.dirname(dir);
+    }
+    warnings.push(diag('warning', 'unresolved-import', `Package '${pkgName}' not found in node_modules`, fromFile, `Run 'npm install' or 'pnpm install' to install dependencies.`));
+    return null;
+}
+function resolveSpecifier(specifier, fromFile, warnings, depKind = 'require') {
+    if (isBuiltin(specifier))
+        return null;
+    // Choose conditions based on caller context
+    const conditions = depKind === 'require' ? exports_resolver_1.CJS_CONDITIONS : exports_resolver_1.ESM_CONDITIONS;
+    // #-prefixed package imports
+    if (specifier.startsWith('#')) {
+        const pj = findNearestPackageJson(path_1.default.dirname(fromFile));
+        if (pj?.data.imports) {
+            const resolved = (0, exports_resolver_1.resolveImports)(pj.data.imports, specifier, conditions);
+            if (resolved && typeof resolved === 'string') {
+                const pkgDir = path_1.default.dirname(pj.path);
+                return resolveRelative(resolved, pkgDir);
+            }
+        }
+        warnings.push(diag('warning', 'imports-not-resolved', `Could not resolve '${specifier}' via imports map.`, fromFile, `Check that the nearest package.json has an "imports" entry for '${specifier}'.`));
+        return null;
+    }
+    if (specifier.startsWith('.') || specifier.startsWith('/')) {
+        return resolveRelative(specifier, path_1.default.dirname(fromFile));
+    }
+    return resolvePackage(specifier, fromFile, warnings, conditions);
+}
+// ─────────────────────────────────────────────────────────────────────
+// Package boundary detection
+// ─────────────────────────────────────────────────────────────────────
+function findPackageBoundary(filePath, projectRoot) {
+    const pj = findNearestPackageJson(path_1.default.dirname(filePath));
+    if (!pj)
+        return null;
+    if (!pj.path.startsWith(projectRoot))
+        return null;
+    return pj.path;
+}
+// ─────────────────────────────────────────────────────────────────────
+// Main analyzer
+// ─────────────────────────────────────────────────────────────────────
+async function analyze(options) {
+    const projectRoot = fs_1.default.realpathSync(options.projectRoot);
+    const warnings = [];
+    packageJsonCache.clear();
+    // ── 1. Resolve project package.json ──
+    const rootPjPath = path_1.default.join(projectRoot, 'package.json');
+    const rootPj = fs_1.default.existsSync(rootPjPath) ? readPackageJson(rootPjPath) : null;
+    const appId = rootPj?.name?.replace(/^@[^/]+\//, '') || path_1.default.basename(projectRoot);
+    // ── Legacy pkg config diagnostic ──
+    if (rootPj?.pkg) {
+        warnings.push(diag('info', 'legacy-pkg-config', `package.json contains a "pkg" configuration section. ` +
+            `Hakobu does not yet read legacy pkg config fields (scripts, assets).`, rootPjPath, `Migrate to Hakobu config format or use --assets / --entry CLI flags. ` +
+            `Legacy "pkg.scripts" and "pkg.assets" globs will be supported in a future release.`));
+    }
+    // ── Root-level imports map diagnostic ──
+    if (rootPj?.imports) {
+        warnings.push(diag('warning', 'imports-not-resolved', `Project package.json uses "imports" (subpath imports). ` +
+            `#-prefixed specifiers in your code may not resolve correctly in the packaged app.`, rootPjPath, `Subpath imports resolution will be implemented before native ESM support is complete.`));
+    }
+    // ── 2. Resolve entrypoint ──
+    let entryPath;
+    if (options.entry) {
+        entryPath = path_1.default.isAbsolute(options.entry)
+            ? options.entry
+            : path_1.default.resolve(projectRoot, options.entry);
+    }
+    else if (rootPj?.exports) {
+        // If the project has "exports", use it to find the entry
+        // For now, only handle the simple case: exports = "./file.js" or exports.".".default
+        const entryFromExports = resolveExportsEntry(rootPj.exports, projectRoot);
+        if (entryFromExports) {
+            entryPath = entryFromExports;
+        }
+        else if (rootPj?.main) {
+            entryPath = path_1.default.resolve(projectRoot, rootPj.main);
+            warnings.push(diag('warning', 'exports-not-resolved', `Project has an "exports" field but Hakobu could not extract the entry from it. ` +
+                `Falling back to "main": "${rootPj.main}".`, rootPjPath, `For complex exports maps, specify the entry explicitly with --entry.`));
+        }
+        else {
+            entryPath = path_1.default.resolve(projectRoot, 'index.js');
+        }
+    }
+    else if (rootPj?.main) {
+        entryPath = path_1.default.resolve(projectRoot, rootPj.main);
+    }
+    else {
+        entryPath = path_1.default.resolve(projectRoot, 'index.js');
+    }
+    if (!fs_1.default.existsSync(entryPath)) {
+        throw new Error(`Entrypoint not found: ${entryPath}\n` +
+            `Specify an entry via --entry or set "main" in package.json.`);
+    }
+    entryPath = fs_1.default.realpathSync(entryPath);
+    const { format: entryFormat, source: entryFormatSource } = detectModuleFormat(entryPath, options.format);
+    const entry = {
+        absolutePath: entryPath,
+        snapshotPath: toSnapshotPath(entryPath, projectRoot, appId),
+        format: entryFormat,
+        formatSource: entryFormatSource,
+    };
+    // ── 3. Walk dependency graph ──
+    const files = {};
+    const packagesMap = {};
+    const nativeAddons = [];
+    const visited = new Set();
+    function addFile(absolutePath, kindOverride) {
+        const realPath = fs_1.default.realpathSync(absolutePath);
+        if (visited.has(realPath))
+            return null;
+        visited.add(realPath);
+        if (!realPath.startsWith(projectRoot)) {
+            warnings.push(diag('warning', 'unsupported-feature', `File outside project root: ${realPath}`, realPath, 'Ensure all dependencies are installed within the project.'));
+            return null;
+        }
+        const snapshotPath = toSnapshotPath(realPath, projectRoot, appId);
+        const kind = kindOverride || classifyFile(realPath);
+        const pjBoundary = findPackageBoundary(realPath, projectRoot);
+        const boundarySnapshot = pjBoundary ? toSnapshotPath(pjBoundary, projectRoot, appId) : null;
+        let format = null;
+        if (kind === 'script') {
+            format = detectModuleFormat(realPath).format;
+        }
+        const file = {
+            absolutePath: realPath,
+            snapshotPath,
+            kind,
+            format,
+            packageBoundary: boundarySnapshot,
+        };
+        files[snapshotPath] = file;
+        if (kind === 'package-json') {
+            const pjData = readPackageJson(realPath);
+            if (pjData) {
+                packagesMap[snapshotPath] = {
+                    snapshotPath,
+                    name: pjData.name ?? null,
+                    version: pjData.version ?? null,
+                    type: (pjData.type === 'module' ? 'module' : pjData.type === 'commonjs' ? 'commonjs' : null),
+                    main: pjData.main ?? null,
+                    exports: pjData.exports ?? null,
+                    imports: pjData.imports ?? null,
+                    dependencies: pjData.dependencies ?? null,
+                };
+            }
+        }
+        if (kind === 'native-addon') {
+            // Compute content hash for deterministic extraction path
+            const addonContent = fs_1.default.readFileSync(realPath);
+            const addonHash = require('crypto')
+                .createHash('sha256')
+                .update(addonContent)
+                .digest('hex');
+            nativeAddons.push({
+                snapshotPath,
+                absolutePath: realPath,
+                contentHash: addonHash,
+                targetPlatform: null,
+                targetArch: null,
+            });
+            // Auto-include all files in the native addon's package directory.
+            // Native packages (sharp, drivelist, etc.) often read sibling files
+            // (vendor configs, data files) via fs.readFileSync() at runtime.
+            // The prelude's dlopen patch copies the entire package directory to
+            // the extraction cache, so we must ensure all files are in the snapshot.
+            const addonDir = path_1.default.dirname(realPath);
+            const addonParts = addonDir.split(path_1.default.sep);
+            const nmIndex = addonParts.lastIndexOf('node_modules');
+            if (nmIndex >= 0 && nmIndex + 1 < addonParts.length) {
+                // Determine package root: node_modules/@scope/pkg or node_modules/pkg
+                let pkgRootIdx = nmIndex + 1;
+                if (addonParts[pkgRootIdx]?.startsWith('@') && pkgRootIdx + 1 < addonParts.length) {
+                    pkgRootIdx += 1; // scoped package
+                }
+                const pkgRoot = addonParts.slice(0, pkgRootIdx + 1).join(path_1.default.sep);
+                if (fs_1.default.existsSync(pkgRoot)) {
+                    walkDirRecursive(pkgRoot, (filePath) => {
+                        if (!visited.has(filePath)) {
+                            addFile(filePath);
+                        }
+                    });
+                }
+            }
+        }
+        return file;
+    }
+    function walkFile(absolutePath) {
+        const file = addFile(absolutePath);
+        if (!file)
+            return;
+        if (file.kind !== 'script')
+            return;
+        const pjBoundary = findPackageBoundary(absolutePath, projectRoot);
+        if (pjBoundary && !visited.has(fs_1.default.realpathSync(pjBoundary))) {
+            addFile(pjBoundary);
+        }
+        const deps = extractDependencies(absolutePath, file.format);
+        for (const dep of deps) {
+            // ── Dynamic specifier diagnostics ──
+            if (dep.dynamic) {
+                const category = dep.kind === 'require' ? 'dynamic-require' : 'dynamic-import';
+                let suggestion;
+                if (dep.dirHint && dep.kind === 'require') {
+                    suggestion = `Detected directory pattern: "${dep.dirHint}". ` +
+                        `Add to hakobu config: { "assets": ["${dep.dirHint}/**/*.js"] }`;
+                }
+                else if (dep.kind === 'require') {
+                    suggestion = `If the required module is known, add it to the assets list explicitly. ` +
+                        `Example: { "hakobu": { "assets": ["path/to/module.js"] } }`;
+                }
+                else {
+                    suggestion = `If the imported module is known, add it as a static import or to the assets list.`;
+                }
+                warnings.push(diag('warning', category, `${dep.kind}() with non-literal argument in ${path_1.default.basename(absolutePath)}. ` +
+                    `Hakobu cannot trace dynamic ${dep.kind === 'require' ? 'require' : 'import'} targets statically.`, absolutePath, suggestion));
+                continue;
+            }
+            const resolved = resolveSpecifier(dep.specifier, absolutePath, warnings, dep.kind);
+            if (resolved) {
+                walkFile(resolved);
+            }
+        }
+    }
+    walkFile(entryPath);
+    if (rootPj && fs_1.default.existsSync(rootPjPath)) {
+        addFile(rootPjPath);
+    }
+    // ── 4. Resolve asset globs ──
+    if (options.assets && options.assets.length > 0) {
+        for (const pattern of options.assets) {
+            const assetPath = path_1.default.resolve(projectRoot, pattern);
+            if (fs_1.default.existsSync(assetPath) && fs_1.default.statSync(assetPath).isFile()) {
+                // Direct file path
+                addFile(assetPath, 'asset');
+            }
+            else {
+                // Try as glob using tinyglobby.
+                // When the pattern or cwd contains glob-special characters
+                // (brackets, parens, etc.), we resolve the directory prefix
+                // first and glob from within it to avoid misinterpretation.
+                try {
+                    const { globSync } = require('tinyglobby');
+                    // Extract the directory prefix from the pattern (e.g., "models/**" → "models")
+                    const firstWild = pattern.search(/[*?{]/);
+                    let globCwd = projectRoot;
+                    let globPattern = pattern;
+                    if (firstWild > 0) {
+                        const prefix = pattern.slice(0, firstWild);
+                        const lastSep = prefix.lastIndexOf('/');
+                        if (lastSep >= 0) {
+                            const dirPrefix = prefix.slice(0, lastSep);
+                            const resolvedDir = path_1.default.resolve(projectRoot, dirPrefix);
+                            if (fs_1.default.existsSync(resolvedDir) && fs_1.default.statSync(resolvedDir).isDirectory()) {
+                                globCwd = resolvedDir;
+                                globPattern = pattern.slice(lastSep + 1);
+                            }
+                        }
+                    }
+                    const matches = globSync(globPattern, { cwd: globCwd, absolute: true });
+                    for (const match of matches) {
+                        try {
+                            if (fs_1.default.statSync(match).isFile()) {
+                                addFile(match, 'asset');
+                            }
+                        }
+                        catch { }
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+    // ── 5. Build externals ──
+    const externals = (options.externals ?? []).map((pattern) => ({
+        name: pattern,
+        pattern,
+        required: false,
+    }));
+    // ── 6. Assemble manifest ──
+    return {
+        projectRoot,
+        appId,
+        entry,
+        files,
+        packages: packagesMap,
+        nativeAddons,
+        externals,
+        targets: options.targets ?? [],
+        bundleMode: null,
+        compression: options.compression ?? 'none',
+        runtimeFlags: options.runtimeFlags ?? [],
+        warnings,
+    };
+}
+exports.analyze = analyze;
+// ─────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────
+/**
+ * Try to extract a single entry file from a package.json "exports" field.
+ * Handles the simplest common cases only:
+ *   exports: "./file.js"
+ *   exports: { ".": "./file.js" }
+ *   exports: { ".": { "default": "./file.js" } }
+ *   exports: { ".": { "import": "./file.js" } }
+ */
+function resolveExportsEntry(exports, projectRoot) {
+    if (typeof exports === 'string') {
+        const resolved = path_1.default.resolve(projectRoot, exports);
+        return fs_1.default.existsSync(resolved) ? resolved : null;
+    }
+    if (typeof exports === 'object' && exports !== null && !Array.isArray(exports)) {
+        const map = exports;
+        // { ".": ... }
+        const dotEntry = map['.'];
+        if (typeof dotEntry === 'string') {
+            const resolved = path_1.default.resolve(projectRoot, dotEntry);
+            return fs_1.default.existsSync(resolved) ? resolved : null;
+        }
+        // { ".": { "import": "...", "default": "..." } }
+        if (typeof dotEntry === 'object' && dotEntry !== null) {
+            const conditions = dotEntry;
+            for (const key of ['import', 'require', 'node', 'default']) {
+                if (typeof conditions[key] === 'string') {
+                    const resolved = path_1.default.resolve(projectRoot, conditions[key]);
+                    if (fs_1.default.existsSync(resolved))
+                        return resolved;
+                }
+            }
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=analyzer.js.map