@codelionapps/unharness 0.0.0-stage → 0.1.0

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/utils.js

@@ -0,0 +1,343 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    RESTART_EXIT_CODE: null,
+    blockOnOutputWrites: null,
+    formatDebugAddress: null,
+    formatNodeOptions: null,
+    getFormattedNodeOptionsWithoutInspect: null,
+    getMaxOldSpaceSize: null,
+    getMemoryRestartStats: null,
+    getNodeDebugType: null,
+    getNodeOptionsArgs: null,
+    getParsedDebugAddress: null,
+    getParsedNodeOptions: null,
+    getParsedNodeOptionsWithoutInspect: null,
+    parseValidPositiveInteger: null,
+    printAndExit: null,
+    tokenizeArgs: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    RESTART_EXIT_CODE: function() {
+        return RESTART_EXIT_CODE;
+    },
+    blockOnOutputWrites: function() {
+        return blockOnOutputWrites;
+    },
+    formatDebugAddress: function() {
+        return formatDebugAddress;
+    },
+    formatNodeOptions: function() {
+        return formatNodeOptions;
+    },
+    getFormattedNodeOptionsWithoutInspect: function() {
+        return getFormattedNodeOptionsWithoutInspect;
+    },
+    getMaxOldSpaceSize: function() {
+        return getMaxOldSpaceSize;
+    },
+    getMemoryRestartStats: function() {
+        return getMemoryRestartStats;
+    },
+    getNodeDebugType: function() {
+        return getNodeDebugType;
+    },
+    getNodeOptionsArgs: function() {
+        return getNodeOptionsArgs;
+    },
+    getParsedDebugAddress: function() {
+        return getParsedDebugAddress;
+    },
+    getParsedNodeOptions: function() {
+        return getParsedNodeOptions;
+    },
+    getParsedNodeOptionsWithoutInspect: function() {
+        return getParsedNodeOptionsWithoutInspect;
+    },
+    parseValidPositiveInteger: function() {
+        return parseValidPositiveInteger;
+    },
+    printAndExit: function() {
+        return printAndExit;
+    },
+    tokenizeArgs: function() {
+        return tokenizeArgs;
+    }
+});
+const _nodeutil = require("node:util");
+const _commander = require("next/dist/compiled/commander");
+function printAndExit(message, code = 1) {
+    if (code === 0) {
+        console.log(message);
+    } else {
+        console.error(message);
+    }
+    return process.exit(code);
+}
+/**
+ * Node.js CLI flags that can be repeated. Node runs every occurrence of these
+ * flags, so they need to be preserved individually rather than collapsed into
+ * a single value keyed by option name.
+ * https://nodejs.org/api/cli.html#--requiremodule
+ * https://nodejs.org/api/cli.html#--importmodule
+ */ const REPEATABLE_OPTIONS = {
+    require: {
+        type: 'string',
+        multiple: true
+    },
+    import: {
+        type: 'string',
+        multiple: true
+    }
+};
+const parseNodeArgs = (args)=>{
+    const parsed = (0, _nodeutil.parseArgs)({
+        args,
+        strict: false,
+        tokens: true,
+        options: REPEATABLE_OPTIONS
+    });
+    const values = parsed.values;
+    const tokens = parsed.tokens;
+    // For the `NODE_OPTIONS`, we support arguments with values without the `=`
+    // sign. We need to parse them manually.
+    let orphan = null;
+    for(let i = 0; i < tokens.length; i++){
+        const token = tokens[i];
+        if (token.kind === 'option-terminator') {
+            break;
+        }
+        // When we encounter an option, if it's value is undefined, we should check
+        // to see if the following tokens are positional parameters. If they are,
+        // then the option is orphaned, and we can assign it.
+        if (token.kind === 'option') {
+            orphan = typeof token.value === 'undefined' ? token : null;
+            continue;
+        }
+        // If the token isn't a positional one, then we can't assign it to the found
+        // orphaned option.
+        if (token.kind !== 'positional') {
+            orphan = null;
+            continue;
+        }
+        // If we don't have an orphan, then we can skip this token.
+        if (!orphan) {
+            continue;
+        }
+        const name = orphan.name;
+        // If the option is repeatable, accumulate each occurrence instead of
+        // collapsing them into a single value.
+        if (name in REPEATABLE_OPTIONS) {
+            if (Array.isArray(values[name])) {
+                values[name].push(token.value);
+            } else if (typeof values[name] === 'string') {
+                values[name] = [
+                    values[name],
+                    token.value
+                ];
+            } else {
+                values[name] = token.value;
+            }
+            continue;
+        }
+        // If the token is a positional one, and it has a value, so add it to the
+        // values object. If it already exists, append it with a space.
+        if (name in values && typeof values[name] === 'string') {
+            values[name] += ` ${token.value}`;
+        } else {
+            values[name] = token.value;
+        }
+    }
+    return values;
+};
+const tokenizeArgs = (input)=>{
+    let args = [];
+    let isInString = false;
+    let willStartNewArg = true;
+    for(let i = 0; i < input.length; i++){
+        let char = input[i];
+        // Skip any escaped characters in strings.
+        if (char === '\\' && isInString) {
+            // Ensure we don't have an escape character at the end.
+            if (input.length === i + 1) {
+                throw new Error('Invalid escape character at the end.');
+            }
+            // Skip the next character.
+            char = input[++i];
+        } else if (char === ' ' && !isInString) {
+            willStartNewArg = true;
+            continue;
+        } else if (char === '"') {
+            isInString = !isInString;
+            continue;
+        }
+        // If we're starting a new argument, we should add it to the array.
+        if (willStartNewArg) {
+            args.push(char);
+            willStartNewArg = false;
+        } else {
+            args[args.length - 1] += char;
+        }
+    }
+    if (isInString) {
+        throw new Error('Unterminated string');
+    }
+    return args;
+};
+const getNodeOptionsArgs = ()=>{
+    if (!process.env.NODE_OPTIONS) return [];
+    return tokenizeArgs(process.env.NODE_OPTIONS);
+};
+const formatDebugAddress = ({ host, port })=>{
+    if (host) return `${host}:${port}`;
+    return `${port}`;
+};
+const getParsedDebugAddress = (address)=>{
+    if (!address || typeof address !== 'string') {
+        return {
+            host: undefined,
+            port: 9229
+        };
+    }
+    // The address is in the form of `[host:]port`. Let's parse the address.
+    if (address.includes(':')) {
+        const [host, port] = address.split(':');
+        return {
+            host,
+            port: parseInt(port, 10)
+        };
+    }
+    return {
+        host: undefined,
+        port: parseInt(address, 10)
+    };
+};
+/**
+ * Node.js CLI flags that are not allowed in NODE_OPTIONS and must be
+ * passed as direct CLI arguments via execArgv.
+ * This set is the difference between all Node.js CLI flags and the ones **not**
+ * allowed in NODE_OPTIONS, as listed in the Node.js documentation:
+ * https://nodejs.org/api/cli.html#node_optionsoptions
+ *
+ * It is not exhaustive since not all options make sense for Next.js (e.g. --test)
+ */ const EXEC_ARGV_ONLY_OPTIONS = new Set([
+    'experimental-network-inspection',
+    'experimental-storage-inspection',
+    'experimental-worker-inspection',
+    'experimental-inspector-network-resource'
+]);
+function formatArg(key, value) {
+    if (value === true) {
+        return `--${key}`;
+    }
+    if (Array.isArray(value)) {
+        const formatted = [];
+        for (const item of value){
+            const formattedItem = formatArg(key, item);
+            if (formattedItem !== null) {
+                formatted.push(formattedItem);
+            }
+        }
+        return formatted.length > 0 ? formatted.join(' ') : null;
+    }
+    if (value) {
+        return `--${key}=${// Values with spaces need to be quoted. We use JSON.stringify to
+        // also escape any nested quotes.
+        value.includes(' ') && !value.startsWith('"') ? JSON.stringify(value) : value}`;
+    }
+    return null;
+}
+function formatNodeOptions(args) {
+    const nodeOptionsParts = [];
+    const execArgv = [];
+    for (const [key, value] of Object.entries(args)){
+        const formatted = formatArg(key, value);
+        if (formatted === null) continue;
+        if (EXEC_ARGV_ONLY_OPTIONS.has(key)) {
+            execArgv.push(formatted);
+        } else {
+            nodeOptionsParts.push(formatted);
+        }
+    }
+    return {
+        nodeOptions: nodeOptionsParts.join(' '),
+        execArgv
+    };
+}
+function getParsedNodeOptions() {
+    const args = [
+        ...process.execArgv,
+        ...getNodeOptionsArgs()
+    ];
+    if (args.length === 0) return {};
+    return parseNodeArgs(args);
+}
+function getParsedNodeOptionsWithoutInspect() {
+    const args = getNodeOptionsArgs();
+    if (args.length === 0) return {};
+    const parsed = parseNodeArgs(args);
+    // Remove inspect options.
+    delete parsed.inspect;
+    delete parsed['inspect-brk'];
+    delete parsed['inspect_brk'];
+    return parsed;
+}
+function getFormattedNodeOptionsWithoutInspect() {
+    const args = getParsedNodeOptionsWithoutInspect();
+    if (Object.keys(args).length === 0) return '';
+    return formatNodeOptions(args).nodeOptions;
+}
+function parseValidPositiveInteger(value) {
+    const parsedValue = parseInt(value, 10);
+    if (isNaN(parsedValue) || !isFinite(parsedValue) || parsedValue < 0) {
+        throw new _commander.InvalidArgumentError(`'${value}' is not a non-negative number.`);
+    }
+    return parsedValue;
+}
+const RESTART_EXIT_CODE = 77;
+function getMemoryRestartStats(isDev, devMemoryThresholdRestart, getHeapStatistics) {
+    if (!isDev || !devMemoryThresholdRestart) {
+        return undefined;
+    }
+    const heapStatistics = getHeapStatistics();
+    if (heapStatistics.used_heap_size > 0.8 * heapStatistics.heap_size_limit) {
+        return heapStatistics;
+    }
+    return undefined;
+}
+function getNodeDebugType(nodeOptions) {
+    if (nodeOptions.inspect) {
+        return 'inspect';
+    }
+    if (nodeOptions['inspect-brk'] || nodeOptions['inspect_brk']) {
+        return 'inspect-brk';
+    }
+}
+function getMaxOldSpaceSize() {
+    const args = getNodeOptionsArgs();
+    if (args.length === 0) return;
+    const parsed = parseNodeArgs(args);
+    const size = parsed['max-old-space-size'] || parsed['max_old_space_size'];
+    if (!size || typeof size !== 'string') return;
+    return parseInt(size, 10);
+}
+function blockOnOutputWrites() {
+    for (const stream of [
+        process.stdout,
+        process.stderr
+    ]){
+        var _stream__handle_setBlocking, _stream__handle;
+        ;
+        (_stream__handle = stream._handle) == null ? void 0 : (_stream__handle_setBlocking = _stream__handle.setBlocking) == null ? void 0 : _stream__handle_setBlocking.call(_stream__handle, true);
+    }
+}
+
+//# sourceMappingURL=utils.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/lib/worker-utils.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getFreePort", {
+    enumerable: true,
+    get: function() {
+        return getFreePort;
+    }
+});
+const _http = /*#__PURE__*/ _interop_require_default(require("http"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const getFreePort = async ()=>{
+    return new Promise((resolve, reject)=>{
+        const server = _http.default.createServer(()=>{});
+        server.listen(0, ()=>{
+            const address = server.address();
+            server.close();
+            if (address && typeof address === 'object') {
+                resolve(address.port);
+            } else {
+                reject(new Error('invalid address from server: ' + (address == null ? void 0 : address.toString())));
+            }
+        });
+    });
+};
+
+//# sourceMappingURL=worker-utils.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/load-components.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    evalManifestWithRetries: null,
+    loadClientReferenceManifestForPage: null,
+    loadComponents: null,
+    loadManifestWithRetries: null,
+    tryLoadManifestWithRetries: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    evalManifestWithRetries: function() {
+        return evalManifestWithRetries;
+    },
+    loadClientReferenceManifestForPage: function() {
+        return loadClientReferenceManifestForPage;
+    },
+    loadComponents: function() {
+        return loadComponents;
+    },
+    loadManifestWithRetries: function() {
+        return loadManifestWithRetries;
+    },
+    tryLoadManifestWithRetries: function() {
+        return tryLoadManifestWithRetries;
+    }
+});
+const _constants = require("../shared/lib/constants");
+const _path = require("path");
+const _require = require("./require");
+const _interopdefault = require("../lib/interop-default");
+const _tracer = require("./lib/trace/tracer");
+const _constants1 = require("./lib/trace/constants");
+const _loadmanifestexternal = require("./load-manifest.external");
+const _wait = require("../lib/wait");
+const _manifestssingleton = require("./app-render/manifests-singleton");
+const _normalizepagepath = require("../shared/lib/page-path/normalize-page-path");
+const _ismetadataroute = require("../lib/metadata/is-metadata-route");
+async function loadManifestWithRetries(manifestPath, attempts = 3) {
+    while(true){
+        try {
+            return (0, _loadmanifestexternal.loadManifest)(manifestPath);
+        } catch (err) {
+            attempts--;
+            if (attempts <= 0) throw err;
+            await (0, _wait.wait)(100);
+        }
+    }
+}
+async function tryLoadManifestWithRetries(manifestPath, attempts = 3) {
+    try {
+        return await loadManifestWithRetries(manifestPath, attempts);
+    } catch (err) {
+        return undefined;
+    }
+}
+async function evalManifestWithRetries(manifestPath, attempts = 3) {
+    while(true){
+        try {
+            return (0, _loadmanifestexternal.evalManifest)(manifestPath);
+        } catch (err) {
+            attempts--;
+            if (attempts <= 0) throw err;
+            await (0, _wait.wait)(100);
+        }
+    }
+}
+async function loadClientReferenceManifestForPage(distDir, page, attempts) {
+    const entryName = page.replace(/%5F/g, '_');
+    const manifestPath = (0, _path.join)(/* turbopackIgnore: true */ distDir, 'server', 'app', entryName + '_' + _constants.CLIENT_REFERENCE_MANIFEST + '.js');
+    try {
+        const context = await evalManifestWithRetries(manifestPath, attempts);
+        return context.__RSC_MANIFEST[entryName];
+    } catch (err) {
+        return undefined;
+    }
+}
+function loadRouteModule(page, distDir, isAppPath) {
+    return (0, _tracer.getTracer)().trace(_constants1.LoadComponentsSpan.loadRouteModule, {
+        spanName: 'load route module'
+    }, ()=>(0, _require.requirePage)(page, distDir, isAppPath));
+}
+async function loadComponentsImpl({ distDir, page, isAppPath, isDev, sriEnabled, // When route modules are used, which is the case for the server calls to loadComponents, it no longer needs manifest to be loaded here.
+// Static generation still needs the manifests to be loaded here.
+// In the future static generation will also use route modules, and we will remove this flag.
+needsManifestsForLegacyReasons }) {
+    let DocumentMod = {};
+    let AppMod = {};
+    if (!isAppPath) {
+        ;
+        [DocumentMod, AppMod] = await Promise.all([
+            (0, _require.requirePage)('/_document', distDir, false),
+            (0, _require.requirePage)('/_app', distDir, false)
+        ]);
+    }
+    if (needsManifestsForLegacyReasons) {
+        // In dev mode we retry loading a manifest file to handle a race condition
+        // that can occur while app and pages are compiling at the same time, and the
+        // build-manifest is still being written to disk while an app path is
+        // attempting to load.
+        const manifestLoadAttempts = isDev ? 3 : 1;
+        let reactLoadableManifestPath;
+        if (!process.env.TURBOPACK) {
+            reactLoadableManifestPath = (0, _path.join)(/* turbopackIgnore: true */ distDir, _constants.REACT_LOADABLE_MANIFEST);
+        } else if (isAppPath) {
+            reactLoadableManifestPath = (0, _path.join)(/* turbopackIgnore: true */ distDir, 'server', 'app', page, _constants.REACT_LOADABLE_MANIFEST);
+        } else {
+            reactLoadableManifestPath = (0, _path.join)(/* turbopackIgnore: true */ distDir, 'server', 'pages', (0, _normalizepagepath.normalizePagePath)(page), _constants.REACT_LOADABLE_MANIFEST);
+        }
+        // Make sure to avoid loading the manifest for static metadata routes for better performance.
+        const hasClientManifest = !(0, _ismetadataroute.isStaticMetadataRoute)(page);
+        // Load the manifest files first
+        //
+        // Loading page-specific manifests shouldn't throw an error if the manifest couldn't be found, so
+        // that the `requirePage` call below will throw the correct error in that case
+        // (a `PageNotFoundError`).
+        const [buildManifest, reactLoadableManifest, dynamicCssManifest, clientReferenceManifest, serverActionsManifest, subresourceIntegrityManifest] = await Promise.all([
+            loadManifestWithRetries((0, _path.join)(/* turbopackIgnore: true */ distDir, _constants.BUILD_MANIFEST), manifestLoadAttempts),
+            tryLoadManifestWithRetries(reactLoadableManifestPath, manifestLoadAttempts),
+            // This manifest will only exist in Pages dir && Production && Webpack.
+            isAppPath || process.env.TURBOPACK ? undefined : loadManifestWithRetries((0, _path.join)(/* turbopackIgnore: true */ distDir, `${_constants.DYNAMIC_CSS_MANIFEST}.json`), manifestLoadAttempts).catch(()=>undefined),
+            isAppPath && hasClientManifest ? loadClientReferenceManifestForPage(distDir, page, manifestLoadAttempts) : undefined,
+            isAppPath ? loadManifestWithRetries((0, _path.join)(/* turbopackIgnore: true */ distDir, 'server', _constants.SERVER_REFERENCE_MANIFEST + '.json'), manifestLoadAttempts).catch(()=>null) : null,
+            sriEnabled ? loadManifestWithRetries((0, _path.join)(/* turbopackIgnore: true */ distDir, 'server', _constants.SUBRESOURCE_INTEGRITY_MANIFEST + '.json')).catch(()=>undefined) : undefined
+        ]);
+        // Before requiring the actual page module, we have to set the reference
+        // manifests to our global store so Server Action's encryption util can access
+        // to them at the top level of the page module.
+        if (serverActionsManifest && clientReferenceManifest) {
+            (0, _manifestssingleton.setManifestsSingleton)({
+                page,
+                clientReferenceManifest,
+                serverActionsManifest
+            });
+        }
+        const ComponentMod = await loadRouteModule(page, distDir, isAppPath);
+        const Component = (0, _interopdefault.interopDefault)(ComponentMod);
+        const Document = (0, _interopdefault.interopDefault)(DocumentMod);
+        const App = (0, _interopdefault.interopDefault)(AppMod);
+        const { getServerSideProps, getStaticProps, getStaticPaths, routeModule } = ComponentMod;
+        return {
+            // @ts-expect-error this is indeed `{} || AppType` and not always `AppType`
+            App,
+            // @ts-expect-error this is indeed `{} || DocumentType` and not always `DocumentType`
+            Document,
+            Component,
+            buildManifest,
+            subresourceIntegrityManifest,
+            reactLoadableManifest: reactLoadableManifest || {},
+            dynamicCssManifest,
+            pageConfig: ComponentMod.config || {},
+            ComponentMod,
+            getServerSideProps,
+            getStaticProps,
+            getStaticPaths,
+            isAppPath,
+            page,
+            routeModule
+        };
+    } else {
+        const ComponentMod = await loadRouteModule(page, distDir, isAppPath);
+        const Component = (0, _interopdefault.interopDefault)(ComponentMod);
+        const Document = (0, _interopdefault.interopDefault)(DocumentMod);
+        const App = (0, _interopdefault.interopDefault)(AppMod);
+        const { getServerSideProps, getStaticProps, getStaticPaths, routeModule } = ComponentMod;
+        return {
+            App,
+            Document,
+            Component,
+            pageConfig: ComponentMod.config || {},
+            ComponentMod,
+            getServerSideProps,
+            getStaticProps,
+            getStaticPaths,
+            isAppPath,
+            page,
+            routeModule
+        }; // temporary `as any` to make TypeScript not fail so that the tests will run on the PR.
+    }
+}
+const loadComponents = (0, _tracer.getTracer)().wrap(_constants1.LoadComponentsSpan.loadComponents, loadComponentsImpl);
+
+//# sourceMappingURL=load-components.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/load-default-error-components.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "loadDefaultErrorComponents", {
+    enumerable: true,
+    get: function() {
+        return loadDefaultErrorComponents;
+    }
+});
+const _constants = require("../shared/lib/constants");
+const _path = require("path");
+const _interopdefault = require("../lib/interop-default");
+const _tracer = require("./lib/trace/tracer");
+const _constants1 = require("./lib/trace/constants");
+const _loadcomponents = require("./load-components");
+async function loadDefaultErrorComponentsImpl(distDir) {
+    // eslint-disable-next-line @next/internal/typechecked-require -- Why not relative imports?
+    const Document = (0, _interopdefault.interopDefault)(require('next/dist/pages/_document'));
+    // eslint-disable-next-line @next/internal/typechecked-require -- Why not relative imports?
+    const AppMod = require('next/dist/pages/_app');
+    const App = (0, _interopdefault.interopDefault)(AppMod);
+    // Load the compiled route module for this builtin error.
+    // TODO: (wyattjoh) replace this with just exporting the route module when the transition is complete
+    const ComponentMod = require('./route-modules/pages/builtin/_error');
+    const Component = ComponentMod.routeModule.userland.default;
+    return {
+        App,
+        Document,
+        Component,
+        pageConfig: {},
+        buildManifest: await (0, _loadcomponents.loadManifestWithRetries)((0, _path.join)(distDir, `fallback-${_constants.BUILD_MANIFEST}`)),
+        reactLoadableManifest: {},
+        ComponentMod,
+        page: '/_error',
+        routeModule: ComponentMod.routeModule
+    };
+}
+const loadDefaultErrorComponents = (0, _tracer.getTracer)().wrap(_constants1.LoadComponentsSpan.loadDefaultErrorComponents, loadDefaultErrorComponentsImpl);
+
+//# sourceMappingURL=load-default-error-components.js.map