@openrewrite/rewrite 8.68.0-20251202-082117 → 8.68.0-20251202-162533

package/dist/javascript/node-resolution-result.js

@@ -0,0 +1,723 @@
+"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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeResolutionResultQueries = exports.NpmrcKind = exports.NpmrcScope = exports.PackageManager = exports.ResolvedDependencyKind = exports.DependencyKind = exports.NodeResolutionResultKind = void 0;
+exports.createNodeResolutionResultMarker = createNodeResolutionResultMarker;
+exports.findNodeResolutionResult = findNodeResolutionResult;
+exports.readNpmrcConfigs = readNpmrcConfigs;
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const markers_1 = require("../markers");
+const uuid_1 = require("../uuid");
+const reference_1 = require("../reference");
+const rpc_1 = require("../rpc");
+const immer_1 = require("immer");
+const semver = __importStar(require("semver"));
+const fsp = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const os_1 = require("os");
+exports.NodeResolutionResultKind = "org.openrewrite.javascript.marker.NodeResolutionResult";
+exports.DependencyKind = "org.openrewrite.javascript.marker.NodeResolutionResult$Dependency";
+exports.ResolvedDependencyKind = "org.openrewrite.javascript.marker.NodeResolutionResult$ResolvedDependency";
+/**
+ * Represents the package manager used by a Node.js project.
+ */
+var PackageManager;
+(function (PackageManager) {
+    PackageManager["Npm"] = "Npm";
+    PackageManager["YarnClassic"] = "YarnClassic";
+    PackageManager["YarnBerry"] = "YarnBerry";
+    PackageManager["Pnpm"] = "Pnpm";
+    PackageManager["Bun"] = "Bun";
+})(PackageManager || (exports.PackageManager = PackageManager = {}));
+/**
+ * Represents the scope/source of an npmrc configuration.
+ * Listed from lowest to highest priority.
+ */
+var NpmrcScope;
+(function (NpmrcScope) {
+    NpmrcScope["Global"] = "Global";
+    NpmrcScope["User"] = "User";
+    NpmrcScope["Project"] = "Project";
+})(NpmrcScope || (exports.NpmrcScope = NpmrcScope = {}));
+exports.NpmrcKind = "org.openrewrite.javascript.marker.NodeResolutionResult$Npmrc";
+/**
+ * Creates a NodeResolutionResult marker from a package.json file.
+ * Should be called during parsing to attach to JS.CompilationUnit.
+ *
+ * All Dependency instances are wrapped with asRef() to enable
+ * reference deduplication during RPC serialization.
+ *
+ * @param path Path to the package.json file
+ * @param packageJsonContent Parsed package.json content
+ * @param packageLockContent Optional parsed package-lock.json content for resolution info
+ * @param workspacePackagePaths Optional resolved paths to workspace package.json files (only for workspace root)
+ * @param packageManager Optional package manager that was detected from lock file
+ * @param npmrcConfigs Optional npm configuration from various scopes
+ */
+function createNodeResolutionResultMarker(path, packageJsonContent, packageLockContent, workspacePackagePaths, packageManager, npmrcConfigs) {
+    // Cache for deduplicating resolved dependencies with the same name+version.
+    const resolvedDependencyCache = new Map();
+    // Index from package name to all resolved versions (for O(1) semver fallback lookup)
+    const nameToResolved = new Map();
+    // Map from lock file path to ResolvedDependency for path-based lookups.
+    // e.g., "node_modules/is-odd" -> ResolvedDependency for is-odd@3.0.1
+    const pathToResolved = new Map();
+    // Cache for deduplicating dependencies with the same name+versionConstraint+contextPath.
+    const dependencyCache = new Map();
+    /**
+     * Normalizes the engines field from package-lock.json.
+     * Some older packages have engines as an array like ["node >=0.6.0"] instead of
+     * the standard object format {"node": ">=0.6.0"}.
+     */
+    function normalizeEngines(engines) {
+        if (!engines)
+            return undefined;
+        if (Array.isArray(engines)) {
+            // Convert array format to object format
+            // e.g., ["node >=0.6.0"] -> {"node": ">=0.6.0"}
+            const result = {};
+            for (const entry of engines) {
+                const spaceIdx = entry.indexOf(' ');
+                if (spaceIdx > 0) {
+                    const key = entry.substring(0, spaceIdx);
+                    result[key] = entry.substring(spaceIdx + 1);
+                }
+            }
+            return Object.keys(result).length > 0 ? result : undefined;
+        }
+        return engines;
+    }
+    /**
+     * Extracts package name and optionally version from a package-lock.json path.
+     * e.g., "node_modules/@babel/core" -> { name: "@babel/core" }
+     * e.g., "node_modules/foo/node_modules/bar" -> { name: "bar" }
+     * e.g., "node_modules/is-odd@3.0.1" -> { name: "is-odd", version: "3.0.1" }
+     */
+    function extractPackageInfo(pkgPath) {
+        // For nested packages, we want the last package name
+        const nodeModulesIndex = pkgPath.lastIndexOf('node_modules/');
+        if (nodeModulesIndex === -1)
+            return { name: pkgPath };
+        let nameWithVersion = pkgPath.slice(nodeModulesIndex + 'node_modules/'.length);
+        // Check if the path has a version suffix (e.g., "is-odd@3.0.1")
+        // Handle scoped packages (@scope/name@version) correctly
+        const atIndex = nameWithVersion.lastIndexOf('@');
+        if (atIndex > 0 && !nameWithVersion.substring(0, atIndex).includes('/')) {
+            // Not a scoped package, the @ is a version separator
+            return {
+                name: nameWithVersion.substring(0, atIndex),
+                version: nameWithVersion.substring(atIndex + 1)
+            };
+        }
+        else if (atIndex > 0) {
+            // Could be scoped package with version: @scope/name@version
+            const parts = nameWithVersion.split('@');
+            if (parts.length === 3 && parts[0] === '') {
+                // @scope/name@version -> ["", "scope/name", "version"]
+                return {
+                    name: `@${parts[1]}`,
+                    version: parts[2]
+                };
+            }
+        }
+        return { name: nameWithVersion };
+    }
+    /**
+     * Creates or retrieves a ResolvedDependency from the cache.
+     * This ensures the same resolved package is reused across the dependency tree.
+     * Also maintains the nameToResolved index for O(1) name lookups.
+     */
+    function getOrCreateResolvedDependency(name, version, pkgEntry) {
+        const key = `${name}@${version}`;
+        let resolved = resolvedDependencyCache.get(key);
+        if (!resolved) {
+            // Create a placeholder first - dependencies will be populated later
+            resolved = (0, reference_1.asRef)({
+                kind: exports.ResolvedDependencyKind,
+                name,
+                version,
+                dependencies: undefined,
+                devDependencies: undefined,
+                peerDependencies: undefined,
+                optionalDependencies: undefined,
+                engines: normalizeEngines(pkgEntry === null || pkgEntry === void 0 ? void 0 : pkgEntry.engines),
+                license: pkgEntry === null || pkgEntry === void 0 ? void 0 : pkgEntry.license,
+            });
+            resolvedDependencyCache.set(key, resolved);
+            // Maintain name index for O(1) lookup during semver fallback
+            const existing = nameToResolved.get(name);
+            if (existing) {
+                existing.push(resolved);
+            }
+            else {
+                nameToResolved.set(name, [resolved]);
+            }
+        }
+        return resolved;
+    }
+    /**
+     * Resolves a dependency name from a given context path using Node.js-style resolution.
+     * Looks for the package in nested node_modules first, then walks up to parent directories.
+     * Falls back to semver matching when path-based resolution fails (e.g., for yarn/pnpm).
+     *
+     * @param name Package name to resolve
+     * @param versionConstraint Version constraint (e.g., "^3.0.1") for semver fallback
+     * @param contextPath The path of the parent package (e.g., "node_modules/is-even")
+     *                    Use "" for root-level dependencies
+     */
+    function resolveFromContext(name, versionConstraint, contextPath) {
+        // Start from the context path and walk up looking for the package
+        let currentPath = contextPath;
+        while (true) {
+            // Try to find the package in node_modules at this level
+            const candidatePath = currentPath
+                ? `${currentPath}/node_modules/${name}`
+                : `node_modules/${name}`;
+            const resolved = pathToResolved.get(candidatePath);
+            if (resolved) {
+                return resolved;
+            }
+            // Walk up to parent directory
+            if (!currentPath) {
+                break; // Already at root
+            }
+            // Remove the last /node_modules/pkg segment to go up one level
+            const lastNodeModules = currentPath.lastIndexOf('/node_modules/');
+            if (lastNodeModules === -1) {
+                currentPath = ''; // Try root level next
+            }
+            else {
+                currentPath = currentPath.substring(0, lastNodeModules);
+            }
+        }
+        // Fallback: use semver matching to find a version that satisfies the constraint
+        // This is needed for yarn/pnpm which don't encode nesting in their lock files
+        const candidates = nameToResolved.get(name);
+        if (!candidates || candidates.length === 0) {
+            return undefined;
+        }
+        if (candidates.length === 1) {
+            return candidates[0];
+        }
+        // Multiple versions - use semver to find the best match
+        // First try to find one that satisfies the constraint
+        for (const candidate of candidates) {
+            try {
+                if (semver.satisfies(candidate.version, versionConstraint)) {
+                    return candidate;
+                }
+            }
+            catch (_a) {
+                // Invalid semver, skip this candidate for matching
+            }
+        }
+        // If no exact match, return the highest version as fallback (O(n) linear scan)
+        let maxCandidate = candidates[0];
+        for (let i = 1; i < candidates.length; i++) {
+            try {
+                if (semver.compare(candidates[i].version, maxCandidate.version) > 0) {
+                    maxCandidate = candidates[i];
+                }
+            }
+            catch (_b) {
+                // Invalid semver, skip comparison
+            }
+        }
+        return maxCandidate;
+    }
+    /**
+     * Creates or retrieves a Dependency from the cache.
+     * Links to resolved dependency using path-based Node.js-style resolution.
+     *
+     * @param name Package name
+     * @param versionConstraint Version constraint from package.json
+     * @param contextPath The path context for resolution (parent package path)
+     */
+    function getOrCreateDependency(name, versionConstraint, contextPath) {
+        // Resolve first to determine the actual resolved version
+        const resolved = resolveFromContext(name, versionConstraint, contextPath);
+        // Key by name, constraint, and resolved version (not context path).
+        // This allows sharing Dependency objects when different contexts resolve to the same version.
+        const resolvedKey = resolved ? `${resolved.name}@${resolved.version}` : 'unresolved';
+        const key = `${name}@${versionConstraint}@${resolvedKey}`;
+        let dep = dependencyCache.get(key);
+        if (!dep) {
+            dep = (0, reference_1.asRef)({
+                kind: exports.DependencyKind,
+                name,
+                versionConstraint,
+                resolved,
+            });
+            dependencyCache.set(key, dep);
+        }
+        return dep;
+    }
+    /**
+     * Parses dependencies from a Record, using the given context path for resolution.
+     */
+    function parseDependencies(deps, contextPath) {
+        if (!deps)
+            return [];
+        return Object.entries(deps).map(([name, versionConstraint]) => getOrCreateDependency(name, versionConstraint, contextPath));
+    }
+    /**
+     * Parses bundled dependencies (array of names with no version constraint).
+     */
+    function parseBundledDependencies(deps, contextPath) {
+        if (!deps)
+            return [];
+        return deps.map(name => getOrCreateDependency(name, '*', contextPath));
+    }
+    /**
+     * Parses package-lock.json to build a list of resolved dependencies.
+     * Two-pass approach:
+     * 1. First pass: Create all ResolvedDependency objects and build path->resolved map
+     * 2. Second pass: Populate dependencies using path-based resolution
+     */
+    function parseResolutions(lockContent) {
+        if (!lockContent.packages)
+            return [];
+        const packages = lockContent.packages;
+        // First pass: Create all ResolvedDependency placeholders and build path map
+        const packageInfos = [];
+        for (const [pkgPath, pkgEntry] of Object.entries(packages)) {
+            // Skip the root package (empty string key)
+            if (pkgPath === '')
+                continue;
+            const pkgInfo = extractPackageInfo(pkgPath);
+            const name = pkgInfo.name;
+            // Use version from path if available, otherwise from entry
+            const version = pkgInfo.version || pkgEntry.version;
+            if (name && version) {
+                const resolved = getOrCreateResolvedDependency(name, version, pkgEntry);
+                pathToResolved.set(pkgPath, resolved);
+                packageInfos.push({ path: pkgPath, name, version, entry: pkgEntry });
+            }
+        }
+        // Second pass: Populate dependencies using path-based resolution.
+        // Note: Using castDraft here is safe because all objects are created within this
+        // parsing context and haven't been returned to callers yet. The objects in
+        // resolvedDependencyCache are plain JS objects marked with asRef() for RPC
+        // reference deduplication, not frozen Immer drafts.
+        for (const { path: pkgPath, name, version, entry } of packageInfos) {
+            const key = `${name}@${version}`;
+            const resolved = resolvedDependencyCache.get(key);
+            if (resolved) {
+                const mutableResolved = (0, immer_1.castDraft)(resolved);
+                if (entry.dependencies) {
+                    mutableResolved.dependencies = parseDependencies(entry.dependencies, pkgPath);
+                }
+                if (entry.devDependencies) {
+                    mutableResolved.devDependencies = parseDependencies(entry.devDependencies, pkgPath);
+                }
+                if (entry.peerDependencies) {
+                    mutableResolved.peerDependencies = parseDependencies(entry.peerDependencies, pkgPath);
+                }
+                if (entry.optionalDependencies) {
+                    mutableResolved.optionalDependencies = parseDependencies(entry.optionalDependencies, pkgPath);
+                }
+            }
+        }
+        // Return all unique resolved dependencies
+        return Array.from(resolvedDependencyCache.values());
+    }
+    // Parse resolved dependencies first (before dependencies) so we can link them
+    const resolvedDependencies = packageLockContent ? parseResolutions(packageLockContent) : [];
+    // Now parse dependencies from package.json - they resolve from root context ("")
+    const dependencies = parseDependencies(packageJsonContent.dependencies, '');
+    const devDependencies = parseDependencies(packageJsonContent.devDependencies, '');
+    const peerDependencies = parseDependencies(packageJsonContent.peerDependencies, '');
+    const optionalDependencies = parseDependencies(packageJsonContent.optionalDependencies, '');
+    const bundledDependencies = parseBundledDependencies(packageJsonContent.bundledDependencies || packageJsonContent.bundleDependencies, '');
+    return {
+        kind: exports.NodeResolutionResultKind,
+        id: (0, uuid_1.randomId)(),
+        name: packageJsonContent.name,
+        version: packageJsonContent.version,
+        description: packageJsonContent.description,
+        path,
+        workspacePackagePaths,
+        dependencies,
+        devDependencies,
+        peerDependencies,
+        optionalDependencies,
+        bundledDependencies,
+        resolvedDependencies,
+        packageManager,
+        engines: packageJsonContent.engines,
+        npmrcConfigs,
+    };
+}
+/**
+ * Helper function to find a NodeResolutionResult marker on a compilation unit.
+ */
+function findNodeResolutionResult(cu) {
+    return (0, markers_1.findMarker)(cu, exports.NodeResolutionResultKind);
+}
+/**
+ * Parses an .npmrc file content into a key-value map.
+ *
+ * .npmrc format:
+ * - Lines are key=value pairs
+ * - Lines starting with # or ; are comments
+ * - Empty lines are ignored
+ * - Values can contain ${VAR} or ${VAR:-default} for env variable substitution
+ */
+function parseNpmrc(content) {
+    const properties = {};
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        // Skip comments and empty lines
+        if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith(';')) {
+            continue;
+        }
+        // Parse key=value
+        const eqIndex = trimmed.indexOf('=');
+        if (eqIndex === -1)
+            continue;
+        const key = trimmed.substring(0, eqIndex).trim();
+        const value = trimmed.substring(eqIndex + 1).trim();
+        if (key) {
+            properties[key] = value;
+        }
+    }
+    return properties;
+}
+/**
+ * Helper to check if a file exists asynchronously.
+ */
+function fileExists(filePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield fsp.access(filePath);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+/**
+ * Reads .npmrc configurations from all scope levels.
+ * Returns an array of Npmrc objects, one for each scope that has configuration.
+ *
+ * Scopes (from lowest to highest priority):
+ * - Global: $PREFIX/etc/npmrc (npm's installation directory)
+ * - User: $HOME/.npmrc (user's home directory)
+ * - Project: .npmrc in project root (sibling of package.json)
+ * - Env: npm_config_* environment variables
+ *
+ * @param projectDir The project directory containing package.json
+ * @returns Promise resolving to array of Npmrc objects for each scope with configuration
+ */
+function readNpmrcConfigs(projectDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const configs = [];
+        // 1. Global config: $PREFIX/etc/npmrc
+        // Try to get npm prefix from npm itself, fall back to common locations
+        const globalNpmrcPaths = [
+            // Try NPM_CONFIG_GLOBALCONFIG env var first
+            process.env.NPM_CONFIG_GLOBALCONFIG,
+            // Common global locations
+            '/usr/local/etc/npmrc',
+            '/etc/npmrc',
+        ].filter(Boolean);
+        // Also try to detect from npm prefix if node is installed
+        const nodeDir = process.execPath ? path.dirname(path.dirname(process.execPath)) : undefined;
+        if (nodeDir) {
+            globalNpmrcPaths.unshift(path.join(nodeDir, 'etc', 'npmrc'));
+        }
+        for (const globalPath of globalNpmrcPaths) {
+            if (yield fileExists(globalPath)) {
+                try {
+                    const content = yield fsp.readFile(globalPath, 'utf-8');
+                    const properties = parseNpmrc(content);
+                    if (Object.keys(properties).length > 0) {
+                        configs.push({
+                            kind: exports.NpmrcKind,
+                            scope: NpmrcScope.Global,
+                            properties
+                        });
+                        break; // Only use the first found global config
+                    }
+                }
+                catch (_a) {
+                    // Ignore read errors
+                }
+            }
+        }
+        // 2. User config: $HOME/.npmrc
+        const userNpmrcPath = process.env.NPM_CONFIG_USERCONFIG || path.join((0, os_1.homedir)(), '.npmrc');
+        if (yield fileExists(userNpmrcPath)) {
+            try {
+                const content = yield fsp.readFile(userNpmrcPath, 'utf-8');
+                const properties = parseNpmrc(content);
+                if (Object.keys(properties).length > 0) {
+                    configs.push({
+                        kind: exports.NpmrcKind,
+                        scope: NpmrcScope.User,
+                        properties
+                    });
+                }
+            }
+            catch (_b) {
+                // Ignore read errors
+            }
+        }
+        // 3. Project config: .npmrc in project root
+        const projectNpmrcPath = path.join(projectDir, '.npmrc');
+        if (yield fileExists(projectNpmrcPath)) {
+            try {
+                const content = yield fsp.readFile(projectNpmrcPath, 'utf-8');
+                const properties = parseNpmrc(content);
+                if (Object.keys(properties).length > 0) {
+                    configs.push({
+                        kind: exports.NpmrcKind,
+                        scope: NpmrcScope.Project,
+                        properties
+                    });
+                }
+            }
+            catch (_c) {
+                // Ignore read errors
+            }
+        }
+        // Note: We intentionally don't capture npm_config_* environment variables.
+        // While users can set config via env vars, npm also automatically injects
+        // many npm_config_* vars when running child processes, and there's no way
+        // to distinguish user-set vars from npm-injected ones at runtime.
+        return configs;
+    });
+}
+/**
+ * Helper functions for querying dependencies
+ */
+var NodeResolutionResultQueries;
+(function (NodeResolutionResultQueries) {
+    /**
+     * Get all dependency requests from all scopes.
+     */
+    function getAllDependencies(project) {
+        return [
+            ...project.dependencies,
+            ...project.devDependencies,
+            ...project.peerDependencies,
+            ...project.optionalDependencies,
+            ...project.bundledDependencies
+        ];
+    }
+    NodeResolutionResultQueries.getAllDependencies = getAllDependencies;
+    /**
+     * Check if project has a specific dependency request, optionally filtered by scope.
+     */
+    function hasDependency(project, packageName, scope) {
+        const deps = scope
+            ? project[scope]
+            : getAllDependencies(project);
+        return deps.some(dep => dep.name === packageName);
+    }
+    NodeResolutionResultQueries.hasDependency = hasDependency;
+    /**
+     * Find a specific dependency request by name across all scopes.
+     */
+    function findDependency(project, packageName) {
+        return getAllDependencies(project).find(dep => dep.name === packageName);
+    }
+    NodeResolutionResultQueries.findDependency = findDependency;
+    /**
+     * Get all dependency requests matching a predicate.
+     */
+    function findDependencies(project, predicate) {
+        return getAllDependencies(project).filter(predicate);
+    }
+    NodeResolutionResultQueries.findDependencies = findDependencies;
+    /**
+     * Get all resolved dependencies with a specific name (handles multiple versions).
+     * Returns an empty array if no versions are found.
+     *
+     * For navigation, prefer using the Dependency.resolved property:
+     * @example
+     * const express = project.dependencies.find(d => d.name === 'express')?.resolved;
+     * const accepts = express?.dependencies?.find(d => d.name === 'accepts')?.resolved;
+     */
+    function getAllResolvedVersions(project, packageName) {
+        return project.resolvedDependencies.filter(r => r.name === packageName);
+    }
+    NodeResolutionResultQueries.getAllResolvedVersions = getAllResolvedVersions;
+})(NodeResolutionResultQueries || (exports.NodeResolutionResultQueries = NodeResolutionResultQueries = {}));
+/**
+ * Register RPC codec for Npmrc.
+ */
+rpc_1.RpcCodecs.registerCodec(exports.NpmrcKind, {
+    rpcReceive(before, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const draft = (0, immer_1.createDraft)(before);
+            draft.kind = exports.NpmrcKind;
+            draft.scope = yield q.receive(before.scope);
+            draft.properties = yield q.receive(before.properties);
+            return (0, immer_1.finishDraft)(draft);
+        });
+    },
+    rpcSend(after, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield q.getAndSend(after, a => a.scope);
+            yield q.getAndSend(after, a => a.properties);
+        });
+    }
+});
+/**
+ * Register RPC codec for Dependency.
+ */
+rpc_1.RpcCodecs.registerCodec(exports.DependencyKind, {
+    rpcReceive(before, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const draft = (0, immer_1.createDraft)(before);
+            draft.kind = exports.DependencyKind;
+            draft.name = yield q.receive(before.name);
+            draft.versionConstraint = yield q.receive(before.versionConstraint);
+            draft.resolved = yield q.receive(before.resolved);
+            return (0, immer_1.finishDraft)(draft);
+        });
+    },
+    rpcSend(after, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield q.getAndSend(after, a => a.name);
+            yield q.getAndSend(after, a => a.versionConstraint);
+            yield q.getAndSend(after, a => a.resolved);
+        });
+    }
+});
+/**
+ * Register RPC codec for ResolvedDependency.
+ */
+rpc_1.RpcCodecs.registerCodec(exports.ResolvedDependencyKind, {
+    rpcReceive(before, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const draft = (0, immer_1.createDraft)(before);
+            draft.kind = exports.ResolvedDependencyKind;
+            draft.name = yield q.receive(before.name);
+            draft.version = yield q.receive(before.version);
+            draft.dependencies = (yield q.receiveList(before.dependencies)) || undefined;
+            draft.devDependencies = (yield q.receiveList(before.devDependencies)) || undefined;
+            draft.peerDependencies = (yield q.receiveList(before.peerDependencies)) || undefined;
+            draft.optionalDependencies = (yield q.receiveList(before.optionalDependencies)) || undefined;
+            draft.engines = yield q.receive(before.engines);
+            draft.license = yield q.receive(before.license);
+            return (0, immer_1.finishDraft)(draft);
+        });
+    },
+    rpcSend(after, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield q.getAndSend(after, a => a.name);
+            yield q.getAndSend(after, a => a.version);
+            yield q.getAndSendList(after, a => (a.dependencies || []).map(d => (0, reference_1.asRef)(d)), dep => `${dep.name}@${dep.versionConstraint}`);
+            yield q.getAndSendList(after, a => (a.devDependencies || []).map(d => (0, reference_1.asRef)(d)), dep => `${dep.name}@${dep.versionConstraint}`);
+            yield q.getAndSendList(after, a => (a.peerDependencies || []).map(d => (0, reference_1.asRef)(d)), dep => `${dep.name}@${dep.versionConstraint}`);
+            yield q.getAndSendList(after, a => (a.optionalDependencies || []).map(d => (0, reference_1.asRef)(d)), dep => `${dep.name}@${dep.versionConstraint}`);
+            yield q.getAndSend(after, a => a.engines);
+            yield q.getAndSend(after, a => a.license);
+        });
+    }
+});
+/**
+ * Register RPC codec for NodeResolutionResult marker.
+ * This handles serialization/deserialization for communication between JS and Java.
+ */
+rpc_1.RpcCodecs.registerCodec(exports.NodeResolutionResultKind, {
+    rpcReceive(before, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const draft = (0, immer_1.createDraft)(before);
+            draft.id = yield q.receive(before.id);
+            draft.name = yield q.receive(before.name);
+            draft.version = yield q.receive(before.version);
+            draft.description = yield q.receive(before.description);
+            draft.path = yield q.receive(before.path);
+            draft.workspacePackagePaths = yield q.receive(before.workspacePackagePaths);
+            draft.dependencies = (yield q.receiveList(before.dependencies)) || [];
+            draft.devDependencies = (yield q.receiveList(before.devDependencies)) || [];
+            draft.peerDependencies = (yield q.receiveList(before.peerDependencies)) || [];
+            draft.optionalDependencies = (yield q.receiveList(before.optionalDependencies)) || [];
+            draft.bundledDependencies = (yield q.receiveList(before.bundledDependencies)) || [];
+            draft.resolvedDependencies = (yield q.receiveList(before.resolvedDependencies)) || [];
+            draft.packageManager = yield q.receive(before.packageManager);
+            draft.engines = yield q.receive(before.engines);
+            draft.npmrcConfigs = (yield q.receiveList(before.npmrcConfigs)) || undefined;
+            return (0, immer_1.finishDraft)(draft);
+        });
+    },
+    rpcSend(after, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield q.getAndSend(after, a => a.id);
+            yield q.getAndSend(after, a => a.name);
+            yield q.getAndSend(after, a => a.version);
+            yield q.getAndSend(after, a => a.description);
+            yield q.getAndSend(after, a => a.path);
+            yield q.getAndSend(after, a => a.workspacePackagePaths);
+            yield q.getAndSendList(after, a => a.dependencies.map(d => (0, reference_1.asRef)(d)), dep => `${dep.name}@${dep.versionConstraint}`);
+            yield q.getAndSendList(after, a => a.devDependencies.map(d => (0, reference_1.asRef)(d)), dep => `${dep.name}@${dep.versionConstraint}`);
+            yield q.getAndSendList(after, a => a.peerDependencies.map(d => (0, reference_1.asRef)(d)), dep => `${dep.name}@${dep.versionConstraint}`);
+            yield q.getAndSendList(after, a => a.optionalDependencies.map(d => (0, reference_1.asRef)(d)), dep => `${dep.name}@${dep.versionConstraint}`);
+            yield q.getAndSendList(after, a => a.bundledDependencies.map(d => (0, reference_1.asRef)(d)), dep => `${dep.name}@${dep.versionConstraint}`);
+            yield q.getAndSendList(after, a => a.resolvedDependencies.map(r => (0, reference_1.asRef)(r)), resolved => `${resolved.name}@${resolved.version}`);
+            yield q.getAndSend(after, a => a.packageManager);
+            yield q.getAndSend(after, a => a.engines);
+            yield q.getAndSendList(after, a => a.npmrcConfigs || [], npmrc => npmrc.scope);
+        });
+    }
+});
+//# sourceMappingURL=node-resolution-result.js.map