agent-session-inspector 0.0.0-stage → 0.1.2

package/app/node_modules/next/dist/lib/find-root.js

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    findRootDirAndLockFiles: null,
+    warnDuplicatedLockFiles: null,
+    warnRootBoundary: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    findRootDirAndLockFiles: function() {
+        return findRootDirAndLockFiles;
+    },
+    warnDuplicatedLockFiles: function() {
+        return warnDuplicatedLockFiles;
+    },
+    warnRootBoundary: function() {
+        return warnRootBoundary;
+    }
+});
+const _path = require("path");
+const _fs = require("fs");
+const _os = require("os");
+const _findup = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/find-up"));
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../build/output/log"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function toRealPath(path) {
+    try {
+        return _fs.realpathSync.native(path);
+    } catch  {
+        return path;
+    }
+}
+// `homedir()` throws when it cannot determine a home directory, and returns an
+// empty string on some platforms. an empty value would match every directory,
+// so treat both as "no home directory".
+function findHomeDir() {
+    try {
+        return toRealPath((0, _os.homedir)()) || undefined;
+    } catch  {
+        return undefined;
+    }
+}
+// if `descendant` is inside of `ancestor` or `descendant` == `ancestor`
+function isAncestorOrSelf(ancestor, descendant) {
+    const rel = (0, _path.relative)(ancestor, descendant);
+    return rel === '' || !rel.startsWith('..') && !(0, _path.isAbsolute)(rel);
+}
+// if `descendant` is inside of `ancestor`
+function isStrictAncestor(ancestor, descendant) {
+    const rel = (0, _path.relative)(ancestor, descendant);
+    return rel !== '' && !rel.startsWith('..') && !(0, _path.isAbsolute)(rel);
+}
+// true for a git worktree (its git dir has a `commondir` file);
+// this method returns false for a submodule.
+function isGitWorktree(dir, gitFile) {
+    let contents;
+    try {
+        contents = (0, _fs.readFileSync)(gitFile, 'utf8');
+    } catch  {
+        return false;
+    }
+    // Match the behavior in git:
+    // https://github.com/git/git/blob/13c7afec212fc97ce257d15601659314c6673d6c/setup.c#L1007-L1018
+    const match = /^gitdir: (.+?)[\r\n]*$/s.exec(contents);
+    if (!match) return false;
+    const gitDir = (0, _path.resolve)(dir, match[1]);
+    return (0, _fs.existsSync)((0, _path.join)(gitDir, 'commondir'));
+}
+// finds the first git repository or git worktree above the
+// current working directory. we limit the project root to
+// inside a worktree or git repository. this is because if
+// you use worktrees, you may have lock files from the
+// parent git repo that are in folders that are not relevant
+// to watch.
+function findGitBoundary(cwd) {
+    let isWorktree = false;
+    const gitDir = _findup.default.sync((dir)=>{
+        var _statSync;
+        const candidate = (0, _path.join)(dir, '.git');
+        const isDirectory = (_statSync = (0, _fs.statSync)(candidate, {
+            throwIfNoEntry: false
+        })) == null ? void 0 : _statSync.isDirectory();
+        isWorktree = !isDirectory && isGitWorktree(dir, candidate);
+        return isDirectory || isWorktree ? dir : undefined;
+    }, {
+        cwd,
+        type: 'directory'
+    });
+    if (!gitDir) return undefined;
+    return {
+        type: isWorktree ? 'worktree' : 'repository',
+        dir: toRealPath(gitDir)
+    };
+}
+const LOCK_FILES = [
+    'pnpm-lock.yaml',
+    'package-lock.json',
+    'yarn.lock',
+    'bun.lock',
+    'bun.lockb'
+];
+// Dedicated workspace-root files. pnpm and Lerna declare the root this way.
+const WORKSPACE_MARKERS = [
+    'pnpm-workspace.yaml',
+    'lerna.json'
+];
+// npm, Yarn, and Bun declare the root via a package.json `workspaces` field,
+// which may be an array or an object (e.g. Yarn's `{ packages: [...] }`).
+function hasWorkspacesField(packageJson) {
+    try {
+        return JSON.parse((0, _fs.readFileSync)(packageJson, 'utf8')).workspaces != null;
+    } catch  {
+        return false;
+    }
+}
+function findWorkspaceMarker(directory) {
+    for (const name of WORKSPACE_MARKERS){
+        const markerPath = (0, _path.join)(directory, name);
+        if ((0, _fs.existsSync)(markerPath)) {
+            return markerPath;
+        }
+    }
+    const packageJson = (0, _path.join)(directory, 'package.json');
+    return hasWorkspacesField(packageJson) ? packageJson : undefined;
+}
+function findNextRootCandidate(cwd) {
+    // a workspace marker takes precedence over lockfiles, which can be included in
+    // the application directory by accident.
+    const marker = _findup.default.sync(findWorkspaceMarker, {
+        cwd
+    });
+    if (marker) {
+        return {
+            path: marker,
+            isWorkspaceMarker: true
+        };
+    }
+    const lockFile = _findup.default.sync(LOCK_FILES, {
+        cwd
+    });
+    return lockFile ? {
+        path: lockFile,
+        isWorkspaceMarker: false
+    } : undefined;
+}
+function findRootDirAndLockFiles(cwd) {
+    const initialCandidate = findNextRootCandidate(cwd);
+    if (!initialCandidate) return {
+        lockFiles: [],
+        rootDir: cwd
+    };
+    const candidates = [
+        initialCandidate.path
+    ];
+    let foundWorkspaceMarker = initialCandidate.isWorkspaceMarker;
+    while(true){
+        const lastCandidate = candidates[candidates.length - 1];
+        const currentDir = (0, _path.dirname)(lastCandidate);
+        const parentDir = (0, _path.dirname)(currentDir);
+        // dirname('/')==='/' so if we happen to reach the FS root (as might happen in a container we need to quit to avoid looping forever
+        if (parentDir === currentDir) break;
+        const nextCandidate = findNextRootCandidate(parentDir);
+        if (!nextCandidate) break;
+        // findNextRootCandidate searches for markers all the way up, so a non-marker
+        // here means there is no higher marker: nothing above can extend the root.
+        if (foundWorkspaceMarker && !nextCandidate.isWorkspaceMarker) break;
+        candidates.push(nextCandidate.path);
+        foundWorkspaceMarker ||= nextCandidate.isWorkspaceMarker;
+    }
+    // filter out candidates that would push the root past a
+    // git boundary or into the home directory.
+    const homeDir = findHomeDir();
+    const gitBoundary = findGitBoundary(cwd);
+    const acceptedCandidates = [];
+    let boundary;
+    for (const candidate of candidates){
+        const dir = (0, _path.dirname)(candidate);
+        // the app's own directory is always a valid root. even if it
+        // is the home directory.
+        if (dir !== cwd) {
+            const resolvedDir = toRealPath(dir);
+            // `dir` sits above the repo or worktree that contains the app.
+            if (gitBoundary && isStrictAncestor(resolvedDir, gitBoundary.dir)) {
+                // add a warning for going beyond a repository
+                if (gitBoundary.type === 'repository') {
+                    boundary = {
+                        boundary: gitBoundary.dir,
+                        marker: candidate,
+                        root: dir,
+                        type: 'repository'
+                    };
+                }
+                break;
+            }
+            // never treat the home directory (or above) as the root.
+            if (homeDir && isAncestorOrSelf(resolvedDir, homeDir)) {
+                boundary = {
+                    boundary: homeDir,
+                    marker: candidate,
+                    root: dir,
+                    type: 'home'
+                };
+                break;
+            }
+        }
+        acceptedCandidates.push(candidate);
+    }
+    return {
+        lockFiles: acceptedCandidates.filter((candidate)=>LOCK_FILES.includes((0, _path.basename)(candidate))),
+        rootDir: acceptedCandidates.length ? (0, _path.dirname)(acceptedCandidates[acceptedCandidates.length - 1]) : cwd,
+        boundary
+    };
+}
+function warnDuplicatedLockFiles(lockFiles) {
+    if (lockFiles.length <= 1) return;
+    const config = process.env.TURBOPACK ? 'turbopack.root' : 'outputFileTracingRoot';
+    const docs = process.env.TURBOPACK ? 'https://nextjs.org/docs/app/api-reference/config/next-config-js/turbopack#root-directory' : 'https://nextjs.org/docs/app/api-reference/config/next-config-js/output#caveats';
+    const rootLockFile = lockFiles[lockFiles.length - 1];
+    const additionalLockFiles = lockFiles.slice(0, -1).map((str)=>`\n   * ${str}`).join('');
+    _log.warnOnce(`Warning: Next.js inferred your workspace root, but it may not be correct.\n` + ` We detected multiple lockfiles and selected the directory of ${rootLockFile} as the root directory.\n` + ` To silence this warning, set \`${config}\` in your Next.js config, or consider ` + `removing one of the lockfiles if it's not needed.\n` + `   See ${docs} for more information.\n` + ` Detected additional lockfiles: ${additionalLockFiles}\n`);
+}
+function warnRootBoundary({ boundary, marker, root, type }) {
+    const config = process.env.TURBOPACK ? 'turbopack.root' : 'outputFileTracingRoot';
+    const reason = type === 'repository' ? `it is outside the current Git repository (${boundary})` : `it would include your home directory (${boundary})`;
+    _log.warnOnce(`Warning: Next.js ignored ${(0, _path.basename)(marker)} in ${root} because ${reason}.\n` + ` To use this directory, set \`${config}\` in your Next.js config.\n`);
+}
+
+//# sourceMappingURL=find-root.js.map

package/app/node_modules/next/dist/lib/format-cli-help-output.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "formatCliHelpOutput", {
+    enumerable: true,
+    get: function() {
+        return formatCliHelpOutput;
+    }
+});
+const _picocolors = require("../lib/picocolors");
+// Copy-pasted from Commander's Help class -> formatHelp().
+// TL;DR, we're overriding the built-in help to add a few niceties.
+// Link: https://github.com/tj/commander.js/blob/master/lib/help.js
+const formatCliHelpOutput = (cmd, helper)=>{
+    const termWidth = helper.padWidth(cmd, helper);
+    const helpWidth = helper.helpWidth || 80;
+    const itemIndentWidth = 2;
+    const itemSeparatorWidth = 2 // between term and description
+    ;
+    function formatItem(term, description) {
+        let value = term;
+        if (description) {
+            if (term === 'directory') {
+                value = `[${term}]`;
+            }
+            const fullText = `${value.padEnd(termWidth + itemSeparatorWidth)}${description}`;
+            return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
+        }
+        return term;
+    }
+    function formatList(textArray) {
+        return textArray.join('\n').replace(/^/gm, ' '.repeat(itemIndentWidth));
+    }
+    // Usage
+    let output = [
+        `${(0, _picocolors.bold)('Usage:')} ${helper.commandUsage(cmd)}`,
+        ''
+    ];
+    // Description
+    const commandDescription = helper.commandDescription(cmd);
+    if (commandDescription.length > 0) {
+        output = output.concat([
+            helper.wrap(commandDescription, helpWidth, 0),
+            ''
+        ]);
+    }
+    // Arguments
+    const argumentList = helper.visibleArguments(cmd).map((argument)=>{
+        return formatItem(helper.argumentTerm(argument), helper.argumentDescription(argument));
+    });
+    if (argumentList.length > 0) {
+        output = output.concat([
+            `${(0, _picocolors.bold)('Arguments:')}`,
+            formatList(argumentList),
+            ''
+        ]);
+    }
+    // Options
+    const optionList = helper.visibleOptions(cmd).map((option)=>{
+        return formatItem(helper.optionTerm(option), helper.optionDescription(option));
+    });
+    if (optionList.length > 0) {
+        output = output.concat([
+            `${(0, _picocolors.bold)('Options:')}`,
+            formatList(optionList),
+            ''
+        ]);
+    }
+    // Commands
+    const commandList = helper.visibleCommands(cmd).map((subCmd)=>{
+        return formatItem(helper.subcommandTerm(subCmd), helper.subcommandDescription(subCmd));
+    });
+    if (commandList.length > 0) {
+        output = output.concat([
+            `${(0, _picocolors.bold)('Commands:')}`,
+            formatList(commandList),
+            ''
+        ]);
+    }
+    return output.join('\n');
+};
+
+//# sourceMappingURL=format-cli-help-output.js.map

package/app/node_modules/next/dist/lib/format-dynamic-import-path.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    formatDynamicImportPath: null,
+    resolveCacheHandlerPathToFilesystem: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    formatDynamicImportPath: function() {
+        return formatDynamicImportPath;
+    },
+    resolveCacheHandlerPathToFilesystem: function() {
+        return resolveCacheHandlerPathToFilesystem;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _url = require("url");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function resolveCacheHandlerPathToFilesystem(filePath) {
+    if (filePath.startsWith('file://')) {
+        return (0, _url.fileURLToPath)(filePath);
+    }
+    return filePath;
+}
+const formatDynamicImportPath = (dir, filePath)=>{
+    const resolvedFilePath = resolveCacheHandlerPathToFilesystem(filePath);
+    const absoluteFilePath = _path.default.isAbsolute(resolvedFilePath) ? resolvedFilePath : _path.default.join(dir, resolvedFilePath);
+    const formattedFilePath = (0, _url.pathToFileURL)(absoluteFilePath).toString();
+    return formattedFilePath;
+};
+
+//# sourceMappingURL=format-dynamic-import-path.js.map

package/app/node_modules/next/dist/lib/format-server-error.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    formatServerError: null,
+    getStackWithoutErrorMessage: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    formatServerError: function() {
+        return formatServerError;
+    },
+    getStackWithoutErrorMessage: function() {
+        return getStackWithoutErrorMessage;
+    }
+});
+const invalidServerComponentReactHooks = [
+    'useDeferredValue',
+    'useEffect',
+    'useEffectEvent',
+    'useImperativeHandle',
+    'useInsertionEffect',
+    'useLayoutEffect',
+    'useReducer',
+    'useRef',
+    'useState',
+    'useSyncExternalStore',
+    'useTransition',
+    'experimental_useOptimistic',
+    'useOptimistic'
+];
+function setMessage(error, message) {
+    error.message = message;
+    if (error.stack) {
+        const lines = error.stack.split('\n');
+        lines[0] = message;
+        error.stack = lines.join('\n');
+    }
+}
+function getStackWithoutErrorMessage(error) {
+    const stack = error.stack;
+    if (!stack) return '';
+    return stack.replace(/^[^\n]*\n/, '');
+}
+function formatServerError(error) {
+    if (typeof (error == null ? void 0 : error.message) !== 'string') return;
+    if (error.message.includes('Class extends value undefined is not a constructor or null')) {
+        const addedMessage = 'This might be caused by a React Class Component being rendered in a Server Component, React Class Components only works in Client Components. Read more: https://nextjs.org/docs/messages/class-component-in-server-component';
+        // If this error instance already has the message, don't add it again
+        if (error.message.includes(addedMessage)) return;
+        setMessage(error, `${error.message}
+
+${addedMessage}`);
+        return;
+    }
+    if (error.message.includes('createContext is not a function')) {
+        setMessage(error, 'createContext only works in Client Components. Add the "use client" directive at the top of the file to use it. Read more: https://nextjs.org/docs/messages/context-in-server-component');
+        return;
+    }
+    for (const clientHook of invalidServerComponentReactHooks){
+        const regex = new RegExp(`\\b${clientHook}\\b.*is not a function`);
+        if (regex.test(error.message)) {
+            setMessage(error, `${clientHook} only works in Client Components. Add the "use client" directive at the top of the file to use it. Read more: https://nextjs.org/docs/messages/react-client-hook-in-server-component`);
+            return;
+        }
+    }
+}
+
+//# sourceMappingURL=format-server-error.js.map

package/app/node_modules/next/dist/lib/framework/boundary-components.js

@@ -0,0 +1,62 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    MetadataBoundary: null,
+    OutletBoundary: null,
+    RootLayoutBoundary: null,
+    ViewportBoundary: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    MetadataBoundary: function() {
+        return MetadataBoundary;
+    },
+    OutletBoundary: function() {
+        return OutletBoundary;
+    },
+    RootLayoutBoundary: function() {
+        return RootLayoutBoundary;
+    },
+    ViewportBoundary: function() {
+        return ViewportBoundary;
+    }
+});
+const _boundaryconstants = require("./boundary-constants");
+// We use a namespace object to allow us to recover the name of the function
+// at runtime even when production bundling/minification is used.
+const NameSpace = {
+    [_boundaryconstants.METADATA_BOUNDARY_NAME]: function({ children }) {
+        return children;
+    },
+    [_boundaryconstants.VIEWPORT_BOUNDARY_NAME]: function({ children }) {
+        return children;
+    },
+    [_boundaryconstants.OUTLET_BOUNDARY_NAME]: function({ children }) {
+        return children;
+    },
+    [_boundaryconstants.ROOT_LAYOUT_BOUNDARY_NAME]: function({ children }) {
+        return children;
+    }
+};
+const MetadataBoundary = // We use slice(0) to trick the bundler into not inlining/minifying the function
+// so it retains the name inferred from the namespace object
+NameSpace[_boundaryconstants.METADATA_BOUNDARY_NAME.slice(0)];
+const ViewportBoundary = // We use slice(0) to trick the bundler into not inlining/minifying the function
+// so it retains the name inferred from the namespace object
+NameSpace[_boundaryconstants.VIEWPORT_BOUNDARY_NAME.slice(0)];
+const OutletBoundary = // We use slice(0) to trick the bundler into not inlining/minifying the function
+// so it retains the name inferred from the namespace object
+NameSpace[_boundaryconstants.OUTLET_BOUNDARY_NAME.slice(0)];
+const RootLayoutBoundary = // We use slice(0) to trick the bundler into not inlining/minifying the function
+// so it retains the name inferred from the namespace object
+NameSpace[_boundaryconstants.ROOT_LAYOUT_BOUNDARY_NAME.slice(0)];
+
+//# sourceMappingURL=boundary-components.js.map

package/app/node_modules/next/dist/lib/framework/boundary-constants.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    METADATA_BOUNDARY_NAME: null,
+    OUTLET_BOUNDARY_NAME: null,
+    ROOT_LAYOUT_BOUNDARY_NAME: null,
+    VIEWPORT_BOUNDARY_NAME: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    METADATA_BOUNDARY_NAME: function() {
+        return METADATA_BOUNDARY_NAME;
+    },
+    OUTLET_BOUNDARY_NAME: function() {
+        return OUTLET_BOUNDARY_NAME;
+    },
+    ROOT_LAYOUT_BOUNDARY_NAME: function() {
+        return ROOT_LAYOUT_BOUNDARY_NAME;
+    },
+    VIEWPORT_BOUNDARY_NAME: function() {
+        return VIEWPORT_BOUNDARY_NAME;
+    }
+});
+const METADATA_BOUNDARY_NAME = '__next_metadata_boundary__';
+const VIEWPORT_BOUNDARY_NAME = '__next_viewport_boundary__';
+const OUTLET_BOUNDARY_NAME = '__next_outlet_boundary__';
+const ROOT_LAYOUT_BOUNDARY_NAME = '__next_root_layout_boundary__';
+
+//# sourceMappingURL=boundary-constants.js.map

package/app/node_modules/next/dist/lib/fs/rename.js

@@ -0,0 +1,87 @@
+/*
+MIT License
+
+Copyright (c) 2015 - present Microsoft Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */ // This file is based on https://github.com/microsoft/vscode/blob/f860fcf11022f10a992440fd54c6e45674e39617/src/vs/base/node/pfs.ts
+// See the LICENSE at the top of the file
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renameSync", {
+    enumerable: true,
+    get: function() {
+        return renameSync;
+    }
+});
+const _nodefs = require("node:fs");
+function renameSync(source, target, windowsRetryTimeout = 60000 /* matches graceful-fs */ ) {
+    if (source === target) {
+        return; // simulate node.js behaviour here and do a no-op if paths match
+    }
+    if (process.platform === 'win32' && typeof windowsRetryTimeout === 'number') {
+        // On Windows, a rename can fail when either source or target
+        // is locked by AV software. We do leverage graceful-fs to iron
+        // out these issues, however in case the target file exists,
+        // graceful-fs will immediately return without retry for fs.rename().
+        renameSyncWithRetry(source, target, Date.now(), windowsRetryTimeout);
+    } else {
+        (0, _nodefs.renameSync)(source, target);
+    }
+}
+function renameSyncWithRetry(source, target, startTime, retryTimeout, attempt = 0) {
+    try {
+        return (0, _nodefs.renameSync)(source, target);
+    } catch (error) {
+        if (error.code !== 'EACCES' && error.code !== 'EPERM' && error.code !== 'EBUSY') {
+            throw error // only for errors we think are temporary
+            ;
+        }
+        if (Date.now() - startTime >= retryTimeout) {
+            console.error(`Node.js fs rename failed after ${attempt} retries with error: ${error}`);
+            throw error // give up after configurable timeout
+            ;
+        }
+        if (attempt > 100) {
+            console.error(`Node.js fs rename failed after ${attempt} retries with error ${error}`);
+            throw error;
+        }
+        if (attempt === 0) {
+            let abortRetry = false;
+            try {
+                const statTarget = (0, _nodefs.statSync)(target);
+                if (!statTarget.isFile()) {
+                    abortRetry = true // if target is not a file, EPERM error may be raised and we should not attempt to retry
+                    ;
+                }
+            } catch (e) {
+            // Ignore
+            }
+            if (abortRetry) {
+                throw error;
+            }
+        }
+        // Attempt again
+        return renameSyncWithRetry(source, target, startTime, retryTimeout, attempt + 1);
+    }
+}
+
+//# sourceMappingURL=rename.js.map