@codelionapps/unharness 0.0.0-stage → 0.1.0

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/magic-identifier.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    MAGIC_IDENTIFIER_REGEX: null,
+    decodeMagicIdentifier: null,
+    deobfuscateModuleId: null,
+    deobfuscateText: null,
+    deobfuscateTextParts: null,
+    removeFreeCallWrapper: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    MAGIC_IDENTIFIER_REGEX: function() {
+        return MAGIC_IDENTIFIER_REGEX;
+    },
+    decodeMagicIdentifier: function() {
+        return decodeMagicIdentifier;
+    },
+    deobfuscateModuleId: function() {
+        return deobfuscateModuleId;
+    },
+    deobfuscateText: function() {
+        return deobfuscateText;
+    },
+    deobfuscateTextParts: function() {
+        return deobfuscateTextParts;
+    },
+    removeFreeCallWrapper: function() {
+        return removeFreeCallWrapper;
+    }
+});
+function decodeHex(hexStr) {
+    if (hexStr.trim() === '') {
+        throw new Error("can't decode empty hex");
+    }
+    const num = parseInt(hexStr, 16);
+    if (isNaN(num)) {
+        throw new Error(`invalid hex: \`${hexStr}\``);
+    }
+    return String.fromCodePoint(num);
+}
+const DECODE_REGEX = /^__TURBOPACK__([a-zA-Z0-9_$]+)__$/;
+function decodeMagicIdentifier(identifier) {
+    const matches = identifier.match(DECODE_REGEX);
+    if (!matches) {
+        return identifier;
+    }
+    const inner = matches[1];
+    let output = '';
+    let mode = 0;
+    let buffer = '';
+    for(let i = 0; i < inner.length; i++){
+        const char = inner[i];
+        if (mode === 0) {
+            if (char === '_') {
+                mode = 1;
+            } else if (char === '$') {
+                mode = 2;
+            } else {
+                output += char;
+            }
+        } else if (mode === 1) {
+            if (char === '_') {
+                output += ' ';
+                mode = 0;
+            } else if (char === '$') {
+                output += '_';
+                mode = 2;
+            } else {
+                output += char;
+                mode = 0;
+            }
+        } else if (mode === 2) {
+            if (buffer.length === 2) {
+                output += decodeHex(buffer);
+                buffer = '';
+            }
+            if (char === '_') {
+                if (buffer !== '') {
+                    throw new Error(`invalid hex: \`${buffer}\``);
+                }
+                mode = 3;
+            } else if (char === '$') {
+                if (buffer !== '') {
+                    throw new Error(`invalid hex: \`${buffer}\``);
+                }
+                mode = 0;
+            } else {
+                buffer += char;
+            }
+        } else if (mode === 3) {
+            if (char === '_') {
+                throw new Error(`invalid hex: \`${buffer + char}\``);
+            } else if (char === '$') {
+                output += decodeHex(buffer);
+                buffer = '';
+                mode = 0;
+            } else {
+                buffer += char;
+            }
+        }
+    }
+    return output;
+}
+const MAGIC_IDENTIFIER_REGEX = /__TURBOPACK__[a-zA-Z0-9_$]+__/g;
+function deobfuscateModuleId(moduleId) {
+    return moduleId// Replace [project] with .
+    .replace(/\[project\]/g, '.')// Remove content in square brackets (e.g. [app-rsc])
+    .replace(/\s\[([^\]]*)\]/g, '')// Remove content in parentheses (e.g. (ecmascript))
+    .replace(/\s\(([^)]*)\)/g, '')// Remove content in angle brackets (e.g. <locals>)
+    .replace(/\s<([^>]*)>/g, '')// Clean up any extra whitespace
+    .trim();
+}
+function removeFreeCallWrapper(text) {
+    // Match (0, <ident>.<ident>) patterns anywhere in the text the beginning
+    // Overzealous: accept any non-whitespace member expression after the dot.
+    // TODO: Fix https://linear.app/vercel/issue/NEXT-4875 to allow using unicode property escapes
+    return text.replace(/\(0\s*,\s*(__TURBOPACK__[a-zA-Z0-9_$]+__\.[^\s)]+)\)/g, '$1');
+}
+function deobfuscateTextParts(text) {
+    // First, remove free call wrappers
+    const withoutFreeCall = removeFreeCallWrapper(text);
+    const parts = [];
+    let lastIndex = 0;
+    // Create a new regex instance for global matching
+    const regex = new RegExp(MAGIC_IDENTIFIER_REGEX.source, 'g');
+    for(let match = regex.exec(withoutFreeCall); match !== null; match = regex.exec(withoutFreeCall)){
+        const matchStart = match.index;
+        const matchEnd = regex.lastIndex;
+        const ident = match[0];
+        // Add raw text before this match (if any)
+        if (matchStart > lastIndex) {
+            const rawText = withoutFreeCall.substring(lastIndex, matchStart);
+            parts.push([
+                'raw',
+                rawText
+            ]);
+        }
+        // Process and add the deobfuscated part
+        try {
+            const decoded = decodeMagicIdentifier(ident);
+            // If it was a magic identifier, clean up the module ID
+            if (decoded !== ident) {
+                // Check if this is an "imported module" reference
+                const importedModuleMatch = decoded.match(/^imported module (.+)$/);
+                if (importedModuleMatch) {
+                    // Clean the entire module path (which includes [app-rsc], etc.)
+                    const modulePathWithMetadata = importedModuleMatch[1];
+                    const cleaned = deobfuscateModuleId(modulePathWithMetadata);
+                    parts.push([
+                        'deobfuscated',
+                        `{imported module ${cleaned}}`
+                    ]);
+                } else {
+                    const cleaned = deobfuscateModuleId(decoded);
+                    parts.push([
+                        'deobfuscated',
+                        `{${cleaned}}`
+                    ]);
+                }
+            } else {
+                // Not actually a magic identifier, treat as raw
+                parts.push([
+                    'raw',
+                    ident
+                ]);
+            }
+        } catch (e) {
+            parts.push([
+                'deobfuscated',
+                `{${ident} (decoding failed: ${e})}`
+            ]);
+        }
+        lastIndex = matchEnd;
+    }
+    // Add any remaining raw text after the last match
+    if (lastIndex < withoutFreeCall.length) {
+        const rawText = withoutFreeCall.substring(lastIndex);
+        parts.push([
+            'raw',
+            rawText
+        ]);
+    }
+    return parts;
+}
+function deobfuscateText(text) {
+    const parts = deobfuscateTextParts(text);
+    return parts.map((part)=>part[1]).join('');
+}
+
+//# sourceMappingURL=magic-identifier.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/match-local-pattern.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    hasLocalMatch: null,
+    matchLocalPattern: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    hasLocalMatch: function() {
+        return hasLocalMatch;
+    },
+    matchLocalPattern: function() {
+        return matchLocalPattern;
+    }
+});
+const _picomatch = require("next/dist/compiled/picomatch");
+function matchLocalPattern(pattern, url) {
+    if (pattern.search !== undefined) {
+        if (pattern.search !== url.search) {
+            return false;
+        }
+    }
+    if (!(0, _picomatch.makeRe)(pattern.pathname ?? '**', {
+        dot: true
+    }).test(url.pathname)) {
+        return false;
+    }
+    return true;
+}
+function hasLocalMatch(localPatterns, urlPathAndQuery) {
+    if (!localPatterns) {
+        // if the user didn't define "localPatterns", we allow all local images
+        return true;
+    }
+    const url = new URL(urlPathAndQuery, 'http://n');
+    return localPatterns.some((p)=>matchLocalPattern(p, url));
+}
+
+//# sourceMappingURL=match-local-pattern.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/match-remote-pattern.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    hasRemoteMatch: null,
+    matchRemotePattern: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    hasRemoteMatch: function() {
+        return hasRemoteMatch;
+    },
+    matchRemotePattern: function() {
+        return matchRemotePattern;
+    }
+});
+const _picomatch = require("next/dist/compiled/picomatch");
+function matchRemotePattern(pattern, url) {
+    if (pattern.protocol !== undefined) {
+        if (pattern.protocol.replace(/:$/, '') !== url.protocol.replace(/:$/, '')) {
+            return false;
+        }
+    }
+    if (pattern.port !== undefined) {
+        if (pattern.port !== url.port) {
+            return false;
+        }
+    }
+    if (pattern.hostname === undefined) {
+        throw new Error(`Pattern should define hostname but found\n${JSON.stringify(pattern)}`);
+    } else {
+        if (!(0, _picomatch.makeRe)(pattern.hostname).test(url.hostname)) {
+            return false;
+        }
+    }
+    if (pattern.search !== undefined) {
+        if (pattern.search !== url.search) {
+            return false;
+        }
+    }
+    // Should be the same as writeImagesManifest()
+    if (!(0, _picomatch.makeRe)(pattern.pathname ?? '**', {
+        dot: true
+    }).test(url.pathname)) {
+        return false;
+    }
+    return true;
+}
+function hasRemoteMatch(domains, remotePatterns, url) {
+    return domains.some((domain)=>url.hostname === domain) || remotePatterns.some((p)=>matchRemotePattern(p, url));
+}
+
+//# sourceMappingURL=match-remote-pattern.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/modern-browserslist-target.js

@@ -0,0 +1,15 @@
+// Note: This file is JS because it's used by the taskfile-swc.js file, which is JS.
+// Keep file changes in sync with the corresponding `.d.ts` files.
+/**
+ * These are the minimum browser versions that we consider "modern" and thus compile for by default.
+ * This list was generated using `pnpm browserslist "baseline widely available"` on 2025-10-01.
+ */ "use strict";
+const MODERN_BROWSERSLIST_TARGET = [
+    'chrome 111',
+    'edge 111',
+    'firefox 111',
+    'safari 16.4'
+];
+module.exports = MODERN_BROWSERSLIST_TARGET;
+
+//# sourceMappingURL=modern-browserslist-target.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/no-fallback-error.external.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NoFallbackError", {
+    enumerable: true,
+    get: function() {
+        return NoFallbackError;
+    }
+});
+class NoFallbackError extends Error {
+    constructor(){
+        super();
+        this.message = 'Internal: NoFallbackError';
+    }
+}
+
+//# sourceMappingURL=no-fallback-error.external.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/normalized-asset-prefix.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "normalizedAssetPrefix", {
+    enumerable: true,
+    get: function() {
+        return normalizedAssetPrefix;
+    }
+});
+function normalizedAssetPrefix(assetPrefix) {
+    // remove all leading slashes and trailing slashes
+    const escapedAssetPrefix = assetPrefix?.replace(/^\/+|\/+$/g, '') || false;
+    // if an assetPrefix was '/', we return empty string
+    // because it could be an unnecessary trailing slash
+    if (!escapedAssetPrefix) {
+        return '';
+    }
+    if (URL.canParse(escapedAssetPrefix)) {
+        const url = new URL(escapedAssetPrefix).toString();
+        return url.endsWith('/') ? url.slice(0, -1) : url;
+    }
+    // assuming assetPrefix here is a pathname-style,
+    // restore the leading slash
+    return `/${escapedAssetPrefix}`;
+}
+
+//# sourceMappingURL=normalized-asset-prefix.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/page-path/absolute-path-to-page.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "absolutePathToPage", {
+    enumerable: true,
+    get: function() {
+        return absolutePathToPage;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _ensureleadingslash = require("./ensure-leading-slash");
+const _normalizepathsep = require("./normalize-path-sep");
+const _path = /*#__PURE__*/ _interop_require_default._(require("../isomorphic/path"));
+const _removepagepathtail = require("./remove-page-path-tail");
+const _getmetadataroute = require("../../../lib/metadata/get-metadata-route");
+function absolutePathToPage(pagePath, options) {
+    const isAppDir = options.pagesType === 'app';
+    const page = (0, _removepagepathtail.removePagePathTail)((0, _normalizepathsep.normalizePathSep)((0, _ensureleadingslash.ensureLeadingSlash)(_path.default.relative(options.dir, pagePath))), {
+        extensions: options.extensions,
+        keepIndex: options.keepIndex
+    });
+    return isAppDir ? (0, _getmetadataroute.normalizeMetadataRoute)(page) : page;
+}
+
+//# sourceMappingURL=absolute-path-to-page.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/page-path/denormalize-page-path.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "denormalizePagePath", {
+    enumerable: true,
+    get: function() {
+        return denormalizePagePath;
+    }
+});
+const _utils = require("../router/utils");
+const _normalizepathsep = require("./normalize-path-sep");
+function denormalizePagePath(page) {
+    let _page = (0, _normalizepathsep.normalizePathSep)(page);
+    return _page.startsWith('/index/') && !(0, _utils.isDynamicRoute)(_page) ? _page.slice(6) : _page !== '/index' ? _page : '/';
+}
+
+//# sourceMappingURL=denormalize-page-path.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/page-path/ensure-leading-slash.js

@@ -0,0 +1,18 @@
+/**
+ * For a given page path, this function ensures that there is a leading slash.
+ * If there is not a leading slash, one is added, otherwise it is noop.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ensureLeadingSlash", {
+    enumerable: true,
+    get: function() {
+        return ensureLeadingSlash;
+    }
+});
+function ensureLeadingSlash(path) {
+    return path.startsWith('/') ? path : `/${path}`;
+}
+
+//# sourceMappingURL=ensure-leading-slash.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/page-path/get-page-paths.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getPagePaths", {
+    enumerable: true,
+    get: function() {
+        return getPagePaths;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _denormalizepagepath = require("./denormalize-page-path");
+const _path = /*#__PURE__*/ _interop_require_default._(require("../isomorphic/path"));
+function getPagePaths(normalizedPagePath, extensions, isAppDir) {
+    const page = (0, _denormalizepagepath.denormalizePagePath)(normalizedPagePath);
+    let prefixes;
+    if (isAppDir) {
+        prefixes = [
+            page
+        ];
+    } else if (normalizedPagePath.endsWith('/index')) {
+        prefixes = [
+            _path.default.join(page, 'index')
+        ];
+    } else {
+        prefixes = [
+            page,
+            _path.default.join(page, 'index')
+        ];
+    }
+    const paths = [];
+    for (const extension of extensions){
+        for (const prefix of prefixes){
+            paths.push(`${prefix}.${extension}`);
+        }
+    }
+    return paths;
+}
+
+//# sourceMappingURL=get-page-paths.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/page-path/normalize-data-path.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "normalizeDataPath", {
+    enumerable: true,
+    get: function() {
+        return normalizeDataPath;
+    }
+});
+const _pathhasprefix = require("../router/utils/path-has-prefix");
+function normalizeDataPath(pathname) {
+    if (!(0, _pathhasprefix.pathHasPrefix)(pathname || '/', '/_next/data')) {
+        return pathname;
+    }
+    pathname = pathname.replace(/\/_next\/data\/[^/]{1,}/, '').replace(/\.json$/, '');
+    if (pathname === '/index') {
+        return '/';
+    }
+    return pathname;
+}
+
+//# sourceMappingURL=normalize-data-path.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/page-path/normalize-page-path.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "normalizePagePath", {
+    enumerable: true,
+    get: function() {
+        return normalizePagePath;
+    }
+});
+const _ensureleadingslash = require("./ensure-leading-slash");
+const _utils = require("../router/utils");
+const _utils1 = require("../utils");
+function normalizePagePath(page) {
+    const normalized = /^\/index(\/|$)/.test(page) && !(0, _utils.isDynamicRoute)(page) ? `/index${page}` : page === '/' ? '/index' : (0, _ensureleadingslash.ensureLeadingSlash)(page);
+    if (process.env.NEXT_RUNTIME !== 'edge') {
+        const { posix } = require('path');
+        const resolvedPage = posix.normalize(normalized);
+        if (resolvedPage !== normalized) {
+            throw new _utils1.NormalizeError(`Requested and resolved page mismatch: ${normalized} ${resolvedPage}`);
+        }
+    }
+    return normalized;
+}
+
+//# sourceMappingURL=normalize-page-path.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/page-path/normalize-path-sep.js

@@ -0,0 +1,19 @@
+/**
+ * For a given page path, this function ensures that there is no backslash
+ * escaping slashes in the path. Example:
+ *  - `foo\/bar\/baz` -> `foo/bar/baz`
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "normalizePathSep", {
+    enumerable: true,
+    get: function() {
+        return normalizePathSep;
+    }
+});
+function normalizePathSep(path) {
+    return path.replace(/\\/g, '/');
+}
+
+//# sourceMappingURL=normalize-path-sep.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/page-path/remove-page-path-tail.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "removePagePathTail", {
+    enumerable: true,
+    get: function() {
+        return removePagePathTail;
+    }
+});
+const _normalizepathsep = require("./normalize-path-sep");
+function removePagePathTail(pagePath, options) {
+    pagePath = (0, _normalizepathsep.normalizePathSep)(pagePath).replace(new RegExp(`\\.+(?:${options.extensions.join('|')})$`), '');
+    if (options.keepIndex !== true) {
+        pagePath = pagePath.replace(/\/index$/, '') || '/';
+    }
+    return pagePath;
+}
+
+//# sourceMappingURL=remove-page-path-tail.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/promise-with-resolvers.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createPromiseWithResolvers", {
+    enumerable: true,
+    get: function() {
+        return createPromiseWithResolvers;
+    }
+});
+function createPromiseWithResolvers() {
+    // Shim of Stage 4 Promise.withResolvers proposal
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej)=>{
+        resolve = res;
+        reject = rej;
+    });
+    return {
+        resolve: resolve,
+        reject: reject,
+        promise
+    };
+}
+
+//# sourceMappingURL=promise-with-resolvers.js.map

package/dashboard/.next/standalone/node_modules/next/dist/shared/lib/request-insights.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getRequestInsightKey: null,
+    getRequestInsightKind: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getRequestInsightKey: function() {
+        return getRequestInsightKey;
+    },
+    getRequestInsightKind: function() {
+        return getRequestInsightKind;
+    }
+});
+function getRequestInsightKind(insight) {
+    return insight.kind ?? 'request';
+}
+function getRequestInsightKey(insight) {
+    return `${getRequestInsightKind(insight)}:${insight.requestId}`;
+}
+
+//# sourceMappingURL=request-insights.js.map