failproofai 1.0.11-beta.1 → 1.0.11-beta.2

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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    HmrTarget: null,
     createDefineEnv: null,
     getBinaryMetadata: null,
     getBindingsSync: null,
@@ -28,9 +27,6 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    HmrTarget: function() {
-        return HmrTarget;
-    },
     createDefineEnv: function() {
         return createDefineEnv;
     },
@@ -134,12 +130,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-var HmrTarget = /*#__PURE__*/ function(HmrTarget) {
-    HmrTarget["Client"] = "client";
-    HmrTarget["Server"] = "server";
-    return HmrTarget;
-}({});
-const nextVersion = "16.3.8";
+const nextVersion = "16.4.0";
 const ArchName = (0, _os.arch)();
 const PlatformName = (0, _os.platform)();
 function infoLog(...args) {
@@ -234,17 +225,9 @@ const lockfilePatchPromise = {};
 function getBindingsSync() {
     if (!loadedBindings) {
         if (pendingBindings) {
-            throw Object.defineProperty(new Error('Bindings not loaded yet, but they are being loaded, did you forget to await?'), "__NEXT_ERROR_CODE", {
-                value: "E906",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Bindings not loaded yet, but they are being loaded, did you forget to await?');
         }
-        throw Object.defineProperty(new Error('bindings not loaded yet.  Either call `loadBindings` to wait for them to be available or ensure that `installBindings` has already been called.'), "__NEXT_ERROR_CODE", {
-            value: "E907",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('bindings not loaded yet.  Either call `loadBindings` to wait for them to be available or ensure that `installBindings` has already been called.');
     }
     return loadedBindings;
 }
@@ -319,11 +302,7 @@ async function loadBindings(useWasmBinary = false) {
         }
         await logLoadFailure(attempts, true);
         // Reject the promise to propagate the error (process.exit was removed to allow telemetry flush)
-        reject(Object.defineProperty(new Error(`Failed to load SWC binary for ${PlatformName}/${ArchName}, see more info here: https://nextjs.org/docs/messages/failed-loading-swc`), "__NEXT_ERROR_CODE", {
-            value: "E909",
-            enumerable: false,
-            configurable: true
-        }));
+        reject(new Error(`Failed to load SWC binary for ${PlatformName}/${ArchName}, see more info here: https://nextjs.org/docs/messages/failed-loading-swc`));
     });
     loadedBindings = await pendingBindings;
     pendingBindings = undefined;
@@ -389,12 +368,8 @@ function loadBindingsSync() {
     // Fire-and-forget telemetry logging (loadBindingsSync must remain synchronous)
     // Worker error handler will await telemetry.flush() before exit
     logLoadFailure(attempts);
-    throw Object.defineProperty(new Error('Failed to load bindings', {
+    throw new Error('Failed to load bindings', {
         cause: attempts
-    }), "__NEXT_ERROR_CODE", {
-        value: "E424",
-        enumerable: false,
-        configurable: true
     });
 }
 let loggingLoadFailure = false;
@@ -465,11 +440,7 @@ function bindingToApi(binding, bindingPath, _wasm) {
     /**
    * Utility function to ensure all variants of an enum are handled.
    */ function invariant(never, computeMessage) {
-        throw Object.defineProperty(new Error(`Invariant: ${computeMessage(never)}`), "__NEXT_ERROR_CODE", {
-            value: "E193",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Invariant: ${computeMessage(never)}`);
     }
     /**
    * Calls a native function and streams the result.
@@ -541,28 +512,38 @@ function bindingToApi(binding, bindingPath, _wasm) {
         return iterator;
     }
     async function rustifyProjectOptions(options) {
+        const projectPath = _path.default.join(options.rootPath, options.projectPath);
+        const additionalRoots = Object.entries(options.nextConfig.experimental.turbopackAdditionalRoots ?? {}).map(([key, root])=>({
+                key,
+                ...root
+            }));
         return {
             ...options,
-            nextConfig: await serializeNextConfig(options.nextConfig, _path.default.join(options.rootPath, options.projectPath)),
+            additionalRoots,
+            nextConfig: await serializeNextConfig(options.nextConfig, projectPath, _path.default.isAbsolute(options.distDir) ? _path.default.relative(projectPath, options.distDir) : options.distDir),
             env: rustifyEnv(options.env)
         };
     }
-    async function rustifyPartialProjectOptions(options) {
+    async function rustifyPartialProjectOptions(options, projectPath) {
         return {
             ...options,
-            nextConfig: options.nextConfig && await serializeNextConfig(options.nextConfig, _path.default.join(options.rootPath, options.projectPath)),
+            nextConfig: options.nextConfig && await serializeNextConfig(options.nextConfig, projectPath),
             env: options.env && rustifyEnv(options.env)
         };
     }
     class ProjectImpl {
-        constructor(nativeProject){
+        constructor(nativeProject, projectPath){
+            this.projectPath = projectPath;
             this._nativeProject = nativeProject;
             if (typeof binding.registerWorkerScheduler === 'function') {
                 (0, _loaderWorkerPool.runLoaderWorkerPool)(binding, bindingPath);
             }
         }
         async update(options) {
-            await binding.projectUpdate(this._nativeProject, await rustifyPartialProjectOptions(options));
+            await binding.projectUpdate(this._nativeProject, await rustifyPartialProjectOptions(options, this.projectPath));
+        }
+        async activateLazyChunk(chunkPath) {
+            return binding.projectActivateLazyChunk(this._nativeProject, chunkPath);
         }
         async writeAnalyzeData(appDirOnly) {
             const napiResult = await binding.projectWriteAnalyzeData(this._nativeProject, appDirOnly);
@@ -574,10 +555,11 @@ function bindingToApi(binding, bindingPath, _wasm) {
         }
         async writeAllEntrypointsToDisk(appDirOnly) {
             const napiEndpoints = await binding.projectWriteAllEntrypointsToDisk(this._nativeProject, appDirOnly);
-            if ('routes' in napiEndpoints) {
+            if (napiEndpoints.value && 'routes' in napiEndpoints.value) {
                 return napiEntrypointsToRawEntrypoints(napiEndpoints);
             } else {
                 return {
+                    value: {},
                     issues: napiEndpoints.issues
                 };
             }
@@ -589,30 +571,26 @@ function bindingToApi(binding, bindingPath, _wasm) {
             const subscription = subscribe(false, async (callback)=>binding.projectEntrypointsSubscribe(this._nativeProject, callback));
             return async function*() {
                 for await (const entrypoints of subscription){
-                    if ('routes' in entrypoints) {
+                    if (entrypoints.value && 'routes' in entrypoints.value) {
                         yield napiEntrypointsToRawEntrypoints(entrypoints);
                     } else {
                         yield {
+                            value: {},
                             issues: entrypoints.issues
                         };
                     }
                 }
             }();
         }
-        // Note: only the Server target is implemented in the native binding;
-        // add a Client overload once `all_hmr_update` supports it.
-        allHmrEvents(target) {
-            return subscribe(true, async (callback)=>binding.projectAllHmrEvents(this._nativeProject, target, callback));
+        async getServerHmrUpdate(from, entryPaths) {
+            // napi cannot express the field correlation.
+            return binding.projectGetServerHmrUpdate(this._nativeProject, from, entryPaths);
         }
-        hmrEvents(chunkName, target) {
-            return subscribe(true, async (callback)=>binding.projectHmrEvents(this._nativeProject, chunkName, target, callback));
+        clientHmrEvents(chunkName) {
+            return subscribe(true, async (callback)=>binding.projectClientHmrEvents(this._nativeProject, chunkName, 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));
+        /** Subscribe to client output chunk paths that can receive HMR updates. */ clientHmrChunkNamesSubscribe() {
+            return subscribe(false, async (callback)=>binding.projectClientHmrChunkNamesSubscribe(this._nativeProject, callback));
         }
         traceSource(stackFrame, currentDirectoryFileUrl) {
             return binding.projectTraceSource(this._nativeProject, stackFrame, currentDirectoryFileUrl);
@@ -662,7 +640,7 @@ function bindingToApi(binding, bindingPath, _wasm) {
             return serverSubscription;
         }
     }
-    async function serializeNextConfig(nextConfig, projectPath) {
+    async function serializeNextConfig(nextConfig, projectPath, distDir) {
         var _nextConfigSerializable_experimental;
         // Avoid mutating the existing `nextConfig` object. NOTE: This is only a shallow clone.
         let nextConfigSerializable = {
@@ -682,7 +660,7 @@ function bindingToApi(binding, bindingPath, _wasm) {
                 ]));
         }
         // These are relative paths, but might be backslash-separated on Windows
-        nextConfigSerializable.distDir = normalizePathOnWindows(nextConfigSerializable.distDir);
+        nextConfigSerializable.distDir = normalizePathOnWindows(distDir ?? nextConfigSerializable.distDir);
         nextConfigSerializable.distDirRoot = normalizePathOnWindows(nextConfigSerializable.distDirRoot);
         // loaderFile is an absolute path, we need it to be relative for turbopack.
         if (nextConfigSerializable.images.loaderFile) {
@@ -711,7 +689,7 @@ function bindingToApi(binding, bindingPath, _wasm) {
                 ...nextConfigSerializable.turbopack
             };
             if (turbopack.rules) {
-                turbopack.rules = serializeTurbopackRules(turbopack.rules);
+                turbopack.rules = serializeTurbopackRules(turbopack.rules, projectPath);
             }
             // Serialize ignoreIssue rules: convert RegExp to {source, flags}
             if (turbopack.ignoreIssue) {
@@ -740,7 +718,7 @@ function bindingToApi(binding, bindingPath, _wasm) {
         // {source, flags} since RegExp objects are not JSON-serializable.
         const chunkingConfig = (_nextConfigSerializable_experimental = nextConfigSerializable.experimental) == null ? void 0 : _nextConfigSerializable_experimental.turbopackChunking;
         if (chunkingConfig) {
-            var _chunkingConfig_priorityRoutes;
+            var _chunkingConfig_clusters, _chunkingConfig_priorityRoutes;
             const regexComponents = (regex)=>({
                     source: regex.source,
                     flags: regex.flags
@@ -749,6 +727,7 @@ function bindingToApi(binding, bindingPath, _wasm) {
                 ...nextConfigSerializable.experimental,
                 turbopackChunking: {
                     ...chunkingConfig,
+                    clusters: (_chunkingConfig_clusters = chunkingConfig.clusters) == null ? void 0 : _chunkingConfig_clusters.map((cluster)=>cluster.map(regexComponents)),
                     priorityRoutes: (_chunkingConfig_priorityRoutes = chunkingConfig.priorityRoutes) == null ? void 0 : _chunkingConfig_priorityRoutes.map(regexComponents)
                 }
             };
@@ -810,7 +789,7 @@ function bindingToApi(binding, bindingPath, _wasm) {
         }
     }
     // Note: Returns an updated `turbopackRules` with serialized conditions. Does not mutate in-place.
-    function serializeTurbopackRules(turbopackRules) {
+    function serializeTurbopackRules(turbopackRules, projectPath) {
         const serializedRules = {};
         for (const [glob, rule] of Object.entries(turbopackRules)){
             if (Array.isArray(rule)) {
@@ -818,8 +797,7 @@ function bindingToApi(binding, bindingPath, _wasm) {
                     if (typeof item !== 'string' && ('loaders' in item || 'type' in item || 'condition' in item)) {
                         return serializeConfigItem(item, glob);
                     } else {
-                        checkLoaderItem(item, glob);
-                        return item;
+                        return serializeLoaderItem(item, glob);
                     }
                 });
             } else {
@@ -830,9 +808,10 @@ function bindingToApi(binding, bindingPath, _wasm) {
         function serializeConfigItem(rule, glob) {
             if (!rule) return rule;
             if (rule.loaders) {
-                for (const item of rule.loaders){
-                    checkLoaderItem(item, glob);
-                }
+                rule = {
+                    ...rule,
+                    loaders: rule.loaders.map((item)=>serializeLoaderItem(item, glob))
+                };
             }
             let serializedRule = rule;
             if (rule.condition != null) {
@@ -843,19 +822,27 @@ function bindingToApi(binding, bindingPath, _wasm) {
             }
             return serializedRule;
         }
-        function checkLoaderItem(loaderItem, glob) {
-            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,
-                    configurable: true
-                });
+        function serializeLoaderItem(loaderItem, glob) {
+            if (typeof loaderItem === 'string') {
+                return serializeLoader(loaderItem);
+            } else {
+                if (!require('util').isDeepStrictEqual(loaderItem, JSON.parse(JSON.stringify(loaderItem)))) {
+                    throw new Error(`loader ${loaderItem.loader} for match "${glob}" does not have serializable options. ` + 'Ensure that options passed are plain JavaScript objects and values.');
+                }
+                return {
+                    ...loaderItem,
+                    loader: serializeLoader(loaderItem.loader)
+                };
             }
         }
+        // Webpack loader specifiers can be absolute paths, we need it to be relative for turbopack.
+        function serializeLoader(loader) {
+            return _path.default.isAbsolute(loader) ? normalizePathOnWindows('./' + _path.default.relative(projectPath, loader)) : loader;
+        }
     }
     function napiEntrypointsToRawEntrypoints(entrypoints) {
         const routes = new Map();
-        for (const { pathname, ...nativeRoute } of entrypoints.routes){
+        for (const { pathname, ...nativeRoute } of entrypoints.value.routes){
             let route;
             const routeType = nativeRoute.type;
             switch(routeType){
@@ -886,6 +873,7 @@ function bindingToApi(binding, bindingPath, _wasm) {
                     route = {
                         type: 'app-route',
                         originalName: nativeRoute.originalName,
+                        hasActionManifest: nativeRoute.hasActionManifest,
                         endpoint: new EndpointImpl(nativeRoute.endpoint)
                     };
                     break;
@@ -906,27 +894,33 @@ function bindingToApi(binding, bindingPath, _wasm) {
                 endpoint: new EndpointImpl(middleware.endpoint),
                 isProxy: middleware.isProxy
             });
-        const middleware = entrypoints.middleware ? napiMiddlewareToMiddleware(entrypoints.middleware) : undefined;
+        const middleware = entrypoints.value.middleware ? napiMiddlewareToMiddleware(entrypoints.value.middleware) : undefined;
         const napiInstrumentationToInstrumentation = (instrumentation)=>({
                 nodeJs: new EndpointImpl(instrumentation.nodeJs),
                 edge: new EndpointImpl(instrumentation.edge)
             });
-        const instrumentation = entrypoints.instrumentation ? napiInstrumentationToInstrumentation(entrypoints.instrumentation) : undefined;
+        const instrumentation = entrypoints.value.instrumentation ? napiInstrumentationToInstrumentation(entrypoints.value.instrumentation) : undefined;
         return {
-            routes,
-            middleware,
-            instrumentation,
-            pagesDocumentEndpoint: new EndpointImpl(entrypoints.pagesDocumentEndpoint),
-            pagesAppEndpoint: new EndpointImpl(entrypoints.pagesAppEndpoint),
-            pagesErrorEndpoint: new EndpointImpl(entrypoints.pagesErrorEndpoint),
+            value: {
+                routes,
+                middleware,
+                instrumentation,
+                pagesDocumentEndpoint: new EndpointImpl(entrypoints.value.pagesDocumentEndpoint),
+                pagesAppEndpoint: new EndpointImpl(entrypoints.value.pagesAppEndpoint),
+                pagesErrorEndpoint: new EndpointImpl(entrypoints.value.pagesErrorEndpoint)
+            },
             issues: entrypoints.issues
         };
     }
     return async function createProject(options, turboEngineOptions, callbacks) {
-        return new ProjectImpl(await binding.projectNew(await rustifyProjectOptions(options), turboEngineOptions, {
+        const { value, issues } = await binding.projectNew(await rustifyProjectOptions(options), turboEngineOptions, {
             throwTurbopackInternalError: require('../../shared/lib/turbopack/internal-error').throwTurbopackInternalError,
             onBeforeDeferredEntries: callbacks == null ? void 0 : callbacks.onBeforeDeferredEntries
-        }));
+        });
+        return {
+            value: new ProjectImpl(value.project, _path.default.join(options.rootPath, options.projectPath)),
+            issues
+        };
     };
 }
 // helper for loadWasm
@@ -1004,25 +998,13 @@ async function loadWasm(importPath = '') {
         css: {
             lightning: {
                 transform: function(_options) {
-                    throw Object.defineProperty(new Error('`css.lightning.transform` is not supported by the wasm bindings.'), "__NEXT_ERROR_CODE", {
-                        value: "E330",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error('`css.lightning.transform` is not supported by the wasm bindings.');
                 },
                 transformStyleAttr: function(_options) {
-                    throw Object.defineProperty(new Error('`css.lightning.transformStyleAttr` is not supported by the wasm bindings.'), "__NEXT_ERROR_CODE", {
-                        value: "E324",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error('`css.lightning.transformStyleAttr` is not supported by the wasm bindings.');
                 },
                 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
-                    });
+                    throw new Error('`css.lightning.featureNamesToMask` is not supported by the wasm bindings.');
                 }
             }
         },
@@ -1050,32 +1032,16 @@ async function loadWasm(importPath = '') {
         },
         turbo: {
             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
-                });
+                throw 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.`);
             },
             startTurbopackTraceServerHandle (_traceFilePath, _port) {
-                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
-                });
+                throw 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.`);
             },
             queryTraceSpans (_handle, _options) {
-                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
-                });
+                throw 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.`);
             },
             databaseCompact (_path, _nextVersion) {
-                throw Object.defineProperty(new Error('Turbopack database compaction is not supported on this platform'), "__NEXT_ERROR_CODE", {
-                    value: "E1147",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error('Turbopack database compaction is not supported on this platform');
             }
         },
         mdx: {
@@ -1093,18 +1059,10 @@ async function loadWasm(importPath = '') {
         },
         rspack: {
             getModuleNamedExports (_resourcePath) {
-                throw Object.defineProperty(new Error('`rspack.getModuleNamedExports` is not supported by the wasm bindings.'), "__NEXT_ERROR_CODE", {
-                    value: "E709",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error('`rspack.getModuleNamedExports` is not supported by the wasm bindings.');
             },
             warnForEdgeRuntime (_source, _isProduction) {
-                throw Object.defineProperty(new Error('`rspack.warnForEdgeRuntime` is not supported by the wasm bindings.'), "__NEXT_ERROR_CODE", {
-                    value: "E712",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error('`rspack.warnForEdgeRuntime` is not supported by the wasm bindings.');
             }
         },
         expandNextJsTemplate (content, templatePath, nextPackageDirPath, replacements, injections, imports) {
@@ -1114,32 +1072,16 @@ async function loadWasm(importPath = '') {
             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
-            });
+            throw new Error('`lockfileTryAcquire` is not supported by the wasm bindings.');
         },
         lockfileTryAcquireSync (_filePath, _content) {
-            throw Object.defineProperty(new Error('`lockfileTryAcquireSync` is not supported by the wasm bindings.'), "__NEXT_ERROR_CODE", {
-                value: "E856",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('`lockfileTryAcquireSync` is not supported by the wasm bindings.');
         },
         lockfileUnlock (_lockfile) {
-            throw Object.defineProperty(new Error('`lockfileUnlock` is not supported by the wasm bindings.'), "__NEXT_ERROR_CODE", {
-                value: "E857",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('`lockfileUnlock` is not supported by the wasm bindings.');
         },
         lockfileUnlockSync (_lockfile) {
-            throw Object.defineProperty(new Error('`lockfileUnlockSync` is not supported by the wasm bindings.'), "__NEXT_ERROR_CODE", {
-                value: "E858",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('`lockfileUnlockSync` is not supported by the wasm bindings.');
         }
     };
     return wasmBindings;
@@ -1152,11 +1094,7 @@ async function loadWasm(importPath = '') {
         return loadedBindings;
     }
     if (process.env.NEXT_TEST_WASM) {
-        throw Object.defineProperty(new Error('cannot run loadNative when `NEXT_TEST_WASM` is set'), "__NEXT_ERROR_CODE", {
-            value: "E714",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('cannot run loadNative when `NEXT_TEST_WASM` is set');
     }
     const customBindingsPath = !!__INTERNAL_CUSTOM_TURBOPACK_BINDINGS ? require.resolve(__INTERNAL_CUSTOM_TURBOPACK_BINDINGS) : null;
     const customBindings = customBindingsPath != null ? require(customBindingsPath) : null;
@@ -1225,17 +1163,9 @@ async function loadWasm(importPath = '') {
             transformSync (src, options) {
                 var _options_jsc;
                 if (typeof src === 'undefined') {
-                    throw Object.defineProperty(new Error("transformSync doesn't implement reading the file from filesystem"), "__NEXT_ERROR_CODE", {
-                        value: "E292",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error("transformSync doesn't implement reading the file from filesystem");
                 } else if (Buffer.isBuffer(src)) {
-                    throw Object.defineProperty(new Error("transformSync doesn't implement taking the source code as Buffer"), "__NEXT_ERROR_CODE", {
-                        value: "E387",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error("transformSync doesn't implement taking the source code as Buffer");
                 }
                 const isModule = typeof src !== 'string';
                 options = options || {};