@next/codemod 16.0.0-canary.9 → 16.0.0

package/bin/upgrade.js

@@ -164,7 +164,8 @@ async function runUpgrade(revision, options) {
     const targetReactVersion = shouldStayOnReact18
         ? '18.3.1'
         : await loadHighestNPMVersionMatching(`react@${targetNextPackageJson.peerDependencies['react']}`);
-    if ((0, semver_1.compare)(targetNextVersion, '15.0.0-canary') >= 0) {
+    if ((0, semver_1.compare)(targetNextVersion, '15.0.0-canary') >= 0 &&
+        (0, semver_1.compare)(targetNextVersion, '16.0.0-canary') < 0) {
         await suggestTurbopack(appPackageJson, targetNextVersion);
     }
     const codemods = await suggestCodemods(installedNextVersion, targetNextVersion);

package/lib/utils.js

@@ -122,5 +122,15 @@ exports.TRANSFORMER_INQUIRER_CHOICES = [
         value: 'middleware-to-proxy',
         version: '15.6.0-canary.54',
     },
+    {
+        title: 'Remove `unstable_` prefix from stabilized API',
+        value: 'remove-unstable-prefix',
+        version: '16.0.0-canary.10',
+    },
+    {
+        title: 'Remove `experimental_ppr` Route Segment Config from App Router pages and layouts',
+        value: 'remove-experimental-ppr',
+        version: '16.0.0-canary.11',
+    },
 ];
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next/codemod",
-  "version": "16.0.0-canary.9",
+  "version": "16.0.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/transforms/middleware-to-proxy.js

@@ -45,6 +45,9 @@ function transformer(file) {
     if (isMiddlewareFile) {
         const middlewareChanges = transformMiddlewareFunction(root, j);
         hasChanges = hasChanges || middlewareChanges.hasChanges;
+        // Remove runtime segment config
+        const runtimeChanges = removeRuntimeConfig(root, j);
+        hasChanges = hasChanges || runtimeChanges;
     }
     if (isNextConfig) {
         const { hasConfigChanges } = transformNextConfig(root, j);
@@ -602,4 +605,123 @@ function extractObjectsFromCallExpression(callExpr, configObjects, exportedNames
         });
     }
 }
+function removeRuntimeConfig(root, j) {
+    let hasChanges = false;
+    // Remove export const runtime = 'string'
+    const directRuntimeExports = root.find(j.ExportNamedDeclaration, {
+        declaration: {
+            type: 'VariableDeclaration',
+            declarations: [
+                {
+                    id: { name: 'runtime' },
+                },
+            ],
+        },
+    });
+    if (directRuntimeExports.size() > 0) {
+        directRuntimeExports.remove();
+        hasChanges = true;
+    }
+    // Remove const runtime = 'string' declarations
+    const runtimeVariableDeclarations = root
+        .find(j.VariableDeclaration)
+        .filter((path) => path.node.declarations.some((decl) => {
+        if (j.VariableDeclarator.check(decl) && j.Identifier.check(decl.id)) {
+            return decl.id.name === 'runtime';
+        }
+        return false;
+    }));
+    if (runtimeVariableDeclarations.size() > 0) {
+        runtimeVariableDeclarations.forEach((path) => {
+            const originalDeclarations = path.node.declarations;
+            const filteredDeclarations = originalDeclarations.filter((decl) => {
+                if (j.VariableDeclarator.check(decl) && j.Identifier.check(decl.id)) {
+                    return decl.id.name !== 'runtime';
+                }
+                return true;
+            });
+            // If we filtered out some declarations, update the node
+            if (filteredDeclarations.length !== originalDeclarations.length) {
+                // Remove the entire declaration only if no declarators left
+                if (filteredDeclarations.length === 0) {
+                    j(path).remove();
+                }
+                else {
+                    path.node.declarations = filteredDeclarations;
+                }
+            }
+        });
+        hasChanges = true;
+    }
+    // Handle export { runtime } and export { runtime, other }
+    const namedExports = root
+        .find(j.ExportNamedDeclaration)
+        .filter((path) => path.node.specifiers && path.node.specifiers.length > 0);
+    namedExports.forEach((path) => {
+        const specifiers = path.node.specifiers;
+        if (!specifiers)
+            return;
+        const filteredSpecifiers = specifiers.filter((spec) => {
+            if (j.ExportSpecifier.check(spec) && j.Identifier.check(spec.local)) {
+                return spec.local.name !== 'runtime';
+            }
+            return true;
+        });
+        // If we removed any specifiers
+        if (filteredSpecifiers.length !== specifiers.length) {
+            hasChanges = true;
+            // If no specifiers left, remove the entire export statement
+            if (filteredSpecifiers.length === 0) {
+                j(path).remove();
+            }
+            else {
+                // Update the specifiers array
+                path.node.specifiers = filteredSpecifiers;
+            }
+        }
+    });
+    // Handle runtime property in config objects
+    const configExports = root.find(j.ExportNamedDeclaration, {
+        declaration: {
+            type: 'VariableDeclaration',
+            declarations: [
+                {
+                    id: { name: 'config' },
+                },
+            ],
+        },
+    });
+    configExports.forEach((path) => {
+        const declaration = path.node.declaration;
+        if (j.VariableDeclaration.check(declaration)) {
+            declaration.declarations.forEach((decl) => {
+                if (j.VariableDeclarator.check(decl) &&
+                    j.Identifier.check(decl.id) &&
+                    decl.id.name === 'config' &&
+                    j.ObjectExpression.check(decl.init)) {
+                    const objExpr = decl.init;
+                    const initialLength = objExpr.properties.length;
+                    // Filter out runtime property
+                    objExpr.properties = objExpr.properties.filter((prop) => {
+                        if (isStaticProperty(prop) &&
+                            prop.key &&
+                            prop.key.type === 'Identifier') {
+                            return prop.key.name !== 'runtime';
+                        }
+                        return true;
+                    });
+                    // If we removed any properties
+                    if (objExpr.properties.length !== initialLength) {
+                        hasChanges = true;
+                        // If no properties left, remove the entire config export
+                        if (objExpr.properties.length === 0) {
+                            j(path).remove();
+                        }
+                    }
+                }
+            });
+        }
+    });
+    return hasChanges;
+}
 //# sourceMappingURL=middleware-to-proxy.js.map

package/transforms/next-lint-to-eslint-cli.js

@@ -8,6 +8,7 @@ exports.default = transformer;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
+const semver_1 = __importDefault(require("semver"));
 const handle_package_1 = require("../lib/handle-package");
 const parser_1 = require("../lib/parser");
 const picocolors_1 = require("picocolors");
@@ -118,6 +119,7 @@ function replaceFlatCompatInConfig(configPath) {
     // Look for FlatCompat extends usage and identify which configs are being used
     root.find(j.CallExpression).forEach((astPath) => {
         const node = astPath.value;
+        // Detect compat.extends() calls and identify which configs are being used
         if (node.callee.type === 'MemberExpression' &&
             node.callee.object.type === 'Identifier' &&
             node.callee.object.name === 'compat' &&
@@ -139,6 +141,41 @@ function replaceFlatCompatInConfig(configPath) {
                 }
             });
         }
+        // Detect compat.config({ extends: [...] }) calls and identify which configs are being used
+        if (node.callee.type === 'MemberExpression' &&
+            node.callee.object.type === 'Identifier' &&
+            node.callee.object.name === 'compat' &&
+            node.callee.property.type === 'Identifier' &&
+            node.callee.property.name === 'config') {
+            // Look for extends property in the object argument
+            node.arguments.forEach((arg) => {
+                if (arg.type === 'ObjectExpression') {
+                    arg.properties?.forEach((prop) => {
+                        if (prop.type === 'ObjectProperty' &&
+                            prop.key.type === 'Identifier' &&
+                            prop.key.name === 'extends' &&
+                            prop.value.type === 'ArrayExpression') {
+                            // Process the extends array
+                            prop.value.elements?.forEach((element) => {
+                                if (element.type === 'Literal' ||
+                                    element.type === 'StringLiteral') {
+                                    if (element.value === 'next/core-web-vitals') {
+                                        needsNextVitals = true;
+                                    }
+                                    else if (element.value === 'next/typescript') {
+                                        needsNextTs = true;
+                                    }
+                                    else if (typeof element.value === 'string') {
+                                        // Preserve other configs (non-Next.js or other Next.js variants)
+                                        otherConfigs.push(element.value);
+                                    }
+                                }
+                            });
+                        }
+                    });
+                }
+            });
+        }
     });
     if (!needsNextVitals && !needsNextTs && otherConfigs.length === 0) {
         console.warn(exports.prefixes.warn, '   No ESLint configs found in FlatCompat usage');
@@ -217,6 +254,7 @@ function replaceFlatCompatInConfig(configPath) {
     // Replace FlatCompat extends with spread imports
     root.find(j.SpreadElement).forEach((astPath) => {
         const node = astPath.value;
+        // Replace spread of compat.extends(...) calls with direct imports
         if (node.argument.type === 'CallExpression' &&
             node.argument.callee.type === 'MemberExpression' &&
             node.argument.callee.object.type === 'Identifier' &&
@@ -250,6 +288,70 @@ function replaceFlatCompatInConfig(configPath) {
                 }
             }
         }
+        // Replace spread of compat.config({ extends: [...] }) calls with direct imports
+        if (node.argument.type === 'CallExpression' &&
+            node.argument.callee.type === 'MemberExpression' &&
+            node.argument.callee.object.type === 'Identifier' &&
+            node.argument.callee.object.name === 'compat' &&
+            node.argument.callee.property.type === 'Identifier' &&
+            node.argument.callee.property.name === 'config') {
+            const replacements = [];
+            const preservedConfigs = [];
+            // Process each argument to compat.config
+            node.argument.arguments.forEach((arg) => {
+                if (arg.type === 'ObjectExpression') {
+                    const updatedProperties = [];
+                    arg.properties?.forEach((prop) => {
+                        if (prop.type === 'ObjectProperty' &&
+                            prop.key.type === 'Identifier' &&
+                            prop.key.name === 'extends' &&
+                            prop.value.type === 'ArrayExpression') {
+                            const nonNextConfigs = [];
+                            // Process extends array
+                            prop.value.elements?.forEach((element) => {
+                                if (element.type === 'Literal' ||
+                                    element.type === 'StringLiteral') {
+                                    if (element.value === 'next/core-web-vitals') {
+                                        replacements.push(j.spreadElement(j.identifier('nextCoreWebVitals')));
+                                    }
+                                    else if (element.value === 'next/typescript') {
+                                        replacements.push(j.spreadElement(j.identifier('nextTypescript')));
+                                    }
+                                    else if (typeof element.value === 'string') {
+                                        // Keep non-Next.js configs
+                                        nonNextConfigs.push(element);
+                                    }
+                                }
+                            });
+                            // If there are non-Next.js configs, preserve the extends property with them
+                            if (nonNextConfigs.length > 0) {
+                                updatedProperties.push(j.property('init', j.identifier('extends'), j.arrayExpression(nonNextConfigs)));
+                            }
+                        }
+                        else {
+                            // Preserve other properties (not extends)
+                            updatedProperties.push(prop);
+                        }
+                    });
+                    // If we still have properties to preserve, keep the compat.config call
+                    if (updatedProperties.length > 0) {
+                        preservedConfigs.push(j.spreadElement(j.callExpression(j.memberExpression(j.identifier('compat'), j.identifier('config')), [j.objectExpression(updatedProperties)])));
+                    }
+                }
+            });
+            // Add all replacements
+            const allReplacements = [...replacements, ...preservedConfigs];
+            if (allReplacements.length > 0) {
+                // Replace the current spread element with multiple spread elements
+                const parent = astPath.parent;
+                if (parent.value.type === 'ArrayExpression') {
+                    const index = parent.value.elements.indexOf(node);
+                    if (index !== -1) {
+                        parent.value.elements.splice(index, 1, ...allReplacements);
+                    }
+                }
+            }
+        }
     });
     // Also handle the case where extends is used as a property value (not spread)
     root.find(j.ObjectExpression).forEach((astPath) => {
@@ -658,6 +760,19 @@ function updatePackageJsonScripts(packageJsonContent) {
                 nextVersion || 'latest';
             needsUpdate = true;
         }
+        // Bump eslint to v9 for full Flat config support
+        if (packageJson.dependencies?.['eslint'] &&
+            semver_1.default.lt(semver_1.default.minVersion(packageJson.dependencies['eslint'])?.version ??
+                '0.0.0', '9.0.0')) {
+            packageJson.dependencies['eslint'] = '^9';
+            needsUpdate = true;
+        }
+        if (packageJson.devDependencies?.['eslint'] &&
+            semver_1.default.lt(semver_1.default.minVersion(packageJson.devDependencies['eslint'])?.version ??
+                '0.0.0', '9.0.0')) {
+            packageJson.devDependencies['eslint'] = '^9';
+            needsUpdate = true;
+        }
         // Remove @eslint/eslintrc if it exists since we no longer use FlatCompat
         if (packageJson.devDependencies?.['@eslint/eslintrc']) {
             delete packageJson.devDependencies['@eslint/eslintrc'];

package/transforms/remove-experimental-ppr.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformer;
+const parser_1 = require("../lib/parser");
+function transformer(file, _api) {
+    // Run on App Router page/layout/route files, except for test environment.
+    if (process.env.NODE_ENV !== 'test' &&
+        !/[/\\]app[/\\](?:.*[/\\])?(page|layout|route)(\.[^/\\]*)?$/.test(file.path)) {
+        return file.source;
+    }
+    const j = (0, parser_1.createParserFromPath)(file.path);
+    const root = j(file.source);
+    let hasChanges = false;
+    // Remove export const experimental_ppr = boolean
+    const directExports = root.find(j.ExportNamedDeclaration, {
+        declaration: {
+            type: 'VariableDeclaration',
+            declarations: [
+                {
+                    id: { name: 'experimental_ppr' },
+                },
+            ],
+        },
+    });
+    if (directExports.size() > 0) {
+        directExports.remove();
+        hasChanges = true;
+    }
+    // Remove const experimental_ppr = boolean declarations
+    const variableDeclarations = root.find(j.VariableDeclaration).filter((path) => path.node.declarations.some((decl) => {
+        if (j.VariableDeclarator.check(decl) && j.Identifier.check(decl.id)) {
+            return decl.id.name === 'experimental_ppr';
+        }
+        return false;
+    }));
+    if (variableDeclarations.size() > 0) {
+        variableDeclarations.remove();
+        hasChanges = true;
+    }
+    // Handle export { experimental_ppr } and export { experimental_ppr, other }
+    const namedExports = root
+        .find(j.ExportNamedDeclaration)
+        .filter((path) => path.node.specifiers && path.node.specifiers.length > 0);
+    namedExports.forEach((path) => {
+        const specifiers = path.node.specifiers;
+        if (!specifiers)
+            return;
+        const filteredSpecifiers = specifiers.filter((spec) => {
+            if (j.ExportSpecifier.check(spec) && j.Identifier.check(spec.local)) {
+                return spec.local.name !== 'experimental_ppr';
+            }
+            return true;
+        });
+        // If we removed any specifiers
+        if (filteredSpecifiers.length !== specifiers.length) {
+            hasChanges = true;
+            // If no specifiers left, remove the entire export statement
+            if (filteredSpecifiers.length === 0) {
+                j(path).remove();
+            }
+            else {
+                // Update the specifiers array
+                path.node.specifiers = filteredSpecifiers;
+            }
+        }
+    });
+    if (hasChanges) {
+        return root.toSource();
+    }
+    return file.source;
+}
+//# sourceMappingURL=remove-experimental-ppr.js.map

package/transforms/remove-unstable-prefix.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformer;
+const parser_1 = require("../lib/parser");
+// Mapping of unstable APIs to their stable counterparts
+// This can be easily extended when new APIs are stabilized
+const UNSTABLE_TO_STABLE_MAPPING = {
+    unstable_cacheTag: 'cacheTag',
+    unstable_cacheLife: 'cacheLife',
+};
+// Helper function to check if a property name should be renamed
+function shouldRenameProperty(propertyName) {
+    return propertyName in UNSTABLE_TO_STABLE_MAPPING;
+}
+function transformer(file, _api, options) {
+    const j = (0, parser_1.createParserFromPath)(file.path);
+    const root = j(file.source);
+    let hasChanges = false;
+    try {
+        // Track identifier renames that need to be applied
+        const identifierRenames = [];
+        // Track variables assigned from next/cache imports/requires
+        const cacheVariables = new Set();
+        // Handle ES6 imports: import { unstable_cacheTag } from 'next/cache'
+        root
+            .find(j.ImportDeclaration, { source: { value: 'next/cache' } })
+            .forEach((path) => {
+            path.node.specifiers?.forEach((specifier) => {
+                if (specifier.type === 'ImportSpecifier' &&
+                    specifier.imported?.type === 'Identifier' &&
+                    shouldRenameProperty(specifier.imported.name)) {
+                    const oldName = specifier.imported.name;
+                    const newName = UNSTABLE_TO_STABLE_MAPPING[oldName];
+                    // Handle alias scenarios
+                    if (specifier.local && specifier.local.name === newName) {
+                        // Same alias name: { unstable_cacheTag as cacheTag } -> { cacheTag }
+                        const newSpecifier = j.importSpecifier(j.identifier(newName));
+                        const specifierIndex = path.node.specifiers.indexOf(specifier);
+                        path.node.specifiers[specifierIndex] = newSpecifier;
+                        identifierRenames.push({ oldName, newName });
+                    }
+                    else {
+                        // Normal case: just update the imported name
+                        specifier.imported = j.identifier(newName);
+                        if (!specifier.local || specifier.local.name === oldName) {
+                            // Not aliased or aliased with old name: add to identifier renames
+                            identifierRenames.push({ oldName, newName });
+                        }
+                    }
+                    hasChanges = true;
+                }
+                else if (specifier.type === 'ImportNamespaceSpecifier') {
+                    // Handle namespace imports: import * as cache from 'next/cache'
+                    cacheVariables.add(specifier.local.name);
+                }
+            });
+        });
+        // Handle export statements: export { unstable_cacheTag } from 'next/cache'
+        root
+            .find(j.ExportNamedDeclaration, { source: { value: 'next/cache' } })
+            .forEach((path) => {
+            path.node.specifiers?.forEach((specifier) => {
+                if (specifier.type === 'ExportSpecifier' &&
+                    specifier.local?.type === 'Identifier' &&
+                    shouldRenameProperty(specifier.local.name)) {
+                    const oldName = specifier.local.name;
+                    const newName = UNSTABLE_TO_STABLE_MAPPING[oldName];
+                    specifier.local = j.identifier(newName);
+                    // Handle export alias scenarios
+                    if (specifier.exported && specifier.exported.name === newName) {
+                        // Same alias name: { unstable_cacheTag as cacheTag } -> { cacheTag }
+                        specifier.exported = specifier.local;
+                    }
+                    else if (!specifier.exported ||
+                        specifier.exported.name === oldName) {
+                        // Not aliased or aliased with old name
+                        specifier.exported = j.identifier(newName);
+                    }
+                    hasChanges = true;
+                }
+            });
+        });
+        // Handle require('next/cache') calls and destructuring
+        root
+            .find(j.CallExpression, { callee: { name: 'require' } })
+            .forEach((path) => {
+            if (path.node.arguments[0]?.type === 'StringLiteral' &&
+                path.node.arguments[0].value === 'next/cache') {
+                // Track variable assignments: const cache = require('next/cache')
+                const parent = path.parent?.node;
+                if (parent?.type === 'VariableDeclarator' &&
+                    parent.id?.type === 'Identifier') {
+                    cacheVariables.add(parent.id.name);
+                }
+                // Handle destructuring: const { unstable_cacheTag } = require('next/cache')
+                if (parent?.type === 'VariableDeclarator' &&
+                    parent.id?.type === 'ObjectPattern') {
+                    parent.id.properties?.forEach((property) => {
+                        if (property.type === 'ObjectProperty' &&
+                            property.key?.type === 'Identifier' &&
+                            shouldRenameProperty(property.key.name)) {
+                            const oldName = property.key.name;
+                            const newName = UNSTABLE_TO_STABLE_MAPPING[oldName];
+                            property.key = j.identifier(newName);
+                            // Handle both shorthand and explicit destructuring
+                            if (!property.value) {
+                                property.value = j.identifier(newName);
+                                identifierRenames.push({ oldName, newName });
+                            }
+                            else if (property.value.type === 'Identifier') {
+                                const localName = property.value.name;
+                                if (localName === oldName) {
+                                    property.value = j.identifier(newName);
+                                    identifierRenames.push({ oldName, newName });
+                                }
+                                else if (localName === newName) {
+                                    // Same alias name: { unstable_cacheTag: cacheTag } -> { cacheTag }
+                                    property.value = j.identifier(newName);
+                                    property.shorthand = true;
+                                    identifierRenames.push({ oldName, newName });
+                                }
+                            }
+                            hasChanges = true;
+                        }
+                    });
+                }
+            }
+        });
+        // Handle await import('next/cache') calls and destructuring
+        root.find(j.AwaitExpression).forEach((path) => {
+            const arg = path.node.argument;
+            if (arg?.type === 'CallExpression' &&
+                arg.callee?.type === 'Import' &&
+                arg.arguments[0]?.type === 'StringLiteral' &&
+                arg.arguments[0].value === 'next/cache') {
+                // Track variable assignments: const cache = await import('next/cache')
+                const parent = path.parent?.node;
+                if (parent?.type === 'VariableDeclarator' &&
+                    parent.id?.type === 'Identifier') {
+                    cacheVariables.add(parent.id.name);
+                }
+                // Handle destructuring: const { unstable_cacheTag } = await import('next/cache')
+                if (parent?.type === 'VariableDeclarator' &&
+                    parent.id?.type === 'ObjectPattern') {
+                    parent.id.properties?.forEach((property) => {
+                        if (property.type === 'ObjectProperty' &&
+                            property.key?.type === 'Identifier' &&
+                            shouldRenameProperty(property.key.name)) {
+                            const oldName = property.key.name;
+                            const newName = UNSTABLE_TO_STABLE_MAPPING[oldName];
+                            property.key = j.identifier(newName);
+                            if (!property.value) {
+                                property.value = j.identifier(newName);
+                                identifierRenames.push({ oldName, newName });
+                            }
+                            else if (property.value.type === 'Identifier') {
+                                const localName = property.value.name;
+                                if (localName === oldName) {
+                                    property.value = j.identifier(newName);
+                                    identifierRenames.push({ oldName, newName });
+                                }
+                                else if (localName === newName) {
+                                    // Same alias name: { unstable_cacheTag: cacheTag } -> { cacheTag }
+                                    property.value = j.identifier(newName);
+                                    property.shorthand = true;
+                                    identifierRenames.push({ oldName, newName });
+                                }
+                            }
+                            hasChanges = true;
+                        }
+                    });
+                }
+            }
+        });
+        // Handle .then() chains: import('next/cache').then(({ unstable_cacheTag }) => ...)
+        root.find(j.CallExpression).forEach((path) => {
+            if (path.node.callee?.type === 'MemberExpression' &&
+                path.node.callee.property?.type === 'Identifier' &&
+                path.node.callee.property.name === 'then' &&
+                path.node.callee.object?.type === 'CallExpression' &&
+                path.node.callee.object.callee?.type === 'Import' &&
+                path.node.callee.object.arguments[0]?.type === 'StringLiteral' &&
+                path.node.callee.object.arguments[0].value === 'next/cache' &&
+                path.node.arguments.length > 0) {
+                const callback = path.node.arguments[0];
+                let params = null;
+                if (callback.type === 'ArrowFunctionExpression') {
+                    params = callback.params;
+                }
+                else if (callback.type === 'FunctionExpression') {
+                    params = callback.params;
+                }
+                if (params && params.length > 0 && params[0].type === 'ObjectPattern') {
+                    params[0].properties?.forEach((property) => {
+                        if (property.type === 'ObjectProperty' &&
+                            property.key?.type === 'Identifier' &&
+                            shouldRenameProperty(property.key.name)) {
+                            const oldName = property.key.name;
+                            const newName = UNSTABLE_TO_STABLE_MAPPING[oldName];
+                            property.key = j.identifier(newName);
+                            if (!property.value) {
+                                property.value = j.identifier(newName);
+                                identifierRenames.push({ oldName, newName });
+                            }
+                            else if (property.value.type === 'Identifier') {
+                                const localName = property.value.name;
+                                if (localName === oldName) {
+                                    property.value = j.identifier(newName);
+                                    identifierRenames.push({ oldName, newName });
+                                }
+                                else if (localName === newName) {
+                                    // Same alias name: { unstable_cacheTag: cacheTag } -> { cacheTag }
+                                    property.value = j.identifier(newName);
+                                    property.shorthand = true;
+                                    identifierRenames.push({ oldName, newName });
+                                }
+                            }
+                            hasChanges = true;
+                        }
+                    });
+                }
+            }
+        });
+        // Handle member expressions
+        root.find(j.MemberExpression).forEach((path) => {
+            const node = path.node;
+            // Handle direct property access: require('next/cache').unstable_cacheTag
+            if (node.object?.type === 'CallExpression' &&
+                node.object.callee?.type === 'Identifier' &&
+                node.object.callee.name === 'require' &&
+                node.object.arguments[0]?.type === 'StringLiteral' &&
+                node.object.arguments[0].value === 'next/cache') {
+                if (node.computed &&
+                    node.property?.type === 'StringLiteral' &&
+                    shouldRenameProperty(node.property.value)) {
+                    const newName = UNSTABLE_TO_STABLE_MAPPING[node.property.value];
+                    node.property = j.stringLiteral(newName);
+                    hasChanges = true;
+                }
+                else if (!node.computed &&
+                    node.property?.type === 'Identifier' &&
+                    shouldRenameProperty(node.property.name)) {
+                    const newName = UNSTABLE_TO_STABLE_MAPPING[node.property.name];
+                    node.property = j.identifier(newName);
+                    hasChanges = true;
+                }
+            }
+            // Handle property access on cache variables: cache.unstable_cacheTag or cache['unstable_cacheTag']
+            if (node.object?.type === 'Identifier' &&
+                cacheVariables.has(node.object.name)) {
+                if (node.computed &&
+                    node.property?.type === 'StringLiteral' &&
+                    shouldRenameProperty(node.property.value)) {
+                    const newName = UNSTABLE_TO_STABLE_MAPPING[node.property.value];
+                    node.property = j.stringLiteral(newName);
+                    hasChanges = true;
+                }
+                else if (!node.computed &&
+                    node.property?.type === 'Identifier' &&
+                    shouldRenameProperty(node.property.name)) {
+                    const newName = UNSTABLE_TO_STABLE_MAPPING[node.property.name];
+                    node.property = j.identifier(newName);
+                    hasChanges = true;
+                }
+            }
+        });
+        // Apply all identifier renames with better scope awareness
+        identifierRenames.forEach(({ oldName, newName }) => {
+            root
+                .find(j.Identifier, { name: oldName })
+                .filter((identifierPath) => {
+                // Skip renaming declarations themselves
+                const parent = identifierPath.parent;
+                return !(parent.node.type === 'ImportSpecifier' ||
+                    parent.node.type === 'ExportSpecifier' ||
+                    (parent.node.type === 'ObjectProperty' &&
+                        parent.node.key === identifierPath.node) ||
+                    (parent.node.type === 'VariableDeclarator' &&
+                        parent.node.id === identifierPath.node) ||
+                    (parent.node.type === 'FunctionDeclaration' &&
+                        parent.node.id === identifierPath.node) ||
+                    (parent.node.type === 'Property' &&
+                        parent.node.key === identifierPath.node &&
+                        !parent.node.computed));
+            })
+                .forEach((identifierPath) => {
+                identifierPath.node.name = newName;
+            });
+        });
+        return hasChanges ? root.toSource(options) : file.source;
+    }
+    catch (error) {
+        console.warn(`Failed to transform ${file.path}: ${error.message}`);
+        return file.source;
+    }
+}
+//# sourceMappingURL=remove-unstable-prefix.js.map