@evoscientist/webui 0.2.5 → 0.2.6

package/dist/node_modules/next/dist/server/image-optimizer.js

@@ -80,7 +80,6 @@ const _imagesize = /*#__PURE__*/ _interop_require_default(require("next/dist/com
 const _detector = require("next/dist/compiled/image-detector/detector.js");
 const _isanimated = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/is-animated"));
 const _path = require("path");
-const _url = /*#__PURE__*/ _interop_require_default(require("url"));
 const _imageblursvg = require("../shared/lib/image-blur-svg");
 const _matchlocalpattern = require("../shared/lib/match-local-pattern");
 const _matchremotepattern = require("../shared/lib/match-remote-pattern");
@@ -92,7 +91,7 @@ const _log = /*#__PURE__*/ _interop_require_wildcard(require("../build/output/lo
 const _iserror = /*#__PURE__*/ _interop_require_default(require("../lib/is-error"));
 const _isprivateip = require("./is-private-ip");
 const _disklrucacheexternal = require("./lib/disk-lru-cache.external");
-const _url1 = require("../lib/url");
+const _url = require("../lib/url");
 const _invarianterror = require("../shared/lib/invariant-error");
 const _promises = require("dns/promises");
 const _net = require("net");
@@ -169,7 +168,8 @@ const BYPASS_TYPES = [
     ICNS,
     BMP,
     JXL,
-    HEIC
+    HEIC,
+    AVIF
 ];
 const BLUR_IMG_SIZE = 8 // should match `next-image-loader`
 ;
@@ -194,13 +194,31 @@ async function initCacheEntries(cacheDir) {
     // Sort oldest-first so we can replay them chronologically into LRU
     return entries.sort((a, b)=>a.expireAt - b.expireAt);
 }
-function getSharp(concurrency) {
+function getSharp(concurrency, operationCache) {
     if (_sharp) {
         return _sharp;
     }
     try {
         _sharp = require('sharp');
-        if (_sharp && _sharp.concurrency() > 1) {
+        _sharp.block({
+            operation: [
+                'VipsForeignLoad'
+            ]
+        });
+        _sharp.unblock({
+            operation: [
+                'VipsForeignLoadJpeg',
+                'VipsForeignLoadNsgif',
+                'VipsForeignLoadPng',
+                'VipsForeignLoadSvg',
+                'VipsForeignLoadTiff',
+                'VipsForeignLoadWebp'
+            ]
+        });
+        if (typeof operationCache === 'boolean') {
+            _sharp.cache(operationCache);
+        }
+        if (_sharp.concurrency() > 1) {
             // Reducing concurrency should reduce the memory usage too.
             // We more aggressively reduce in dev but also reduce in prod.
             // https://sharp.pixelplumbing.com/api-utility#concurrency
@@ -292,7 +310,7 @@ async function deleteFromCacheDir(cacheDir, cacheKey) {
         _log.error(`Failed to delete cache key ${cacheKey}`, err);
     });
 }
-async function detectContentType(buffer, skipMetadata, concurrency) {
+async function detectContentType(buffer) {
     if (buffer.byteLength === 0) {
         return null;
     }
@@ -465,21 +483,12 @@ async function detectContentType(buffer, skipMetadata, concurrency) {
     ].every((b, i)=>buffer[i] === b)) {
         return JP2;
     }
-    let format;
-    format = (0, _detector.detector)(buffer);
-    if (!format && !skipMetadata) {
-        const sharp = getSharp(concurrency);
-        const meta = await sharp(buffer).metadata().catch((_)=>null);
-        format = meta == null ? void 0 : meta.format;
-    }
+    const format = (0, _detector.detector)(buffer.subarray(0, 1024));
     switch(format){
-        case 'avif':
-            return AVIF;
         case 'webp':
             return WEBP;
         case 'png':
             return PNG;
-        case 'jpeg':
         case 'jpg':
             return JPEG;
         case 'gif':
@@ -492,28 +501,14 @@ async function detectContentType(buffer, skipMetadata, concurrency) {
         case 'jp2':
             return JP2;
         case 'tiff':
-        case 'tif':
             return TIFF;
-        case 'pdf':
-            return PDF;
         case 'bmp':
             return BMP;
         case 'ico':
             return ICO;
         case 'icns':
             return ICNS;
-        case 'dcraw':
-        case 'dz':
-        case 'exr':
-        case 'fits':
         case 'heif':
-        case 'input':
-        case 'magick':
-        case 'openslide':
-        case 'ppm':
-        case 'rad':
-        case 'raw':
-        case 'v':
         case 'cur':
         case 'dds':
         case 'j2c':
@@ -522,8 +517,12 @@ async function detectContentType(buffer, skipMetadata, concurrency) {
         case 'psd':
         case 'tga':
         case undefined:
+            return null // unsupported formats
+            ;
         default:
-            return null;
+            format; // exhaustive check
+            return null // impossible to reach
+            ;
     }
 }
 class ImageOptimizerCache {
@@ -565,7 +564,7 @@ class ImageOptimizerCache {
             var _parseUrl;
             href = url;
             isAbsolute = false;
-            if (/\/_next\/image($|\/)/.test(decodeURIComponent(((_parseUrl = (0, _url1.parseUrl)(url)) == null ? void 0 : _parseUrl.pathname) ?? ''))) {
+            if (/\/_next\/image($|\/)/.test(decodeURIComponent(((_parseUrl = (0, _url.parseUrl)(url)) == null ? void 0 : _parseUrl.pathname) ?? ''))) {
                 return {
                     errorMessage: '"url" parameter cannot be recursive'
                 };
@@ -662,7 +661,7 @@ class ImageOptimizerCache {
             }
         }
         const mimeType = getSupportedMimeType(formats || [], req.headers['accept']);
-        const isStatic = url.startsWith(`${nextConfig.basePath || ''}/_next/static/media`);
+        const isStatic = url.startsWith(`${nextConfig.basePath || ''}/_next/static/media`) || url.startsWith(`${nextConfig.basePath || ''}/_next/static/immutable/media`);
         return {
             href,
             sizes,
@@ -818,6 +817,11 @@ class ImageOptimizerCache {
 class ImageError extends Error {
     constructor(statusCode, message){
         super(message);
+        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
         // ensure an error status is used > 400
         if (statusCode >= 400) {
             this.statusCode = statusCode;
@@ -865,8 +869,8 @@ function getPreviouslyCachedImageOrNull(upstreamImage, previousCacheEntry) {
     }
     return null;
 }
-async function optimizeImage({ buffer, contentType, quality, width, height, concurrency, limitInputPixels, sequentialRead, timeoutInSeconds }) {
-    const sharp = getSharp(concurrency);
+async function optimizeImage({ buffer, contentType, quality, width, height, concurrency, operationCache, limitInputPixels, sequentialRead, timeoutInSeconds }) {
+    const sharp = getSharp(concurrency, operationCache);
     const transformer = sharp(buffer, {
         limitInputPixels,
         sequentialRead: sequentialRead ?? undefined
@@ -882,7 +886,10 @@ async function optimizeImage({ buffer, contentType, quality, width, height, conc
     }
     if (contentType === AVIF) {
         transformer.avif({
-            quality: Math.max(quality - 20, 1),
+            // Scale the quality to try and match webp. This ratio was derived
+            // from sharp's default 80 (webp) and 50 (avif), and then verified
+            // using dssim and ssimulacra2 visual quality tests.
+            quality: Math.max(Math.round(quality * (50 / 80)), 1),
             effort: 3
         });
     } else if (contentType === WEBP) {
@@ -931,7 +938,7 @@ async function fetchExternalImage(href, dangerouslyAllowLocalIP, maximumResponse
         }
         const privateIps = ips.filter((ip)=>(0, _isprivateip.isPrivateIp)(ip));
         if (privateIps.length > 0) {
-            _log.error('upstream image', href, 'resolved to private ip', JSON.stringify(privateIps));
+            _log.error('upstream image', href, 'hostname resolved to private IP', JSON.stringify(privateIps), 'If this is expected and you understand SSRF risk, use images.dangerouslyAllowLocalIP = true to continue.');
             throw Object.defineProperty(new ImageError(400, '"url" parameter is not allowed'), "__NEXT_ERROR_CODE", {
                 value: "E394",
                 enumerable: false,
@@ -1020,7 +1027,7 @@ async function fetchInternalImage(href, _req, _res, maximumResponseBody, handleR
             socket: _req.socket,
             maximumResponseBody
         });
-        await handleRequest(mocked.req, mocked.res, _url.default.parse(href, true));
+        await handleRequest(mocked.req, mocked.res, (0, _url.parseReqUrl)(href));
         await mocked.res.hasStreamed;
         if (!mocked.res.statusCode) {
             _log.error('image response failed for', href, mocked.res.statusCode);
@@ -1072,7 +1079,7 @@ async function imageOptimizer(imageUpstream, paramsResult, nextConfig, opts) {
     const { href, quality, width, mimeType } = paramsResult;
     const { buffer: upstreamBuffer, etag: upstreamEtag } = imageUpstream;
     const maxAge = Math.max(nextConfig.images.minimumCacheTTL, getMaxAge(imageUpstream.cacheControl));
-    const upstreamType = await detectContentType(upstreamBuffer, nextConfig.experimental.imgOptSkipMetadata, nextConfig.experimental.imgOptConcurrency);
+    const upstreamType = await detectContentType(upstreamBuffer);
     if (!upstreamType || !upstreamType.startsWith('image/') || upstreamType.includes(',')) {
         if (!opts.silent) {
             _log.error("The requested resource isn't a valid image for", href, 'received', upstreamType);
@@ -1140,6 +1147,7 @@ async function imageOptimizer(imageUpstream, paramsResult, nextConfig, opts) {
             quality,
             width,
             concurrency: nextConfig.experimental.imgOptConcurrency,
+            operationCache: nextConfig.experimental.imgOptOperationCache,
             limitInputPixels: nextConfig.experimental.imgOptMaxInputPixels,
             sequentialRead: nextConfig.experimental.imgOptSequentialRead,
             timeoutInSeconds: nextConfig.experimental.imgOptTimeoutInSeconds

package/dist/node_modules/next/dist/server/lib/app-info-log.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
+    ensureAgentRulesForDev: null,
     getEnvInfo: null,
     logExperimentalInfo: null,
     logStartInfo: null
@@ -14,6 +15,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    ensureAgentRulesForDev: function() {
+        return ensureAgentRulesForDev;
+    },
     getEnvInfo: function() {
         return getEnvInfo;
     },
@@ -29,6 +33,9 @@ const _inspector = /*#__PURE__*/ _interop_require_wildcard(require("inspector"))
 const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../build/output/log"));
 const _picocolors = require("../../lib/picocolors");
 const _configschema = require("../config-schema");
+const _agentname = require("../../telemetry/agent-name");
+const _bundler = require("../../lib/bundler");
+const _generateagentfiles = require("./generate-agent-files");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -71,21 +78,8 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 function logStartInfo({ networkUrl, appUrl, envInfo, logBundler }) {
-    let versionSuffix = '';
-    const parts = [];
-    if (logBundler) {
-        if (process.env.TURBOPACK) {
-            parts.push('Turbopack');
-        } else if (process.env.NEXT_RSPACK) {
-            parts.push('Rspack');
-        } else {
-            parts.push('webpack');
-        }
-    }
-    if (parts.length > 0) {
-        versionSuffix = ` (${parts.join(', ')})`;
-    }
-    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"16.2.6"}`))}${versionSuffix}`);
+    const versionSuffix = logBundler ? ` (${(0, _bundler.bundlerName)((0, _bundler.getBundlerFromEnv)())})` : '';
+    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"16.3.3"}`))}${versionSuffix}`);
     if (appUrl) {
         _log.bootstrap(`- Local:         ${appUrl}`);
     }
@@ -103,10 +97,14 @@ function logStartInfo({ networkUrl, appUrl, envInfo, logBundler }) {
     }
     if (envInfo == null ? void 0 : envInfo.length) _log.bootstrap(`- Environments: ${envInfo.join(', ')}`);
 }
-function logExperimentalInfo({ experimentalFeatures, cacheComponents }) {
+function logExperimentalInfo({ experimentalFeatures, cacheComponents, partialPrefetching }) {
     if (cacheComponents) {
         _log.bootstrap(`- Cache Components enabled`);
     }
+    if (partialPrefetching) {
+        const mode = partialPrefetching === 'unstable_eager' ? ' (unstable_eager)' : '';
+        _log.bootstrap(`- Partial Prefetching enabled${mode}`);
+    }
     if (experimentalFeatures == null ? void 0 : experimentalFeatures.length) {
         _log.bootstrap(`- Experiments (use with caution):`);
         for (const exp of experimentalFeatures){
@@ -124,6 +122,11 @@ function logExperimentalInfo({ experimentalFeatures, cacheComponents }) {
     // New line after the bootstrap info
     _log.info('');
 }
+async function ensureAgentRulesForDev(dir) {
+    if (await (0, _agentname.getAgentName)() === null) return null;
+    if ((0, _generateagentfiles.hasCurrentAgentRules)(dir)) return null;
+    return (0, _generateagentfiles.writeAgentFiles)(dir);
+}
 function getEnvInfo(dir) {
     const { loadedEnvFiles } = (0, _env.loadEnvConfig)(dir, true, console, false);
     return loadedEnvFiles.map((f)=>f.path);

package/dist/node_modules/next/dist/server/lib/cache-handlers/default.js

@@ -5,6 +5,11 @@
  * likely going to get evicted before we get to use it anyway. However, we also
  * don't want to reuse a stale entry for too long so stale entries should be
  * considered expired/missing in such cache handlers.
+ *
+ * The dev server (`next dev`) is the exception: to keep reloads fast it serves
+ * stale entries until they expire, relying on the wrapper's
+ * stale-while-revalidate path to warm a fresh entry in the background. See
+ * `get` for where this branches.
  */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
@@ -17,6 +22,7 @@ Object.defineProperty(exports, "createDefaultCacheHandler", {
 });
 const _lrucache = require("../lru-cache");
 const _tagsmanifestexternal = require("../incremental-cache/tags-manifest.external");
+const _constants = require("../../use-cache/constants");
 function createDefaultCacheHandler(maxSize) {
     // If the max size is 0, return a cache handler that doesn't cache anything,
     // this avoids an unnecessary LRUCache instance and potential memory
@@ -30,7 +36,7 @@ function createDefaultCacheHandler(maxSize) {
             updateTags: ()=>Promise.resolve()
         };
     }
-    const memoryCache = new _lrucache.LRUCache(maxSize, (entry)=>entry.size);
+    const memoryCache = new _lrucache.LRUCache(maxSize, (entry, cacheKey)=>entry.size + cacheKey.length);
     const pendingSets = new Map();
     const debug = process.env.NEXT_PRIVATE_DEBUG_CACHE ? console.debug.bind(console, 'DefaultCacheHandler:') : undefined;
     return {
@@ -46,10 +52,29 @@ function createDefaultCacheHandler(maxSize) {
                 return undefined;
             }
             const entry = privateEntry.entry;
-            if (performance.timeOrigin + performance.now() > entry.timestamp + entry.revalidate * 1000) {
-                // In-memory caches should expire after revalidate time because it is
-                // unlikely that a new entry will be able to be used before it is dropped
-                // from the cache.
+            // A negative `expire` is an eviction sentinel: the tiered cache handler
+            // (dev-only) marks a front entry for deletion by overwriting it with a
+            // negative `expire`, since the cache-handler interface has no per-key
+            // delete. Treat it as missing here, independently of the minimum
+            // retention below (which would otherwise keep it alive). This is distinct
+            // from `revalidate = -1` below, which keeps serving the entry but forces
+            // a revalidation.
+            if (entry.expire < 0) {
+                debug == null ? void 0 : debug('get', cacheKey, 'evicted');
+                return undefined;
+            }
+            // The dev server serves stale entries until they expire (see the file
+            // overview); production drops them once past the revalidate time. In dev,
+            // an entry is retained for at least `MIN_PRERENDERABLE_EXPIRE` so that
+            // entries with a short `expire` (for example a `cacheLife({ expire: 0 })`
+            // client-only cache) still linger long enough that a reload hits the
+            // cache. That minimum is the same threshold below which the "use cache"
+            // wrapper treats an entry as dynamic, so it only extends the retention of
+            // entries that are dynamic anyway. It affects retention only; the
+            // returned entry keeps its real `expire`, so staging decisions are
+            // unchanged.
+            const maxAgeSeconds = process.env.__NEXT_DEV_SERVER ? Math.max(entry.expire, _constants.MIN_PRERENDERABLE_EXPIRE) : entry.revalidate;
+            if (performance.timeOrigin + performance.now() > entry.timestamp + maxAgeSeconds * 1000) {
                 debug == null ? void 0 : debug('get', cacheKey, 'expired');
                 return undefined;
             }
@@ -86,6 +111,17 @@ function createDefaultCacheHandler(maxSize) {
             const entry = await pendingEntry;
             let size = 0;
             try {
+                // In production an `expire: 0` entry is dynamic: the "use cache"
+                // wrapper regenerates it on every read instead of serving the stored
+                // copy, so persisting it would be a wasted write of a value that is
+                // never served back. Skip storing it so the next read is a plain miss.
+                // The dev server keeps it, because its minimum retention serves the
+                // previously cached value across reloads. The `finally` below still
+                // resolves the pending set.
+                if (!process.env.__NEXT_DEV_SERVER && entry.expire === 0) {
+                    debug == null ? void 0 : debug('set', cacheKey, 'skipped dynamic entry');
+                    return;
+                }
                 const [value, clonedValue] = entry.value.tee();
                 entry.value = value;
                 const reader = clonedValue.getReader();

package/dist/node_modules/next/dist/server/lib/cpu-profile.js

@@ -40,11 +40,8 @@ function saveCpuProfile() {
         const filename = `${baseName}-${timestamp}.cpuprofile`;
         let outputPath;
         if (cpuProfileDir) {
-            if (!fs.existsSync(cpuProfileDir)) {
-                fs.mkdirSync(cpuProfileDir, {
-                    recursive: true
-                });
-            }
+            // The CLI created `cpuProfileDir` (with its `.gitignore`) before setting
+            // NEXT_CPU_PROF_DIR, so it already exists in these build workers.
             outputPath = path.join(cpuProfileDir, filename);
         } else {
             outputPath = `./${filename}`;

package/dist/node_modules/next/dist/server/lib/dev-bundler-service.js

@@ -11,10 +11,15 @@ Object.defineProperty(exports, "DevBundlerService", {
 const _lrucache = require("./lru-cache");
 const _mockrequest = require("./mock-request");
 const _hotreloadertypes = require("../dev/hot-reloader-types");
+const _requestinsights = require("./trace/request-insights");
 class DevBundlerService {
-    constructor(bundler, handler){
+    constructor(bundler, handler, requestInsightsEnabled){
         this.bundler = bundler;
         this.handler = handler;
+        this.close = ()=>{
+            this.unsubscribeRequestInsights == null ? void 0 : this.unsubscribeRequestInsights.call(this);
+            this.bundler.hotReloader.close();
+        };
         this.ensurePage = async (definition)=>{
             // TODO: remove after ensure is pulled out of server
             return await this.bundler.hotReloader.ensurePage(definition);
@@ -24,10 +29,20 @@ class DevBundlerService {
             return 16;
         });
         const { hotReloader } = bundler;
-        this.close = hotReloader.close.bind(hotReloader);
         this.setCacheStatus = hotReloader.setCacheStatus.bind(hotReloader);
         this.setReactDebugChannel = hotReloader.setReactDebugChannel.bind(hotReloader);
         this.sendErrorsToBrowser = hotReloader.sendErrorsToBrowser.bind(hotReloader);
+        if (requestInsightsEnabled) {
+            this.unsubscribeRequestInsights = (0, _requestinsights.subscribeRequestInsights)((insight)=>{
+                hotReloader.send({
+                    type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.REQUEST_INSIGHTS_UPDATE,
+                    insight
+                });
+            });
+        }
+    }
+    getServerComponentsHmrRefreshHash() {
+        return this.bundler.hotReloader.getServerComponentsHmrRefreshHash();
     }
     async getFallbackErrorComponents(url) {
         await this.bundler.hotReloader.buildFallbackError();

package/dist/node_modules/next/dist/server/lib/encode-header-safe.js

@@ -0,0 +1,44 @@
+/**
+ * Percent-encode every character other than horizontal tab and printable ASCII
+ * so a value can be safely serialized into an HTTP header.
+ *
+ * Node's `validateHeaderValue` and `fetch`'s ByteString conversion accept
+ * different character ranges. Restricting values to `\t\x20-\x7e` produces a
+ * conservative representation that both can serialize. Characters outside a
+ * transport's accepted range (Hebrew, Arabic, Chinese, emoji, …) would
+ * otherwise throw `ERR_INVALID_CHAR` or a `TypeError`, which crashes ISR or
+ * fails a cache read on every affected request.
+ *
+ * Cache tags are encoded at the public boundaries — tag construction
+ * (`getImplicitTags`, `validateTags`) and invalidation input
+ * (`revalidatePath`, `revalidateTag`, `updateTag`) — so storage, comparison,
+ * and the wire all see the same canonical form.
+ *
+ * The class is narrower than either transport accepts. Everything inside it
+ * passes through byte-for-byte, including `,`, `/`, `%`, `[`, `]`, `_`, `-` and
+ * `\t`, which preserves the comma-separated header format and the
+ * dynamic-segment markers in derived tags (`_N_T_/[slug]/page`).
+ *
+ * Properties:
+ * - Fast-path: input that already fits the class is returned unchanged. This
+ *   makes the encoder idempotent on already-encoded `%xx` sequences.
+ * - Matches *runs* of out-of-class code units so surrogate pairs (e.g. an
+ *   emoji) are handed to `encodeURIComponent` as a complete code point — a
+ *   per-code-unit regex would split the pair and throw `URIError`.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "encodeHeaderSafe", {
+    enumerable: true,
+    get: function() {
+        return encodeHeaderSafe;
+    }
+});
+const OUT_OF_CLASS_CHAR = /[^\t\x20-\x7e]/;
+const OUT_OF_CLASS_RUN = /[^\t\x20-\x7e]+/g;
+function encodeHeaderSafe(value) {
+    return OUT_OF_CLASS_CHAR.test(value) ? value.replace(OUT_OF_CLASS_RUN, (run)=>encodeURIComponent(run)) : value;
+}
+
+//# sourceMappingURL=encode-header-safe.js.map

package/dist/node_modules/next/dist/server/lib/generate-agent-files.js

@@ -0,0 +1,180 @@
+/**
+ * Auto-generate AGENTS.md / CLAUDE.md with the managed Next.js agent-rules
+ * block when `next dev` detects an AI coding agent but the block is missing.
+ *
+ * Keep the marker and block content in sync with:
+ *   - packages/create-next-app/helpers/generate-agent-files.ts
+ *   - packages/next-codemod/lib/agents-md.ts
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    AGENT_RULES_END_MARKER: null,
+    AGENT_RULES_START_MARKER: null,
+    hasCurrentAgentRules: null,
+    writeAgentFiles: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    AGENT_RULES_END_MARKER: function() {
+        return AGENT_RULES_END_MARKER;
+    },
+    AGENT_RULES_START_MARKER: function() {
+        return AGENT_RULES_START_MARKER;
+    },
+    hasCurrentAgentRules: function() {
+        return hasCurrentAgentRules;
+    },
+    writeAgentFiles: function() {
+        return writeAgentFiles;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const AGENT_RULES_START_MARKER = '<!-- BEGIN:nextjs-agent-rules -->';
+const AGENT_RULES_END_MARKER = '<!-- END:nextjs-agent-rules -->';
+/**
+ * Markers written by the pre-bundled-docs version of `agents-md`.
+ * Stripped on upsert so projects that ran the old codemod end up with
+ * a single current block instead of two stale-and-current blocks.
+ */ const LEGACY_AGENT_RULES_START_MARKER = '<!-- NEXT-AGENTS-MD-START -->';
+const LEGACY_AGENT_RULES_END_MARKER = '<!-- NEXT-AGENTS-MD-END -->';
+function buildAgentRulesBlock() {
+    return `${AGENT_RULES_START_MARKER}
+
+# This is NOT the Next.js you know
+
+This version has breaking changes — APIs, conventions, and file structure may all differ from your training data. Read the relevant guide in \`node_modules/next/dist/docs/\` (resolved from this file's directory; in monorepos the \`next\` package may not be visible from the repo root) before writing any code. Heed deprecation notices.
+
+This block is written and re-added by \`next dev\` — verify at \`node_modules/next/dist/server/lib/generate-agent-files.js\`. Removing it from a diff only re-creates the uncommitted change; committing it with your work keeps the tree clean.
+
+${AGENT_RULES_END_MARKER}`;
+}
+const CLAUDE_MD_CONTENT = `@AGENTS.md\n`;
+/**
+ * Returns the managed block (markers included) found in `content`, or
+ * `null` when the markers are absent or malformed.
+ */ function extractAgentRulesBlock(content) {
+    const start = content.indexOf(AGENT_RULES_START_MARKER);
+    if (start === -1) return null;
+    const end = content.indexOf(AGENT_RULES_END_MARKER, start);
+    if (end === -1) return null;
+    return content.slice(start, end + AGENT_RULES_END_MARKER.length);
+}
+function hasCurrentAgentRules(dir) {
+    const block = buildAgentRulesBlock();
+    for (const file of [
+        'AGENTS.md',
+        'CLAUDE.md'
+    ]){
+        const content = tryReadFile(_path.default.join(dir, file));
+        if (!content) continue;
+        const installed = extractAgentRulesBlock(content);
+        if (installed !== null && normalizeEol(installed, '\n') === block) {
+            return true;
+        }
+    }
+    return false;
+}
+function writeAgentFiles(projectDir) {
+    var _tryReadFile, _tryReadFile1;
+    const agentsMdPath = _path.default.join(projectDir, 'AGENTS.md');
+    const claudeMdPath = _path.default.join(projectDir, 'CLAUDE.md');
+    const block = buildAgentRulesBlock();
+    const agentsMdExists = _fs.default.existsSync(agentsMdPath);
+    const claudeMdExists = _fs.default.existsSync(claudeMdPath);
+    const claudeMdHostsBlock = claudeMdExists && (((_tryReadFile = tryReadFile(claudeMdPath)) == null ? void 0 : _tryReadFile.includes(AGENT_RULES_START_MARKER)) ?? false);
+    const agentsMdHostsBlock = agentsMdExists && (((_tryReadFile1 = tryReadFile(agentsMdPath)) == null ? void 0 : _tryReadFile1.includes(AGENT_RULES_START_MARKER)) ?? false);
+    if (agentsMdExists && (agentsMdHostsBlock || !claudeMdHostsBlock)) {
+        return {
+            agentsMd: upsertFile(agentsMdPath, block),
+            claudeMd: 'skipped'
+        };
+    }
+    if (claudeMdExists) {
+        return {
+            agentsMd: 'skipped',
+            claudeMd: upsertFile(claudeMdPath, block)
+        };
+    }
+    // Neither file exists — scaffold both, matching create-next-app.
+    _fs.default.writeFileSync(agentsMdPath, block + '\n', 'utf-8');
+    _fs.default.writeFileSync(claudeMdPath, CLAUDE_MD_CONTENT, 'utf-8');
+    return {
+        agentsMd: 'created',
+        claudeMd: 'created'
+    };
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function tryReadFile(filePath) {
+    try {
+        return _fs.default.readFileSync(filePath, 'utf-8');
+    } catch  {
+        return null;
+    }
+}
+function upsertFile(filePath, block) {
+    const existing = _fs.default.readFileSync(filePath, 'utf-8');
+    const updated = upsertAgentRulesBlock(existing, block);
+    if (updated === existing) return 'unchanged';
+    _fs.default.writeFileSync(filePath, updated, 'utf-8');
+    return 'updated';
+}
+/**
+ * Detect the predominant line-ending style. Returns `'\r\n'` if any
+ * CRLF is present, `'\n'` otherwise — avoids mixed EOLs on Windows.
+ */ function detectEol(content) {
+    return /\r\n/.test(content) ? '\r\n' : '\n';
+}
+function normalizeEol(s, eol) {
+    return s.replace(/\r?\n/g, eol);
+}
+function upsertAgentRulesBlock(existing, block) {
+    const eol = detectEol(existing);
+    const normalizedBlock = normalizeEol(block, eol);
+    existing = stripLegacyAgentRulesBlock(existing, eol);
+    const startIdx = existing.indexOf(AGENT_RULES_START_MARKER);
+    const endIdx = existing.indexOf(AGENT_RULES_END_MARKER);
+    if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+        const before = existing.slice(0, startIdx);
+        const after = existing.slice(endIdx + AGENT_RULES_END_MARKER.length);
+        const replaced = before + normalizedBlock + after;
+        return replaced === existing ? existing : replaced;
+    }
+    const separator = existing.length === 0 || /\r?\n$/.test(existing) ? eol : eol + eol;
+    return existing + separator + normalizedBlock + eol;
+}
+function stripLegacyAgentRulesBlock(existing, eol = '\n') {
+    while(true){
+        const startIdx = existing.indexOf(LEGACY_AGENT_RULES_START_MARKER);
+        if (startIdx === -1) return existing;
+        const endIdx = existing.indexOf(LEGACY_AGENT_RULES_END_MARKER, startIdx);
+        if (endIdx === -1) return existing;
+        let cutStart = startIdx;
+        while(cutStart > 0 && /\s/.test(existing[cutStart - 1])){
+            cutStart--;
+        }
+        let cutEnd = endIdx + LEGACY_AGENT_RULES_END_MARKER.length;
+        while(cutEnd < existing.length && /\s/.test(existing[cutEnd])){
+            cutEnd++;
+        }
+        const before = existing.slice(0, cutStart);
+        const after = existing.slice(cutEnd);
+        existing = before.length > 0 && after.length > 0 ? before + eol + eol + after : before + after;
+    }
+}
+
+//# sourceMappingURL=generate-agent-files.js.map