vibecodedshit 0.0.0-stage → 0.2.0

package/dist/measure/safety/ts-imports.js

@@ -0,0 +1,63 @@
+import ts from 'typescript';
+const isStringLiteral = (node) => node !== undefined && ts.isStringLiteralLike(node);
+/**
+ * What a test file imports: static `import` declarations of every form (`import type` and `import { type X }` included), `export ... from`,
+ * `require("<literal>")` and dynamic `import("<literal>")`. `vi.mock`, `jest.mock`, `require.resolve` and non-literal paths do not count.
+ */
+export function importFacts(sf) {
+    const facts = [];
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node) && isStringLiteral(node.moduleSpecifier)) {
+            const specifier = node.moduleSpecifier.text;
+            const clause = node.importClause;
+            if (!clause)
+                facts.push({ specifier });
+            else {
+                if (clause.name)
+                    facts.push({ specifier, name: 'default' });
+                const bindings = clause.namedBindings;
+                if (bindings && ts.isNamespaceImport(bindings))
+                    facts.push({ specifier, name: '*', local: bindings.name.text });
+                else if (bindings)
+                    for (const el of bindings.elements)
+                        facts.push({ specifier, name: (el.propertyName ?? el.name).text });
+                if (!clause.name && !bindings)
+                    facts.push({ specifier });
+            }
+        }
+        else if (ts.isExportDeclaration(node) && isStringLiteral(node.moduleSpecifier)) {
+            const specifier = node.moduleSpecifier.text;
+            const clause = node.exportClause;
+            if (clause && ts.isNamedExports(clause))
+                for (const el of clause.elements)
+                    facts.push({ specifier, name: (el.propertyName ?? el.name).text });
+            else
+                facts.push({ specifier });
+        }
+        else if (ts.isCallExpression(node) && isStringLiteral(node.arguments[0])) {
+            const callee = node.expression;
+            if ((ts.isIdentifier(callee) && callee.text === 'require') || callee.kind === ts.SyntaxKind.ImportKeyword) {
+                facts.push({ specifier: node.arguments[0].text });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return facts;
+}
+/** Names accessed as `m.x` for each namespace-import binding `m` of a file. */
+export function namespaceAccesses(sf, locals) {
+    const out = new Map();
+    if (locals.size === 0)
+        return out;
+    const visit = (node) => {
+        if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && locals.has(node.expression.text)) {
+            const set = out.get(node.expression.text) ?? new Set();
+            set.add(node.name.text);
+            out.set(node.expression.text, set);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return out;
+}

package/dist/measure/safety/ts-resolve.js

@@ -0,0 +1,43 @@
+import path from 'node:path';
+import ts from 'typescript';
+import { trackedPaths } from '../../scope/tracked.js';
+import { compilerOptionsFor } from '../ts/tsconfig.js';
+const posix = (p) => p.split(path.sep).join('/');
+/**
+ * `ts.resolveModuleName` with the options of the nearest tsconfig and a host backed by the tracked files, so `node_modules`
+ * is never read and a package import resolves to nothing. NodeNext `.js` specifiers that map to `.ts` files resolve through the compiler.
+ */
+export function createTsResolver(repoPath) {
+    const root = posix(path.resolve(repoPath));
+    const files = new Set(trackedPaths(repoPath));
+    const dirs = new Set(['']);
+    for (const file of files)
+        for (let d = path.posix.dirname(file); d !== '.' && !dirs.has(d); d = path.posix.dirname(d))
+            dirs.add(d);
+    const rel = (abs) => path.posix.relative(root, posix(abs));
+    const host = {
+        fileExists: (abs) => files.has(rel(abs)),
+        readFile: (abs) => (files.has(rel(abs)) ? ts.sys.readFile(abs) : undefined),
+        directoryExists: (abs) => dirs.has(rel(abs) === '.' ? '' : rel(abs)),
+        realpath: (abs) => abs,
+        getCurrentDirectory: () => root,
+        useCaseSensitiveFileNames: true,
+    };
+    const optionsByDir = new Map();
+    return {
+        resolve(specifier, fromFile) {
+            const dir = path.posix.dirname(fromFile);
+            let options = optionsByDir.get(dir);
+            if (!options) {
+                options = compilerOptionsFor(repoPath, dir);
+                optionsByDir.set(dir, options);
+            }
+            const containing = path.posix.join(root, fromFile);
+            const result = ts.resolveModuleName(specifier, containing, options, host).resolvedModule;
+            if (!result)
+                return undefined;
+            const found = rel(result.resolvedFileName);
+            return found.startsWith('..') || !files.has(found) ? undefined : found;
+        },
+    };
+}

package/dist/measure/ts/directives.js

@@ -0,0 +1,37 @@
+import ts from 'typescript';
+/** True when the file's leading comments hold `@<name>` at the start of a comment (after `//`, `///` or `/*`). */
+export function hasLeadingDirective(sourceFile, name) {
+    const text = sourceFile.text;
+    const pattern = new RegExp(`^(?:\\/\\/\\/?|\\/\\*+)\\s*@${name}\\b`);
+    return (ts.getLeadingCommentRanges(text, 0) ?? []).some((range) => pattern.test(text.slice(range.pos, range.end)));
+}
+const LINE_DIRECTIVE = /^\/\/\/?\s*@(?:ts-expect-error|ts-ignore)/;
+const BLOCK_DIRECTIVE = /^(?:\/|\*)*\s*@(?:ts-expect-error|ts-ignore)/;
+/** Number of `@ts-ignore` and `@ts-expect-error` comments, found through the AST so strings, templates, regexes and JSX text never count. */
+export function countSuppressionComments(sourceFile) {
+    const text = sourceFile.text;
+    const seen = new Set();
+    let count = 0;
+    const check = (ranges) => {
+        for (const range of ranges ?? []) {
+            if (seen.has(range.pos))
+                continue;
+            seen.add(range.pos);
+            const comment = text.slice(range.pos, range.end);
+            const matches = range.kind === ts.SyntaxKind.SingleLineCommentTrivia
+                ? LINE_DIRECTIVE.test(comment)
+                : BLOCK_DIRECTIVE.test(comment.slice(comment.lastIndexOf('\n') + 1));
+            if (matches)
+                count += 1;
+        }
+    };
+    const visit = (node) => {
+        if (node.kind !== ts.SyntaxKind.JsxText) {
+            check(ts.getLeadingCommentRanges(text, node.pos));
+            check(ts.getTrailingCommentRanges(text, node.end));
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return count;
+}

package/dist/measure/ts/exports.js

@@ -0,0 +1,60 @@
+import ts from 'typescript';
+function hasModifier(node, kind) {
+    return ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((m) => m.kind === kind) ?? false);
+}
+function bindingNames(name, out) {
+    if (ts.isIdentifier(name)) {
+        out.add(name.text);
+        return;
+    }
+    for (const element of name.elements) {
+        if (ts.isBindingElement(element))
+            bindingNames(element.name, out);
+    }
+}
+/**
+ * Exported symbols of one file, the denominator of 4.4:
+ * each exported declaration by name (overloads and merged declarations once, each binding of a
+ * destructured `const` once), each specifier of `export { a, b as c }` and `export { x } from`,
+ * `export default` once, `export =` once, `export * as ns from` once, `export * from` zero.
+ */
+export function countExportedSymbols(sourceFile) {
+    const names = new Set();
+    let extra = 0;
+    for (const statement of sourceFile.statements) {
+        if (ts.isExportAssignment(statement)) {
+            extra += 1; // `export default expr` and `export = expr`
+            continue;
+        }
+        if (ts.isExportDeclaration(statement)) {
+            const clause = statement.exportClause;
+            if (!clause)
+                continue; // export * from '...'
+            if (ts.isNamespaceExport(clause))
+                extra += 1;
+            else
+                extra += clause.elements.length;
+            continue;
+        }
+        if (!hasModifier(statement, ts.SyntaxKind.ExportKeyword))
+            continue;
+        if (hasModifier(statement, ts.SyntaxKind.DefaultKeyword)) {
+            extra += 1;
+            continue;
+        }
+        if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations)
+                bindingNames(declaration.name, names);
+        }
+        else if (ts.isFunctionDeclaration(statement) ||
+            ts.isClassDeclaration(statement) ||
+            ts.isInterfaceDeclaration(statement) ||
+            ts.isTypeAliasDeclaration(statement) ||
+            ts.isEnumDeclaration(statement) ||
+            ts.isModuleDeclaration(statement)) {
+            if (statement.name)
+                names.add(statement.name.getText(sourceFile));
+        }
+    }
+    return names.size + extra;
+}

package/dist/measure/ts/tsconfig.js

@@ -0,0 +1,179 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import ts from 'typescript';
+import { trackedPaths } from '../../scope/tracked.js';
+const STRICT_FAMILY = [
+    'noImplicitAny',
+    'strictNullChecks',
+    'strictFunctionTypes',
+    'strictBindCallApply',
+    'strictPropertyInitialization',
+    'noImplicitThis',
+    'useUnknownInCatchVariables',
+    'alwaysStrict',
+];
+const LEVEL_ORDER = ['none', 'partial', 'strict', 'strict_plus'];
+const posix = (p) => p.split(path.sep).join('/');
+const host = {
+    ...ts.sys,
+    onUnRecoverableConfigFileDiagnostic: () => undefined,
+};
+/** Parse one tsconfig or jsconfig with `extends` resolved by the TypeScript API. JSON only, nothing is executed. */
+function loadTsConfig(file, cache) {
+    const key = posix(file);
+    if (cache.has(key))
+        return cache.get(key);
+    let info;
+    const parsed = ts.getParsedCommandLineOfConfigFile(file, {}, host);
+    if (parsed) {
+        const raw = parsed.raw;
+        const references = (parsed.projectReferences ?? []).map((ref) => {
+            const resolved = ts.resolveProjectReferencePath(ref);
+            return posix(resolved);
+        });
+        const missingExtends = [];
+        for (const error of parsed.errors) {
+            if (error.code !== 6053)
+                continue; // File '{0}' not found.
+            const match = /'([^']+)'/.exec(ts.flattenDiagnosticMessageText(error.messageText, '\n'));
+            if (match?.[1])
+                missingExtends.push(match[1]);
+        }
+        info = {
+            file: key,
+            options: parsed.options,
+            fileNames: new Set(parsed.fileNames.map(posix)),
+            references,
+            solution: Array.isArray(raw?.files) && raw.files.length === 0 && references.length > 0,
+            missingExtends,
+        };
+    }
+    cache.set(key, info);
+    return info;
+}
+/** The level a set of compiler options declares: every flag is its explicit value, else `strict`, else false. */
+export function levelOf(options) {
+    const bag = options;
+    const strict = bag.strict === true;
+    const effective = (flag) => (typeof bag[flag] === 'boolean' ? bag[flag] === true : strict);
+    const turnedOff = STRICT_FAMILY.some((flag) => bag[flag] === false);
+    if (strict && !turnedOff)
+        return options.noUncheckedIndexedAccess === true ? 'strict_plus' : 'strict';
+    return STRICT_FAMILY.some(effective) ? 'partial' : 'none';
+}
+export function lowestLevel(levels) {
+    return levels.reduce((low, level) => (LEVEL_ORDER.indexOf(level) < LEVEL_ORDER.indexOf(low) ? level : low), 'strict_plus');
+}
+function reachable(root, cache) {
+    const seen = new Set([root.file]);
+    const out = [];
+    const queue = [...root.references];
+    while (queue.length > 0) {
+        const next = queue.shift();
+        if (next === undefined || seen.has(next))
+            continue;
+        seen.add(next);
+        const info = loadTsConfig(next, cache);
+        if (!info)
+            continue;
+        out.push(info);
+        queue.push(...info.references);
+    }
+    return out;
+}
+function covers(config, files) {
+    for (const file of config.fileNames)
+        if (files.has(file))
+            return true;
+    return false;
+}
+function configIn(dir) {
+    for (const name of ['tsconfig.json', 'jsconfig.json']) {
+        const candidate = path.join(dir, name);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+/**
+ * The configs that apply to one unit: the package's own `tsconfig.json`, else its `jsconfig.json`,
+ * else the nearest ancestor config up to the repository root, kept only if it (or a config it
+ * references) covers a logic file of the unit. A solution-style config is replaced by the configs
+ * reachable through its `references` that cover a logic file of the unit (the config itself if none do).
+ */
+export function unitConfigs(repoPath, packageDir, logicFiles, cache) {
+    const files = new Set(logicFiles.map((f) => posix(path.resolve(repoPath, f))));
+    const root = path.resolve(repoPath);
+    const start = path.resolve(repoPath, packageDir);
+    let chosen = configIn(start);
+    let ancestor = false;
+    if (!chosen) {
+        ancestor = true;
+        for (let dir = path.dirname(start);; dir = path.dirname(dir)) {
+            if (dir.length < root.length)
+                break;
+            chosen = configIn(dir);
+            if (chosen || dir === root)
+                break;
+        }
+    }
+    if (!chosen)
+        return { configs: [], read: [] };
+    const top = loadTsConfig(chosen, cache);
+    if (!top)
+        return { configs: [], read: [] };
+    const nested = reachable(top, cache);
+    const read = [top, ...nested];
+    if (ancestor && ![top, ...nested].some((c) => covers(c, files)))
+        return { configs: [], read: [] };
+    if (!top.solution)
+        return { configs: [top], read };
+    const covering = nested.filter((c) => !c.solution && covers(c, files));
+    return { configs: covering.length > 0 ? covering : [top], read };
+}
+/** The nearest `tsconfig.json`, else `jsconfig.json`, from `dir` up to the repository root. Absolute path. */
+export function nearestTsConfig(repoPath, dir) {
+    const root = path.resolve(repoPath);
+    for (let current = path.resolve(root, dir); current.length >= root.length; current = path.dirname(current)) {
+        const found = configIn(current);
+        if (found)
+            return found;
+        if (current === root)
+            break;
+    }
+    return undefined;
+}
+const optionsCache = new Map();
+/**
+ * The compiler options of the nearest `tsconfig.json`, else `jsconfig.json`, with `extends` chains resolved through a host that only
+ * sees tracked files (so `node_modules` is never read). Without a config: `Bundler` resolution, ESNext modules, `allowJs`, JSON modules.
+ */
+export function compilerOptionsFor(repoPath, dir) {
+    const fallback = {
+        moduleResolution: ts.ModuleResolutionKind.Bundler,
+        module: ts.ModuleKind.ESNext,
+        allowJs: true,
+        resolveJsonModule: true,
+    };
+    const configFile = nearestTsConfig(repoPath, dir);
+    if (!configFile)
+        return fallback;
+    const cached = optionsCache.get(configFile);
+    if (cached)
+        return cached;
+    const root = path.resolve(repoPath);
+    const tracked = new Set(trackedPaths(repoPath));
+    const rel = (abs) => path.posix.relative(posix(root), posix(abs));
+    const visible = (abs) => tracked.has(rel(abs));
+    const configHost = {
+        useCaseSensitiveFileNames: true,
+        readDirectory: () => [],
+        fileExists: visible,
+        readFile: (abs) => (visible(abs) ? ts.sys.readFile(abs) : undefined),
+    };
+    const read = ts.readConfigFile(configFile, (abs) => configHost.readFile(abs));
+    const parsed = read.error ? undefined : ts.parseJsonConfigFileContent(read.config, configHost, path.dirname(configFile));
+    const options = { ...fallback, ...(parsed?.options ?? {}), allowJs: true };
+    optionsCache.set(configFile, options);
+    return options;
+}

package/dist/measure/types.js

@@ -0,0 +1 @@
+export {};

package/dist/measure/units.js

@@ -0,0 +1,41 @@
+export function logicFiles(scope, group) {
+    return scope.files.filter((f) => f.role === 'logic' && f.group === group);
+}
+export function unitId(file) {
+    return `${file.package}\0${file.group}`;
+}
+/** One tally per (package, group) that has logic files, weight = logic lines of the unit. */
+export function emptyTallies(files) {
+    const tallies = new Map();
+    for (const file of files) {
+        const key = unitId(file);
+        const tally = tallies.get(key) ?? { package: file.package, group: file.group, weight: 0, numerator: 0, denominator: 0 };
+        tally.weight += file.logicLines;
+        tallies.set(key, tally);
+    }
+    return tallies;
+}
+export function tallyUnits(tallies) {
+    return [...tallies.values()]
+        .sort((a, b) => a.package.localeCompare(b.package) || a.group.localeCompare(b.group))
+        .map((t) => ({
+        package: t.package,
+        group: t.group,
+        weight: t.weight,
+        raw: { kind: 'ratio', numerator: t.numerator, denominator: t.denominator, scale: 100 },
+    }));
+}
+/** One unit per (workspace package, language group) that has at least one logic-role file, sorted by package then group. */
+export function logicUnits(scope) {
+    const units = new Map();
+    for (const file of scope.files) {
+        if (file.role !== 'logic')
+            continue;
+        const key = unitId(file);
+        const unit = units.get(key) ?? { package: file.package, group: file.group, dir: file.package, weight: 0, files: [] };
+        unit.weight += file.logicLines;
+        unit.files.push(file);
+        units.set(key, unit);
+    }
+    return [...units.values()].sort((a, b) => a.package.localeCompare(b.package) || a.group.localeCompare(b.group));
+}

package/dist/methodology/load.js

@@ -0,0 +1,159 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse } from 'yaml';
+import { dimensionFileSchema, methodologyFileSchema, presetFileSchema, scopeFileSchema, } from './schema.js';
+export class MethodologyError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MethodologyError';
+    }
+}
+/** Package root: the directory holding `methodology/`, both from `src/` and from `dist/`. */
+/** The methodology version a scan uses when `--methodology` is not given. */
+export const CURRENT_METHODOLOGY_VERSION = '1.0';
+export const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+function readYaml(file, schema) {
+    let doc;
+    try {
+        doc = parse(readFileSync(file, 'utf8'));
+    }
+    catch (err) {
+        throw new MethodologyError(`${file}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const result = schema.safeParse(doc);
+    if (!result.success) {
+        const issue = result.error.issues[0];
+        const where = issue && issue.path.length > 0 ? issue.path.join('.') : '(root)';
+        throw new MethodologyError(`${file}: ${where}: ${issue?.message ?? 'invalid'}`);
+    }
+    return result.data;
+}
+function commaList(text) {
+    return text
+        .split(',')
+        .map((entry) => entry.trim().replace(/^node:/, ''))
+        .filter((entry) => entry !== '');
+}
+function parseD3Lists(def, file = 'dimension 3') {
+    const lists = { forbiddenImports: { typescript_javascript: [], python: [] }, infrastructureDirectories: [] };
+    if (!def)
+        return lists;
+    const measure = def.measure ?? {};
+    for (const group of ['typescript_javascript', 'python']) {
+        const match = /Forbidden imports:\s*(.+?)\.(?:\s|$)/s.exec(measure[group] ?? '');
+        if (!match?.[1])
+            throw new MethodologyError(`${file}: parameter ${def.id} measure.${group} has no "Forbidden imports:" list`);
+        lists.forbiddenImports[group] = [...new Set(commaList(match[1]))];
+    }
+    const infra = (measure.infrastructure_directories ?? '').replace(/\.\s*$/, '');
+    lists.infrastructureDirectories = commaList(infra);
+    if (lists.infrastructureDirectories.length === 0) {
+        throw new MethodologyError(`${file}: parameter ${def.id} measure.infrastructure_directories is empty`);
+    }
+    return lists;
+}
+function words(text) {
+    return text
+        .replace(/\s+/g, ' ')
+        .replace(/,?\s+(?:and|or)\s+/g, ', ')
+        .split(/[,;]/)
+        .map((entry) => entry.trim())
+        .filter((entry) => entry !== '');
+}
+function parseD6Lists(scriptResolution, defs, defs6x, file = 'dimension 6') {
+    const text = (scriptResolution ?? '').replace(/\s+/g, ' ');
+    const pick = (re, what) => {
+        const match = re.exec(text);
+        if (!match?.[1])
+            throw new MethodologyError(`${file}: script_resolution has no ${what} list`);
+        return words(match[1]);
+    };
+    const typecheckers = pick(/typecheckers (.+?);/, 'typecheckers');
+    const linters = pick(/linters (.+?);/, 'linters');
+    const testRunners = pick(/test runners (.+?)\. The prefixes/, 'test runners');
+    const prefixes = pick(/The prefixes (.+?) are removed/, 'prefixes');
+    const env = defs?.scoring.method === 'mean_of_components' ? defs.scoring.components.find((c) => c.key === 'env_documented') : undefined;
+    const runtime = defs?.scoring.method === 'mean_of_components' ? defs.scoring.components.find((c) => c.key === 'runtime_pinned') : undefined;
+    const envMeasure = (env?.measure ?? '').replace(/\s+/g, ' ');
+    const examples = /Example files: (.+?)\. Reads:/.exec(envMeasure)?.[1];
+    const excluded = /Excluded names: (.+?), and names starting with (.+?)\.?$/.exec(envMeasure);
+    if (!examples || !excluded?.[1] || !excluded[2])
+        throw new MethodologyError(`${file}: parameter 6.5 env_documented measure has no example files or excluded names`);
+    const pins = /^Any of (.+?)\.?$/.exec((runtime?.measure ?? '').replace(/\s+/g, ' '))?.[1];
+    if (!pins)
+        throw new MethodologyError(`${file}: parameter 6.5 runtime_pinned measure has no file list`);
+    const docMeasure = (defs6x?.measure?.all_languages ?? '').replace(/\s+/g, ' ');
+    const managers = /starts with a package manager \((.+?)\)/.exec(docMeasure)?.[1];
+    if (!managers)
+        throw new MethodologyError(`${file}: parameter 6.6 measure has no package manager list`);
+    return {
+        typecheckers,
+        linters,
+        testRunners,
+        prefixes,
+        envExcludedNames: words(excluded[1]),
+        envExcludedPrefixes: words(excluded[2]),
+        envExampleFiles: words(examples),
+        runtimePinFiles: words(pins),
+        docPackageManagers: words(managers),
+    };
+}
+export function loadMethodology(version, rootDir = packageRoot) {
+    if (!/^\d+\.\d+$/.test(version)) {
+        throw new MethodologyError(`Unknown methodology version "${version}"`);
+    }
+    const dir = path.join(rootDir, 'methodology', `v${version}`);
+    if (!existsSync(dir)) {
+        throw new MethodologyError(`Unknown methodology version "${version}" (no ${dir})`);
+    }
+    const main = readYaml(path.join(dir, 'methodology.yaml'), methodologyFileSchema);
+    if (main.version !== version) {
+        throw new MethodologyError(`${path.join(dir, 'methodology.yaml')}: version "${main.version}" does not match directory v${version}`);
+    }
+    const scope = readYaml(path.join(dir, 'scope.yaml'), scopeFileSchema);
+    const presets = {};
+    const dimensions = main.dimensions.map((entry) => {
+        const file = path.join(dir, entry.file);
+        const parsed = readYaml(file, dimensionFileSchema);
+        if (parsed.dimension.id !== entry.id || parsed.dimension.key !== entry.key) {
+            throw new MethodologyError(`${file}: dimension id/key do not match methodology.yaml`);
+        }
+        const total = parsed.parameters.reduce((sum, p) => sum + p.weight, 0);
+        if (Math.abs(total - 100) > 1e-9) {
+            throw new MethodologyError(`${file}: parameter weights sum to ${total}, expected 100`);
+        }
+        for (const presetFile of parsed.presets?.files ?? []) {
+            const loaded = readYaml(path.join(dir, presetFile), presetFileSchema);
+            presets[loaded.preset.key] = {
+                preset: loaded.preset.key,
+                name: loaded.preset.name,
+                ...(loaded.conventions === undefined ? {} : { conventions: loaded.conventions }),
+                languages: loaded.preset.languages,
+                layers: loaded.layers,
+                modules: loaded.modules,
+                rules: loaded.rules,
+            };
+        }
+        return {
+            id: parsed.dimension.id,
+            key: parsed.dimension.key,
+            name: parsed.dimension.name,
+            ...(parsed.script_resolution === undefined ? {} : { scriptResolution: parsed.script_resolution }),
+            parameters: parsed.parameters,
+        };
+    });
+    const d3Def = dimensions.find((d) => d.id === 3)?.parameters.find((p) => p.id === '3.5');
+    const d6Dim = dimensions.find((d) => d.id === 6);
+    return {
+        version,
+        presets,
+        d3: parseD3Lists(d3Def, path.join(dir, 'dimensions')),
+        d6: parseD6Lists(d6Dim?.scriptResolution, d6Dim?.parameters.find((p) => p.id === '6.5'), d6Dim?.parameters.find((p) => p.id === '6.6'), path.join(dir, 'dimensions')),
+        dimensions,
+        capMargin: main.aggregation.dimension_to_health.cap_margin,
+        bands: main.bands,
+        scope,
+        execution: main.execution,
+    };
+}