@claudeye/linux-arm64 1.0.6-beta.2 → 1.0.6-beta.4

package/assets/standalone/node_modules/next/dist/build/static-paths/app.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    assignErrorIfEmpty: null,
+    assignStaticShellMetadata: null,
     buildAppStaticPaths: null,
     calculateFallbackMode: null,
     filterUniqueParams: null,
@@ -17,8 +17,8 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    assignErrorIfEmpty: function() {
-        return assignErrorIfEmpty;
+    assignStaticShellMetadata: function() {
+        return assignStaticShellMetadata;
     },
     buildAppStaticPaths: function() {
         return buildAppStaticPaths;
@@ -46,6 +46,7 @@ const _createincrementalcache = require("../../export/helpers/create-incremental
 const _getsegmentparam = require("../../shared/lib/router/utils/get-segment-param");
 const _emptygeneratestaticparamserror = require("../../shared/lib/errors/empty-generate-static-params-error");
 const _interceptionprefixfromparamtype = require("../../shared/lib/router/utils/interception-prefix-from-param-type");
+const _implicittags = require("../../server/lib/implicit-tags");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -280,7 +281,7 @@ function calculateFallbackMode(dynamicParams, fallbackRootParams, baseFallbackMo
     }
     return valid;
 }
-function assignErrorIfEmpty(prerenderedRoutes, pathnameSegments) {
+function assignStaticShellMetadata(prerenderedRoutes, pathnameSegments, computeRemainingPrerenderableParams) {
     // If there are no routes to process, exit early.
     if (prerenderedRoutes.length === 0) {
         return;
@@ -391,6 +392,31 @@ function assignErrorIfEmpty(prerenderedRoutes, pathnameSegments) {
                     route.throwOnEmptyStaticShell = true // Should throw on empty static shell.
                     ;
                 }
+                if (computeRemainingPrerenderableParams && route.fallbackRouteParams && route.fallbackRouteParams.length > 0) {
+                    const fallbackRouteParamsByName = new Map(route.fallbackRouteParams.map((param)=>[
+                            param.paramName,
+                            param
+                        ]));
+                    const remainingPrerenderableParams = [];
+                    // Only unresolved pathname params that can still be filled by
+                    // generateStaticParams belong here. Once we hit an unresolved param
+                    // that is purely dynamic, the rest of the shell also stays dynamic
+                    // and cannot be completed into a more specific prerendered shell.
+                    for (const segment of pathnameSegments){
+                        if (route.params.hasOwnProperty(segment.paramName)) {
+                            continue;
+                        }
+                        if (!segment.hasGenerateStaticParams) {
+                            break;
+                        }
+                        const fallbackRouteParam = fallbackRouteParamsByName.get(segment.paramName);
+                        if (!fallbackRouteParam) {
+                            break;
+                        }
+                        remainingPrerenderableParams.push(fallbackRouteParam);
+                    }
+                    route.remainingPrerenderableParams = remainingPrerenderableParams.length > 0 ? remainingPrerenderableParams : undefined;
+                }
             }
         }
         // Add all children of the current node to the stack. This ensures that
@@ -400,9 +426,30 @@ function assignErrorIfEmpty(prerenderedRoutes, pathnameSegments) {
         }
     }
 }
-async function generateRouteStaticParams(segments, store, isRoutePPREnabled) {
+/**
+ * Calls a single generateStaticParams function within a WorkUnitStore context,
+ * making root param getters available during static param generation.
+ */ async function callGenerateStaticParams(generateStaticParams, workUnitAsyncStorage, parentParams, rootParamKeys, implicitTags) {
+    const rootParams = {};
+    for (const key of rootParamKeys){
+        if (key in parentParams) {
+            rootParams[key] = parentParams[key];
+        }
+    }
+    const workUnitStore = {
+        type: 'generate-static-params',
+        phase: 'render',
+        implicitTags,
+        rootParams
+    };
+    return workUnitAsyncStorage.run(workUnitStore, generateStaticParams, {
+        params: parentParams
+    });
+}
+async function generateRouteStaticParams(segments, store, workUnitAsyncStorage, isRoutePPREnabled, rootParamKeys) {
     // Early return if no segments to process
     if (segments.length === 0) return [];
+    const implicitTags = await (0, _implicittags.getImplicitTags)(store.page, store.page, null);
     const queue = [
         {
             segmentIndex: 0,
@@ -436,9 +483,7 @@ async function generateRouteStaticParams(segments, store, isRoutePPREnabled) {
         if (params.length > 0) {
             // Process each parent parameter combination
             for (const parentParams of params){
-                const result = await current.generateStaticParams({
-                    params: parentParams
-                });
+                const result = await callGenerateStaticParams(current.generateStaticParams, workUnitAsyncStorage, parentParams, rootParamKeys, implicitTags);
                 if (result.length > 0) {
                     // Merge parent params with each result item
                     for (const item of result){
@@ -456,9 +501,7 @@ async function generateRouteStaticParams(segments, store, isRoutePPREnabled) {
             }
         } else {
             // No parent params, call generateStaticParams with empty object
-            const result = await current.generateStaticParams({
-                params: {}
-            });
+            const result = await callGenerateStaticParams(current.generateStaticParams, workUnitAsyncStorage, {}, rootParamKeys, implicitTags);
             if (result.length === 0 && isRoutePPREnabled) {
                 (0, _emptygeneratestaticparamserror.throwEmptyGenerateStaticParamsError)();
             }
@@ -488,7 +531,7 @@ function createReplacements(segment, paramValue) {
         encodeURIComponent)
     };
 }
-async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents, authInterrupts, segments, isrFlushToDisk, cacheHandler, cacheLifeProfiles, requestHeaders, cacheHandlers, cacheMaxMemorySize, fetchCacheKeyPrefix, nextConfigOutput, ComponentMod, isRoutePPREnabled = false, buildId, rootParamKeys }) {
+async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents, authInterrupts, segments, isrFlushToDisk, cacheHandler, cacheLifeProfiles, requestHeaders, cacheHandlers, cacheMaxMemorySize, fetchCacheKeyPrefix, nextConfigOutput, ComponentMod, isRoutePPREnabled = false, partialFallbacksEnabled = false, buildId, rootParamKeys }) {
     if (segments.some((generate)=>{
         var _generate_config;
         return ((_generate_config = generate.config) == null ? void 0 : _generate_config.dynamicParams) === true;
@@ -533,7 +576,17 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
         buildId,
         previouslyRevalidatedTags: []
     });
-    const routeParams = await ComponentMod.workAsyncStorage.run(store, generateRouteStaticParams, segments, store, isRoutePPREnabled);
+    const routeParams = await ComponentMod.workAsyncStorage.run(store, generateRouteStaticParams, segments, store, ComponentMod.workUnitAsyncStorage, isRoutePPREnabled, rootParamKeys);
+    const generatedParamNames = new Set();
+    for (const params of routeParams){
+        for (const paramName of Object.keys(params)){
+            generatedParamNames.add(paramName);
+        }
+    }
+    const prerenderablePathSegments = pathnameRouteParamSegments.map((segment)=>({
+            paramName: segment.paramName,
+            hasGenerateStaticParams: generatedParamNames.has(segment.paramName)
+        }));
     await afterRunner.executeAfter();
     let lastDynamicSegmentHadGenerateStaticParams = false;
     for (const segment of segments){
@@ -572,7 +625,7 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
         var _segment_config;
         return ((_segment_config = segment.config) == null ? void 0 : _segment_config.dynamicParams) !== false;
     });
-    const supportsRoutePreGeneration = hadAllParamsGenerated || process.env.NODE_ENV === 'production';
+    const supportsRoutePreGeneration = hadAllParamsGenerated || !process.env.__NEXT_DEV_SERVER;
     const fallbackMode = dynamicParams ? supportsRoutePreGeneration ? isRoutePPREnabled ? _fallback.FallbackMode.PRERENDER : _fallback.FallbackMode.BLOCKING_STATIC_RENDER : undefined : _fallback.FallbackMode.NOT_FOUND;
     const prerenderedRoutesByPathname = new Map();
     // Convert rootParamKeys to Set for O(1) lookup.
@@ -671,7 +724,7 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
     ] : undefined;
     // Now we have to set the throwOnEmptyStaticShell for each of the routes.
     if (prerenderedRoutes && cacheComponents) {
-        assignErrorIfEmpty(prerenderedRoutes, pathnameRouteParamSegments);
+        assignStaticShellMetadata(prerenderedRoutes, prerenderablePathSegments, partialFallbacksEnabled);
     }
     return {
         fallbackMode,

package/assets/standalone/node_modules/next/dist/build/static-paths/pages.js

@@ -38,7 +38,7 @@ async function buildPagesStaticPaths({ page, getStaticPaths, configFileName, loc
     const expectedReturnVal = `Expected: { paths: [], fallback: boolean }\n` + `See here for more info: https://nextjs.org/docs/messages/invalid-getstaticpaths-value`;
     if (!staticPathsResult || typeof staticPathsResult !== 'object' || Array.isArray(staticPathsResult)) {
         throw Object.defineProperty(new Error(`Invalid value returned from getStaticPaths in ${page}. Received ${typeof staticPathsResult} ${expectedReturnVal}`), "__NEXT_ERROR_CODE", {
-            value: "E241",
+            value: "E1004",
             enumerable: false,
             configurable: true
         });
@@ -46,14 +46,14 @@ async function buildPagesStaticPaths({ page, getStaticPaths, configFileName, loc
     const invalidStaticPathKeys = Object.keys(staticPathsResult).filter((key)=>!(key === 'paths' || key === 'fallback'));
     if (invalidStaticPathKeys.length > 0) {
         throw Object.defineProperty(new Error(`Extra keys returned from getStaticPaths in ${page} (${invalidStaticPathKeys.join(', ')}) ${expectedReturnVal}`), "__NEXT_ERROR_CODE", {
-            value: "E38",
+            value: "E1047",
             enumerable: false,
             configurable: true
         });
     }
     if (!(typeof staticPathsResult.fallback === 'boolean' || staticPathsResult.fallback === 'blocking')) {
         throw Object.defineProperty(new Error(`The \`fallback\` key must be returned from getStaticPaths in ${page}.\n` + expectedReturnVal), "__NEXT_ERROR_CODE", {
-            value: "E243",
+            value: "E1034",
             enumerable: false,
             configurable: true
         });

package/assets/standalone/node_modules/next/dist/build/swc/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
+    HmrTarget: null,
     createDefineEnv: null,
     getBinaryMetadata: null,
     getBindingsSync: null,
@@ -26,6 +27,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    HmrTarget: function() {
+        return HmrTarget;
+    },
     createDefineEnv: function() {
         return createDefineEnv;
     },
@@ -77,13 +81,8 @@ const _url = require("url");
 const _os = require("os");
 const _triples = require("next/dist/compiled/@napi-rs/triples");
 const _log = /*#__PURE__*/ _interop_require_wildcard(require("../output/log"));
-const _options = require("./options");
-const _swcloadfailure = require("../../telemetry/events/swc-load-failure");
-const _patchincorrectlockfile = require("../../lib/patch-incorrect-lockfile");
-const _downloadswc = require("../../lib/download-swc");
-const _util = require("util");
 const _defineenv = require("../define-env");
-const _internalerror = require("../../shared/lib/turbopack/internal-error");
+const _loaderWorkerPool = require("./loaderWorkerPool");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -130,7 +129,12 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-const nextVersion = "16.1.6";
+var HmrTarget = /*#__PURE__*/ function(HmrTarget) {
+    HmrTarget["Client"] = "client";
+    HmrTarget["Server"] = "server";
+    return HmrTarget;
+}({});
+const nextVersion = "16.2.1";
 const ArchName = (0, _os.arch)();
 const PlatformName = (0, _os.platform)();
 function infoLog(...args) {
@@ -179,9 +183,9 @@ const triples = (()=>{
     // Otherwise, it is completely unsupported platforms.
     let rawTargetTriple = (_platformArchTriples_PlatformName = _triples.platformArchTriples[PlatformName]) == null ? void 0 : _platformArchTriples_PlatformName[ArchName];
     if (rawTargetTriple) {
-        _log.warn(`Trying to load next-swc for target triple ${rawTargetTriple}, but there next-swc does not have native bindings support`);
+        _log.warn(`next-swc does not have native bindings support for target triple ${rawTargetTriple}. Native features like Turbopack will not be available.`);
     } else {
-        _log.warn(`Trying to load next-swc for unsupported platforms ${PlatformName}/${ArchName}`);
+        _log.warn(`next-swc does not have native bindings for platform ${PlatformName}/${ArchName}. Native features like Turbopack will not be available.`);
     }
     return [];
 })();
@@ -268,7 +272,7 @@ async function loadBindings(useWasmBinary = false) {
         if (!lockfilePatchPromise.cur) {
             // always run lockfile check once so that it gets patched
             // even if it doesn't fail to load locally
-            lockfilePatchPromise.cur = (0, _patchincorrectlockfile.patchIncorrectLockfile)(process.cwd()).catch(console.error);
+            lockfilePatchPromise.cur = require('../../lib/patch-incorrect-lockfile').patchIncorrectLockfile(process.cwd()).catch(console.error);
         }
         let attempts = [];
         const disableWasmFallback = process.env.NEXT_DISABLE_SWC_WASM;
@@ -328,7 +332,7 @@ async function loadBindings(useWasmBinary = false) {
 async function tryLoadNativeWithFallback(attempts) {
     const nativeBindingsDirectory = _path.default.join(_path.default.dirname(require.resolve('next/package.json')), 'next-swc-fallback');
     if (!downloadNativeBindingsPromise) {
-        downloadNativeBindingsPromise = (0, _downloadswc.downloadNativeNextSwc)(nextVersion, nativeBindingsDirectory, triples.map((triple)=>triple.platformArchABI));
+        downloadNativeBindingsPromise = require('../../lib/download-swc').downloadNativeNextSwc(nextVersion, nativeBindingsDirectory, triples.map((triple)=>triple.platformArchABI));
     }
     await downloadNativeBindingsPromise;
     try {
@@ -342,8 +346,7 @@ async function tryLoadNativeWithFallback(attempts) {
 async function tryLoadWasmWithFallback(attempts) {
     try {
         let bindings = await loadWasm('');
-        // @ts-expect-error TODO: this event has a wrong type.
-        (0, _swcloadfailure.eventSwcLoadFailure)({
+        require('../../telemetry/events/swc-load-failure').eventSwcLoadFailure({
             wasm: 'enabled',
             nativeBindingsErrorCode: lastNativeBindingsLoadErrorCode
         });
@@ -358,12 +361,11 @@ async function tryLoadWasmWithFallback(attempts) {
         // x-ref: https://github.com/nodejs/modules/issues/307
         const wasmDirectory = _path.default.join(_path.default.dirname(require.resolve('next/package.json')), 'wasm');
         if (!downloadWasmPromise) {
-            downloadWasmPromise = (0, _downloadswc.downloadWasmSwc)(nextVersion, wasmDirectory);
+            downloadWasmPromise = require('../../lib/download-swc').downloadWasmSwc(nextVersion, wasmDirectory);
         }
         await downloadWasmPromise;
         let bindings = await loadWasm(wasmDirectory);
-        // @ts-expect-error TODO: this event has a wrong type.
-        (0, _swcloadfailure.eventSwcLoadFailure)({
+        require('../../telemetry/events/swc-load-failure').eventSwcLoadFailure({
             wasm: 'fallback',
             nativeBindingsErrorCode: lastNativeBindingsLoadErrorCode
         });
@@ -408,8 +410,7 @@ let loggingLoadFailure = false;
     for (let attempt of attempts){
         _log.warn(attempt);
     }
-    // @ts-expect-error TODO: this event has a wrong type.
-    await (0, _swcloadfailure.eventSwcLoadFailure)({
+    await require('../../telemetry/events/swc-load-failure').eventSwcLoadFailure({
         wasm: triedWasm ? 'failed' : undefined,
         nativeBindingsErrorCode: lastNativeBindingsLoadErrorCode
     });
@@ -455,7 +456,7 @@ function rustifyOptionEnv(env) {
 }
 const normalizePathOnWindows = (p)=>_path.default.sep === '\\' ? p.replace(/\\/g, '/') : p;
 // TODO(sokra) Support wasm option.
-function bindingToApi(binding, _wasm) {
+function bindingToApi(binding, bindingPath, _wasm) {
     const cancel = new class Cancel extends Error {
     }();
     /**
@@ -553,6 +554,9 @@ function bindingToApi(binding, _wasm) {
     class ProjectImpl {
         constructor(nativeProject){
             this._nativeProject = nativeProject;
+            if (typeof binding.registerWorkerScheduler === 'function') {
+                (0, _loaderWorkerPool.runLoaderWorkerPool)(binding, bindingPath);
+            }
         }
         async update(options) {
             await binding.projectUpdate(this._nativeProject, await rustifyPartialProjectOptions(options));
@@ -587,11 +591,15 @@ function bindingToApi(binding, _wasm) {
                 }
             }();
         }
-        hmrEvents(identifier) {
-            return subscribe(true, async (callback)=>binding.projectHmrEvents(this._nativeProject, identifier, callback));
+        hmrEvents(chunkName, target) {
+            return subscribe(true, async (callback)=>binding.projectHmrEvents(this._nativeProject, chunkName, target, callback));
         }
-        hmrIdentifiersSubscribe() {
-            return subscribe(false, async (callback)=>binding.projectHmrIdentifiersSubscribe(this._nativeProject, callback));
+        /**
+     * Subscribe to the list of output chunk paths that can receive HMR updates.
+     * Chunk paths are output file paths like "server/chunks/ssr/..._.js" for server
+     * or "_next/static/chunks/app/page.js" for client.
+     */ hmrChunkNamesSubscribe(target) {
+            return subscribe(false, async (callback)=>binding.projectHmrChunkNamesSubscribe(this._nativeProject, target, callback));
         }
         traceSource(stackFrame, currentDirectoryFileUrl) {
             return binding.projectTraceSource(this._nativeProject, stackFrame, currentDirectoryFileUrl);
@@ -687,6 +695,27 @@ function bindingToApi(binding, _wasm) {
             if (turbopack.rules) {
                 turbopack.rules = serializeTurbopackRules(turbopack.rules);
             }
+            // Serialize ignoreIssue rules: convert RegExp to {source, flags}
+            if (turbopack.ignoreIssue) {
+                function serializePatternField(value, stringType) {
+                    if (value instanceof RegExp) {
+                        return {
+                            type: 'regex',
+                            source: value.source,
+                            flags: value.flags
+                        };
+                    }
+                    return {
+                        type: stringType,
+                        value
+                    };
+                }
+                turbopack.ignoreIssue = turbopack.ignoreIssue.map((rule)=>({
+                        path: serializePatternField(rule.path, 'glob'),
+                        title: rule.title != null ? serializePatternField(rule.title, 'string') : undefined,
+                        description: rule.description != null ? serializePatternField(rule.description, 'string') : undefined
+                    }));
+            }
             nextConfigSerializable.turbopack = turbopack;
         }
         return JSON.stringify(nextConfigSerializable, null, 2);
@@ -727,7 +756,21 @@ function bindingToApi(binding, _wasm) {
                     type: 'glob',
                     value: cond.path
                 },
-                content: cond.content && regexComponents(cond.content)
+                content: cond.content && regexComponents(cond.content),
+                query: cond.query == null ? undefined : cond.query instanceof RegExp ? {
+                    type: 'regex',
+                    value: regexComponents(cond.query)
+                } : {
+                    type: 'constant',
+                    value: cond.query
+                },
+                contentType: cond.contentType == null ? undefined : cond.contentType instanceof RegExp ? {
+                    type: 'regex',
+                    value: regexComponents(cond.contentType)
+                } : {
+                    type: 'glob',
+                    value: cond.contentType
+                }
             };
         }
     }
@@ -737,7 +780,7 @@ function bindingToApi(binding, _wasm) {
         for (const [glob, rule] of Object.entries(turbopackRules)){
             if (Array.isArray(rule)) {
                 serializedRules[glob] = rule.map((item)=>{
-                    if (typeof item !== 'string' && 'loaders' in item) {
+                    if (typeof item !== 'string' && ('loaders' in item || 'type' in item || 'condition' in item)) {
                         return serializeConfigItem(item, glob);
                     } else {
                         checkLoaderItem(item, glob);
@@ -751,8 +794,10 @@ function bindingToApi(binding, _wasm) {
         return serializedRules;
         function serializeConfigItem(rule, glob) {
             if (!rule) return rule;
-            for (const item of rule.loaders){
-                checkLoaderItem(item, glob);
+            if (rule.loaders) {
+                for (const item of rule.loaders){
+                    checkLoaderItem(item, glob);
+                }
             }
             let serializedRule = rule;
             if (rule.condition != null) {
@@ -764,7 +809,7 @@ function bindingToApi(binding, _wasm) {
             return serializedRule;
         }
         function checkLoaderItem(loaderItem, glob) {
-            if (typeof loaderItem !== 'string' && !(0, _util.isDeepStrictEqual)(loaderItem, JSON.parse(JSON.stringify(loaderItem)))) {
+            if (typeof loaderItem !== 'string' && !require('util').isDeepStrictEqual(loaderItem, JSON.parse(JSON.stringify(loaderItem)))) {
                 throw Object.defineProperty(new Error(`loader ${loaderItem.loader} for match "${glob}" does not have serializable options. ` + 'Ensure that options passed are plain JavaScript objects and values.'), "__NEXT_ERROR_CODE", {
                     value: "E491",
                     enumerable: false,
@@ -843,9 +888,10 @@ function bindingToApi(binding, _wasm) {
             diagnostics: entrypoints.diagnostics
         };
     }
-    return async function createProject(options, turboEngineOptions) {
+    return async function createProject(options, turboEngineOptions, callbacks) {
         return new ProjectImpl(await binding.projectNew(await rustifyProjectOptions(options), turboEngineOptions || {}, {
-            throwTurbopackInternalError: _internalerror.throwTurbopackInternalError
+            throwTurbopackInternalError: require('../../shared/lib/turbopack/internal-error').throwTurbopackInternalError,
+            onBeforeDeferredEntries: callbacks == null ? void 0 : callbacks.onBeforeDeferredEntries
         }));
     };
 }
@@ -936,6 +982,13 @@ async function loadWasm(importPath = '') {
                         enumerable: false,
                         configurable: true
                     });
+                },
+                featureNamesToMask: function(_names) {
+                    throw Object.defineProperty(new Error('`css.lightning.featureNamesToMask` is not supported by the wasm bindings.'), "__NEXT_ERROR_CODE", {
+                        value: "E1090",
+                        enumerable: false,
+                        configurable: true
+                    });
                 }
             }
         },
@@ -959,16 +1012,16 @@ async function loadWasm(importPath = '') {
             return undefined;
         },
         turbo: {
-            createProject (_options, _turboEngineOptions) {
-                throw Object.defineProperty(new Error('`turbo.createProject` is not supported by the wasm bindings.'), "__NEXT_ERROR_CODE", {
-                    value: "E403",
+            createProject (_options, _turboEngineOptions, _callbacks) {
+                throw Object.defineProperty(new Error(`Turbopack is not supported on this platform (${PlatformName}/${ArchName}) because native bindings are not available. ` + `Only WebAssembly (WASM) bindings were loaded, and Turbopack requires native bindings. ` + `Use the --webpack flag instead.`), "__NEXT_ERROR_CODE", {
+                    value: "E1052",
                     enumerable: false,
                     configurable: true
                 });
             },
             startTurbopackTraceServer (_traceFilePath, _port) {
-                throw Object.defineProperty(new Error('`turbo.startTurbopackTraceServer` is not supported by the wasm bindings.'), "__NEXT_ERROR_CODE", {
-                    value: "E13",
+                throw Object.defineProperty(new Error(`Turbopack trace server is not supported on this platform (${PlatformName}/${ArchName}) because native bindings are not available. ` + `Only WebAssembly (WASM) bindings were loaded, and Turbopack requires native bindings.`), "__NEXT_ERROR_CODE", {
+                    value: "E1051",
                     enumerable: false,
                     configurable: true
                 });
@@ -1006,14 +1059,17 @@ async function loadWasm(importPath = '') {
         expandNextJsTemplate (content, templatePath, nextPackageDirPath, replacements, injections, imports) {
             return rawBindings.expandNextJsTemplate(content, templatePath, nextPackageDirPath, replacements, injections, imports);
         },
-        lockfileTryAcquire (_filePath) {
+        codeFrameColumns (source, location, options) {
+            return rawBindings.codeFrameColumns(Buffer.from(source), location, options);
+        },
+        lockfileTryAcquire (_filePath, _content) {
             throw Object.defineProperty(new Error('`lockfileTryAcquire` is not supported by the wasm bindings.'), "__NEXT_ERROR_CODE", {
                 value: "E855",
                 enumerable: false,
                 configurable: true
             });
         },
-        lockfileTryAcquireSync (_filePath) {
+        lockfileTryAcquireSync (_filePath, _content) {
             throw Object.defineProperty(new Error('`lockfileTryAcquireSync` is not supported by the wasm bindings.'), "__NEXT_ERROR_CODE", {
                 value: "E856",
                 enumerable: false,
@@ -1051,31 +1107,44 @@ async function loadWasm(importPath = '') {
             configurable: true
         });
     }
-    const customBindings = !!__INTERNAL_CUSTOM_TURBOPACK_BINDINGS ? require(__INTERNAL_CUSTOM_TURBOPACK_BINDINGS) : null;
+    const customBindingsPath = !!__INTERNAL_CUSTOM_TURBOPACK_BINDINGS ? require.resolve(__INTERNAL_CUSTOM_TURBOPACK_BINDINGS) : null;
+    const customBindings = customBindingsPath != null ? require(customBindingsPath) : null;
     let bindings = customBindings;
+    let bindingsPath = customBindingsPath;
+    // callers expect that if loadNative throws, it's an array of strings.
     let attempts = [];
     const NEXT_TEST_NATIVE_DIR = process.env.NEXT_TEST_NATIVE_DIR;
     for (const triple of triples){
         if (NEXT_TEST_NATIVE_DIR) {
             try {
+                const bindingForTest = `${NEXT_TEST_NATIVE_DIR}/next-swc.${triple.platformArchABI}.node`;
                 // Use the binary directly to skip `pnpm pack` for testing as it's slow because of the large native binary.
-                bindings = require(`${NEXT_TEST_NATIVE_DIR}/next-swc.${triple.platformArchABI}.node`);
+                bindingsPath = require.resolve(bindingForTest);
+                bindings = require(bindingsPath);
                 infoLog('next-swc build: local built @next/swc from NEXT_TEST_NATIVE_DIR');
                 break;
-            } catch (e) {}
-        } else {
+            } catch (e) {
+                attempts.push(`Failed to load triple ${triple.platformArchABI}: ${e.message ?? e}`);
+            }
+        } else if (process.env.NEXT_TEST_NATIVE_IGNORE_LOCAL_INSTALL !== 'true') {
             try {
-                bindings = require(`@next/swc/native/next-swc.${triple.platformArchABI}.node`);
+                const normalBinding = `@next/swc/native/next-swc.${triple.platformArchABI}.node`;
+                bindings = require(normalBinding);
+                bindingsPath = require.resolve(normalBinding);
                 infoLog('next-swc build: local built @next/swc');
                 break;
             } catch (e) {}
         }
     }
     if (!bindings) {
+        if (NEXT_TEST_NATIVE_DIR) {
+            throw attempts;
+        }
         for (const triple of triples){
             let pkg = importPath ? _path.default.join(importPath, `@next/swc-${triple.platformArchABI}`, `next-swc.${triple.platformArchABI}.node`) : `@next/swc-${triple.platformArchABI}`;
             try {
                 bindings = require(pkg);
+                bindingsPath = require.resolve(pkg);
                 if (!importPath) {
                     checkVersionMismatch(require(`${pkg}/package.json`));
                 }
@@ -1137,7 +1206,7 @@ async function loadWasm(importPath = '') {
             initCustomTraceSubscriber: bindings.initCustomTraceSubscriber,
             teardownTraceSubscriber: bindings.teardownTraceSubscriber,
             turbo: {
-                createProject: bindingToApi(customBindings ?? bindings, false),
+                createProject: bindingToApi(customBindings ?? bindings, customBindingsPath ?? bindingsPath, false),
                 startTurbopackTraceServer (traceFilePath, port) {
                     _log.warn(`Turbopack trace server started. View trace at https://trace.nextjs.org${port != null ? `?port=${port}` : ''}`);
                     (customBindings ?? bindings).startTurbopackTraceServer(traceFilePath, port);
@@ -1158,6 +1227,9 @@ async function loadWasm(importPath = '') {
                     },
                     transformStyleAttr (transformAttrOptions) {
                         return bindings.lightningCssTransformStyleAttribute(transformAttrOptions);
+                    },
+                    featureNamesToMask (names) {
+                        return bindings.lightningcssFeatureNamesToMaskNapi(names);
                     }
                 }
             },
@@ -1177,17 +1249,22 @@ async function loadWasm(importPath = '') {
             expandNextJsTemplate (content, templatePath, nextPackageDirPath, replacements, injections, imports) {
                 return bindings.expandNextJsTemplate(content, templatePath, nextPackageDirPath, replacements, injections, imports);
             },
-            lockfileTryAcquire (filePath) {
-                return bindings.lockfileTryAcquire(filePath);
+            lockfileTryAcquire (filePath, content) {
+                return bindings.lockfileTryAcquire(filePath, content);
             },
-            lockfileTryAcquireSync (filePath) {
-                return bindings.lockfileTryAcquireSync(filePath);
+            lockfileTryAcquireSync (filePath, content) {
+                return bindings.lockfileTryAcquireSync(filePath, content);
             },
             lockfileUnlock (lockfile) {
                 return bindings.lockfileUnlock(lockfile);
             },
             lockfileUnlockSync (lockfile) {
                 return bindings.lockfileUnlockSync(lockfile);
+            },
+            codeFrameColumns (source, location, options) {
+                // napi-rs translates Option::None as null but wasm-bindgen translates it to `null`
+                // convert here for consistency
+                return bindings.codeFrameColumns(source, location, options) ?? undefined;
             }
         };
         return loadedBindings;
@@ -1225,7 +1302,7 @@ function isReactCompilerRequired(filename) {
 }
 async function parse(src, options) {
     const bindings = getBindingsSync();
-    const parserOptions = (0, _options.getParserOptions)(options);
+    const parserOptions = require('./options').getParserOptions(options);
     const parsed = await bindings.parse(src, parserOptions);
     return JSON.parse(parsed);
 }

package/assets/standalone/node_modules/next/dist/build/swc/jest-transformer.js

@@ -59,6 +59,7 @@ const createTransformer = (inputOptions)=>({
                 modularizeImports: inputOptions == null ? void 0 : inputOptions.modularizeImports,
                 swcPlugins: inputOptions == null ? void 0 : inputOptions.swcPlugins,
                 compilerOptions: inputOptions == null ? void 0 : inputOptions.compilerOptions,
+                imageConfig: inputOptions == null ? void 0 : inputOptions.imageConfig,
                 serverReferenceHashSalt: '',
                 esm: isSupportEsm && isEsm(Boolean(inputOptions == null ? void 0 : inputOptions.isEsmProject), filename, jestConfig)
             });

package/assets/standalone/node_modules/next/dist/build/swc/loaderWorkerPool.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "runLoaderWorkerPool", {
+    enumerable: true,
+    get: function() {
+        return runLoaderWorkerPool;
+    }
+});
+const _worker_threads = require("worker_threads");
+const loaderWorkers = {};
+function getPoolId(cwd, filename) {
+    return `${cwd}:${filename}`;
+}
+async function runLoaderWorkerPool(bindings, bindingPath) {
+    bindings.registerWorkerScheduler((creation)=>{
+        const { options: { filename, cwd } } = creation;
+        const poolId = getPoolId(cwd, filename);
+        const worker = new _worker_threads.Worker(/* turbopackIgnore: true*/ filename, {
+            workerData: {
+                bindingPath,
+                cwd
+            }
+        });
+        // This will cause handing when run in jest worker, but not as a first level thread of nodejs thread
+        // worker.unref()
+        const workers = loaderWorkers[poolId] || (loaderWorkers[poolId] = new Map());
+        workers.set(worker.threadId, worker);
+    }, (termination)=>{
+        var _workers_get;
+        const { options: { filename, cwd }, workerId } = termination;
+        const poolId = getPoolId(cwd, filename);
+        const workers = loaderWorkers[poolId];
+        (_workers_get = workers.get(workerId)) == null ? void 0 : _workers_get.terminate();
+        workers.delete(workerId);
+    });
+}
+
+//# sourceMappingURL=loaderWorkerPool.js.map