@codelionapps/unharness 0.0.0-stage → 0.1.0

package/dashboard/.next/standalone/node_modules/next/dist/server/app-render/get-preloadable-fonts.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getPreloadableFonts", {
+    enumerable: true,
+    get: function() {
+        return getPreloadableFonts;
+    }
+});
+function getPreloadableFonts(nextFontManifest, filePath, injectedFontPreloadTags) {
+    if (!nextFontManifest || !filePath) {
+        return null;
+    }
+    const filepathWithoutExtension = filePath.replace(/\.[^.]+$/, '');
+    const fontFiles = new Set();
+    let foundFontUsage = false;
+    const preloadedFontFiles = nextFontManifest.app[filepathWithoutExtension];
+    if (preloadedFontFiles) {
+        foundFontUsage = true;
+        for (const fontFile of preloadedFontFiles){
+            if (!injectedFontPreloadTags.has(fontFile)) {
+                fontFiles.add(fontFile);
+                injectedFontPreloadTags.add(fontFile);
+            }
+        }
+    }
+    if (fontFiles.size) {
+        return [
+            ...fontFiles
+        ].sort();
+    } else if (foundFontUsage && injectedFontPreloadTags.size === 0) {
+        return [];
+    } else {
+        return null;
+    }
+}
+
+//# sourceMappingURL=get-preloadable-fonts.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/app-render/get-script-nonce-from-header.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getScriptNonceFromHeader", {
+    enumerable: true,
+    get: function() {
+        return getScriptNonceFromHeader;
+    }
+});
+const CSP_NONCE_SOURCE_REGEX = /^'nonce-([A-Za-z0-9+/_-]+={0,2})'$/;
+function getScriptNonceFromHeader(cspHeaderValue) {
+    const directives = cspHeaderValue// Directives are split by ';'.
+    .split(';').map((directive)=>directive.trim());
+    // First try to find the directive for the 'script-src', otherwise try to
+    // fallback to the 'default-src'.
+    const directive = directives.find((dir)=>dir.startsWith('script-src')) || directives.find((dir)=>dir.startsWith('default-src'));
+    // If no directive could be found, then we're done.
+    if (!directive) {
+        return;
+    }
+    // Extract the first valid nonce from the directive. Malformed nonces are
+    // ignored so the request can continue without a nonce instead of failing.
+    for (const source of directive.split(/\s+/).slice(1)){
+        const match = source.trim().match(CSP_NONCE_SOURCE_REGEX);
+        if (match) {
+            return match[1];
+        }
+    }
+}
+
+//# sourceMappingURL=get-script-nonce-from-header.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/app-render/get-short-dynamic-param-type.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "dynamicParamTypes", {
+    enumerable: true,
+    get: function() {
+        return dynamicParamTypes;
+    }
+});
+const dynamicParamTypes = {
+    catchall: 'c',
+    'catchall-intercepted-(..)(..)': 'ci(..)(..)',
+    'catchall-intercepted-(.)': 'ci(.)',
+    'catchall-intercepted-(..)': 'ci(..)',
+    'catchall-intercepted-(...)': 'ci(...)',
+    'optional-catchall': 'oc',
+    dynamic: 'd',
+    'dynamic-intercepted-(..)(..)': 'di(..)(..)',
+    'dynamic-intercepted-(.)': 'di(.)',
+    'dynamic-intercepted-(..)': 'di(..)',
+    'dynamic-intercepted-(...)': 'di(...)'
+};
+
+//# sourceMappingURL=get-short-dynamic-param-type.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/app-render/has-loading-component-in-tree.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "hasLoadingComponentInTree", {
+    enumerable: true,
+    get: function() {
+        return hasLoadingComponentInTree;
+    }
+});
+function hasLoadingComponentInTree(tree) {
+    const [, parallelRoutes, { loading }] = tree;
+    if (loading) {
+        return true;
+    }
+    return Object.values(parallelRoutes).some((parallelRoute)=>hasLoadingComponentInTree(parallelRoute));
+}
+
+//# sourceMappingURL=has-loading-component-in-tree.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/app-render/instant-test-bootstrap.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getInstantTestBootstrapScriptContent", {
+    enumerable: true,
+    get: function() {
+        return getInstantTestBootstrapScriptContent;
+    }
+});
+const _approuterheaders = require("../../client/components/app-router-headers");
+const _cachebustingsearchparam = require("../../shared/lib/router/utils/cache-busting-search-param");
+async function getInstantTestBootstrapScriptContent() {
+    const segmentPath = '/_full';
+    const cacheBustingHeader = await (0, _cachebustingsearchparam.computeCacheBustingSearchParam)('1', segmentPath, undefined, undefined);
+    const searchStr = `${_approuterheaders.NEXT_RSC_UNION_QUERY}=${cacheBustingHeader}`;
+    return `if(document.cookie.indexOf('${_approuterheaders.NEXT_INSTANT_TEST_COOKIE}=')>-1){self.__next_instant_test=fetch(location.pathname+'?${searchStr}',{credentials:'same-origin',headers:{'${_approuterheaders.RSC_HEADER}':'1','${_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER}':'1','${_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER}':'${segmentPath}'}})}`;
+}
+
+//# sourceMappingURL=instant-test-bootstrap.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/app-render/instant-validation/boundary-constants.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    INSTANT_SLOT_MARKER_PREFIX: null,
+    INSTANT_SLOT_MARKER_SUFFIX: null,
+    INSTANT_VALIDATION_BOUNDARY_NAME: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    INSTANT_SLOT_MARKER_PREFIX: function() {
+        return INSTANT_SLOT_MARKER_PREFIX;
+    },
+    INSTANT_SLOT_MARKER_SUFFIX: function() {
+        return INSTANT_SLOT_MARKER_SUFFIX;
+    },
+    INSTANT_VALIDATION_BOUNDARY_NAME: function() {
+        return INSTANT_VALIDATION_BOUNDARY_NAME;
+    }
+});
+const INSTANT_VALIDATION_BOUNDARY_NAME = '__next_instant_validation_boundary__';
+const INSTANT_SLOT_MARKER_PREFIX = '__next_instant_slot_';
+const INSTANT_SLOT_MARKER_SUFFIX = '__';
+
+//# sourceMappingURL=boundary-constants.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/app-render/instant-validation/boundary-impl.js

@@ -0,0 +1,118 @@
+/* eslint-disable @next/internal/no-ambiguous-jsx -- React Client */ // Do not put a "use client" directive here. Import this module via the shim in
+// `packages/next/src/client/components/instant-validation/boundary.tsx` instead.
+// 'use client'
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    InstantValidationBoundaryContext: null,
+    PlaceValidationBoundaryBelowThisLevel: null,
+    RenderValidationBoundaryAtThisLevel: null,
+    SlotMarker: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    InstantValidationBoundaryContext: function() {
+        return InstantValidationBoundaryContext;
+    },
+    PlaceValidationBoundaryBelowThisLevel: function() {
+        return PlaceValidationBoundaryBelowThisLevel;
+    },
+    RenderValidationBoundaryAtThisLevel: function() {
+        return RenderValidationBoundaryAtThisLevel;
+    },
+    SlotMarker: function() {
+        return SlotMarker;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = require("react");
+const _boundaryconstants = require("./boundary-constants");
+const _invarianterror = require("../../../shared/lib/invariant-error");
+const _workunitasyncstorageexternal = require("../work-unit-async-storage.external");
+if (typeof window !== 'undefined') {
+    throw new _invarianterror.InvariantError('Instant validation boundaries should never appear in browser bundles.');
+}
+function getValidationBoundaryTracking() {
+    const store = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (!store) return null;
+    switch(store.type){
+        case 'validation-client':
+            return store.boundaryState;
+        case 'prerender':
+        case 'prerender-client':
+        case 'prerender-legacy':
+        case 'prerender-runtime':
+        case 'request':
+        case 'cache':
+        case 'private-cache':
+        case 'unstable-cache':
+        case 'build-time-generator':
+            break;
+        default:
+            store;
+    }
+    return null;
+}
+// We use a namespace object to allow us to recover the name of the function
+// at runtime even when production bundling/minification is used.
+const NameSpace = {
+    [_boundaryconstants.INSTANT_VALIDATION_BOUNDARY_NAME]: function({ id, children }) {
+        // Track which boundaries we actually managed to render.
+        const state = getValidationBoundaryTracking();
+        if (state === null) {
+            throw new _invarianterror.InvariantError('Missing boundary tracking state');
+        }
+        state.renderedIds.add(id);
+        return children;
+    }
+};
+const InstantValidationBoundaryContext = /*#__PURE__*/ (0, _react.createContext)(null);
+function PlaceValidationBoundaryBelowThisLevel({ id, children }) {
+    return(// OuterLayoutRouter will see this and render a `RenderValidationBoundaryAtThisLevel`.
+    /*#__PURE__*/ (0, _jsxruntime.jsx)(InstantValidationBoundaryContext, {
+        value: id,
+        children: children
+    }));
+}
+function RenderValidationBoundaryAtThisLevel({ id, children }) {
+    // We got a boundaryId from the context. Clear the context so that the children don't render another boundary.
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(InstantValidationBoundary, {
+        id: id,
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(InstantValidationBoundaryContext, {
+            value: null,
+            children: children
+        })
+    });
+}
+const InstantValidationBoundary = // We use slice(0) to trick the bundler into not inlining/minifying the function
+// so it retains the name inferred from the namespace object
+NameSpace[_boundaryconstants.INSTANT_VALIDATION_BOUNDARY_NAME.slice(0)];
+// Slot marker component for attributing validation errors to the
+// correct config when a boundary spans multiple parallel slots.
+// Renders a dynamically-named inner component so the slot index
+// appears in the SSR component stack (__next_instant_slot_N__).
+const slotMarkerCache = new Map();
+function SlotMarker({ name, children }) {
+    let Marker = slotMarkerCache.get(name);
+    if (!Marker) {
+        const ns = {
+            [name]: function({ children: c }) {
+                return c;
+            }
+        };
+        Marker = ns[name];
+        slotMarkerCache.set(name, Marker);
+    }
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(Marker, {
+        children: children
+    });
+}
+
+//# sourceMappingURL=boundary-impl.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/app-render/instant-validation/boundary-tracking.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    allRequiredBoundariesRendered: null,
+    createValidationBoundaryTracking: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    allRequiredBoundariesRendered: function() {
+        return allRequiredBoundariesRendered;
+    },
+    createValidationBoundaryTracking: function() {
+        return createValidationBoundaryTracking;
+    }
+});
+function createValidationBoundaryTracking(/** Pass if the render is expected to render the same IDs as a previous one. */ matchPrevious) {
+    return {
+        requiredIds: matchPrevious ? new Map(matchPrevious.requiredIds) : new Map(),
+        renderedIds: new Set()
+    };
+}
+function allRequiredBoundariesRendered(state) {
+    for (const id of state.requiredIds.keys()){
+        if (!state.renderedIds.has(id)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+//# sourceMappingURL=boundary-tracking.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/app-render/instant-validation/instant-config.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    anySegmentHasPartialPrefetchingEnabled: null,
+    anySegmentNeedsInstantValidationInBuild: null,
+    anySegmentNeedsInstantValidationInDev: null,
+    isFrameworkErrorRoute: null,
+    isImplicitValidationSegment: null,
+    isPageAllowedToBlock: null,
+    resolveInstantConfigSamplesForPage: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    anySegmentHasPartialPrefetchingEnabled: function() {
+        return anySegmentHasPartialPrefetchingEnabled;
+    },
+    anySegmentNeedsInstantValidationInBuild: function() {
+        return anySegmentNeedsInstantValidationInBuild;
+    },
+    anySegmentNeedsInstantValidationInDev: function() {
+        return anySegmentNeedsInstantValidationInDev;
+    },
+    isFrameworkErrorRoute: function() {
+        return isFrameworkErrorRoute;
+    },
+    isImplicitValidationSegment: function() {
+        return isImplicitValidationSegment;
+    },
+    isPageAllowedToBlock: function() {
+        return isPageAllowedToBlock;
+    },
+    resolveInstantConfigSamplesForPage: function() {
+        return resolveInstantConfigSamplesForPage;
+    }
+});
+const _appdirmodule = require("../../lib/app-dir-module");
+const _parseloadertree = require("../../../shared/lib/router/utils/parse-loader-tree");
+const _segment = require("../../../shared/lib/segment");
+const _entryconstants = require("../../../shared/lib/entry-constants");
+const _workasyncstorageexternal = require("../work-async-storage.external");
+const _invarianterror = require("../../../shared/lib/invariant-error");
+function isImplicitValidationSegment(segment) {
+    const key = typeof segment === 'string' ? segment : segment[0];
+    return key === _segment.PAGE_SEGMENT_KEY || key === _segment.DEFAULT_SEGMENT_KEY;
+}
+function isFrameworkErrorRoute(route) {
+    return route === _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE || route === _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE;
+}
+async function anySegmentHasPartialPrefetchingEnabled(tree) {
+    const { mod: layoutOrPageMod } = await (0, _appdirmodule.getLayoutOrPageModule)(tree);
+    // TODO(restart-on-cache-miss): Does this work correctly for client page/layout modules?
+    const prefetchConfig = layoutOrPageMod ? layoutOrPageMod.prefetch : undefined;
+    if (prefetchConfig === 'partial') {
+        return true;
+    }
+    const { parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+    for(const parallelRouteKey in parallelRoutes){
+        const parallelRoute = parallelRoutes[parallelRouteKey];
+        const hasChildPartialPrefetching = await anySegmentHasPartialPrefetchingEnabled(parallelRoute);
+        if (hasChildPartialPrefetching) {
+            return true;
+        }
+    }
+    return false;
+}
+async function isPageAllowedToBlock(tree) {
+    const { mod: layoutOrPageMod } = await (0, _appdirmodule.getLayoutOrPageModule)(tree);
+    // TODO(restart-on-cache-miss): Does this work correctly for client page/layout modules?
+    const instantConfig = layoutOrPageMod ? layoutOrPageMod.instant : undefined;
+    // If we encounter a non-false instant config before a instant=false,
+    // the page isn't allowed to block. The config expresses a requirement for
+    // instant UI, so we should make sure that a static shell exists.
+    // (even if it'd use runtime prefetching for client navs)
+    if (instantConfig !== undefined) {
+        if (instantConfig === false) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+    const { parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+    for(const parallelRouteKey in parallelRoutes){
+        const parallelRoute = parallelRoutes[parallelRouteKey];
+        const subtreeIsBlocking = await isPageAllowedToBlock(parallelRoute);
+        if (subtreeIsBlocking) {
+            return true;
+        }
+    }
+    return false;
+}
+var VALIDATION_LEVEL = /*#__PURE__*/ function(VALIDATION_LEVEL) {
+    VALIDATION_LEVEL[VALIDATION_LEVEL["WARNING"] = 0] = "WARNING";
+    VALIDATION_LEVEL[VALIDATION_LEVEL["ERROR"] = 1] = "ERROR";
+    return VALIDATION_LEVEL;
+}(VALIDATION_LEVEL || {});
+/**
+ * Walks the loader tree and checks if any segment has an `instant` config
+ * that needs validating for the given mode.
+ *
+ * - Explicit `instant` exports are checked against mode.
+ * - Page and default segments without an explicit config get implicit
+ *   validation when the default validation level applies to this mode.
+ * - `unstable_disableValidation` on any segment kills validation for
+ *   the whole tree.
+ */ async function anySegmentNeedsInstantValidation(rootTree, level) {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    if (!workStore) {
+        throw new _invarianterror.InvariantError('anySegmentNeedsInstantValidation must run inside a WorkStore');
+    }
+    const { validationLevel } = workStore;
+    let baseValidationLevel = 0;
+    let manualValidation = false;
+    switch(validationLevel){
+        case 'manual-warning':
+            manualValidation = true;
+        // intentional fallthrough
+        case 'warning':
+            baseValidationLevel = 0;
+            break;
+        case 'experimental-manual-error':
+            manualValidation = true;
+        // intentional fallthrough
+        case 'experimental-error':
+            baseValidationLevel = 1;
+            break;
+        default:
+            validationLevel;
+    }
+    const applyDefaultValidation = // We need to be validating the right level
+    level <= baseValidationLevel && // We need to not be in manual validation mode
+    !manualValidation && // We don't validate framework internal routes by default
+    !isFrameworkErrorRoute(workStore.route);
+    let needsValidation = false;
+    let disabled = false;
+    async function visit(tree) {
+        if (disabled) return;
+        const { mod: layoutOrPageMod } = await (0, _appdirmodule.getLayoutOrPageModule)(tree);
+        const instantConfig = layoutOrPageMod ? layoutOrPageMod.instant : undefined;
+        if (instantConfig === false) {
+        // Explicit opt-out. Doesn't itself trigger validation.
+        } else if (instantConfig === true) {
+            // Explicit opt-in using the default level.
+            if (level <= baseValidationLevel) {
+                needsValidation = true;
+            }
+        } else if (typeof instantConfig === 'object' && instantConfig !== null) {
+            if (instantConfig.unstable_disableValidation === true || level === 0 && instantConfig.unstable_disableDevValidation === true || level === 1 && instantConfig.unstable_disableBuildValidation === true) {
+                disabled = true;
+                return;
+            }
+            if (instantConfig.level !== undefined) {
+                const configuredLevel = instantConfig.level === 'experimental-error' ? 1 : 0;
+                if (level <= configuredLevel) {
+                    needsValidation = true;
+                }
+            } else if (level <= baseValidationLevel) {
+                needsValidation = true;
+            }
+        } else if (applyDefaultValidation && isImplicitValidationSegment(tree[0])) {
+            // No explicit config. Implicit validation applies to page/default
+            // segments when the default level is active for this mode.
+            needsValidation = true;
+        }
+        const { parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+        for(const parallelRouteKey in parallelRoutes){
+            await visit(parallelRoutes[parallelRouteKey]);
+            if (disabled) return;
+        }
+    }
+    await visit(rootTree);
+    if (disabled) {
+        return false;
+    }
+    return needsValidation;
+}
+const anySegmentNeedsInstantValidationInDev = cacheScopedToWorkStore(async (rootTree)=>anySegmentNeedsInstantValidation(rootTree, 0));
+const anySegmentNeedsInstantValidationInBuild = cacheScopedToWorkStore(async (rootTree)=>anySegmentNeedsInstantValidation(rootTree, 1));
+const resolveInstantConfigSamplesForPage = async (tree)=>{
+    const { mod: layoutOrPageMod } = await (0, _appdirmodule.getLayoutOrPageModule)(tree);
+    const instantConfig = layoutOrPageMod ? layoutOrPageMod.instant : undefined;
+    let samples = null;
+    if (instantConfig !== undefined && typeof instantConfig === 'object' && instantConfig.unstable_samples) {
+        samples = instantConfig.unstable_samples;
+    }
+    // The samples from inner segments override samples from outer segments,
+    // i.e. a page overrides the samples from a layout.
+    // We do not perform any merging logic.
+    const { parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+    for(const parallelRouteKey in parallelRoutes){
+        if (parallelRouteKey !== 'children') {
+            continue;
+        }
+        const childTree = parallelRoutes[parallelRouteKey];
+        const childSamples = await resolveInstantConfigSamplesForPage(childTree);
+        if (childSamples !== null) {
+            samples = childSamples;
+        }
+    }
+    return samples;
+};
+/**
+ * A simple cache wrapper for 1-argument functions.
+ * The cache will live as long as the current WorkStore,
+ * i.e. it's scoped to a single request.
+ */ function cacheScopedToWorkStore(func) {
+    const resultsPerWorkStore = new WeakMap();
+    return (arg)=>{
+        const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+        if (!workStore) {
+            throw new _invarianterror.InvariantError(`${func.name || 'cacheScopedToWorkStore callee'} must run inside a WorkStore`);
+        }
+        let results = resultsPerWorkStore.get(workStore);
+        if (results && results.has(arg)) {
+            return results.get(arg);
+        }
+        const result = func(arg);
+        if (!results) {
+            results = new WeakMap();
+            resultsPerWorkStore.set(workStore, results);
+        }
+        results.set(arg, result);
+        return result;
+    };
+}
+
+//# sourceMappingURL=instant-config.js.map