prodex 2.0.0 → 2.1.0

package/dist/cli/report-command.js

@@ -13,39 +13,65 @@ function reportCommandResult(result) {
         console.error(`Error: ${error}`);
     if (result.message)
         console.log(result.message);
-    if (result.profiles)
-        reportProfiles(result.profiles);
+    if (result.scopes)
+        reportScopes(result.scopes);
     if (result.migration)
         reportMigration(result.migration);
-    for (const run of result.runs)
-        reportRun(run);
+    reportRuns(result.runs);
 }
-function reportRun(run) {
-    const label = run.profile ? ` [${run.profile}]` : "";
+function reportRuns(runs) {
+    for (const run of runs) {
+        reportRunWarningsAndErrors(run);
+        if (run.plannedCommands && run.plannedCommands.length > 0) {
+            console.log(`[dry-run] Planned command attachments to run in sequence:`);
+            for (const cmd of run.plannedCommands) {
+                console.log(`  - ${cmd}`);
+            }
+        }
+    }
+    const reportableRuns = runs.filter((run) => run.ok || run.outputPath);
+    if (!reportableRuns.length)
+        return;
+    const rows = reportableRuns.map((run) => {
+        const sizeMb = run.outputSizeBytes !== undefined ? (run.outputSizeBytes / (1024 * 1024)).toFixed(2) : "0.00";
+        return {
+            icon: run.ok ? "✓" : "✗",
+            label: formatRunLabel(run),
+            mode: run.mode,
+            files: `${run.files.length} files`,
+            size: `${sizeMb} MB`,
+            output: run.outputPath ? formatPath(run.outputPath, run.root) : "dry-run",
+        };
+    });
+    const labelWidth = maxWidth(rows.map((row) => row.label));
+    const modeWidth = maxWidth(rows.map((row) => row.mode));
+    const filesWidth = maxWidth(rows.map((row) => row.files));
+    const sizeWidth = maxWidth(rows.map((row) => row.size));
+    for (const row of rows) {
+        console.log(`${row.icon} ${row.label.padEnd(labelWidth)}  ${row.mode.padEnd(modeWidth)}  ${row.files.padStart(filesWidth)}  ${row.size.padStart(sizeWidth)}  ${row.output}`);
+    }
+}
+function reportRunWarningsAndErrors(run) {
+    const label = run.scopeKey ? ` [${run.scopeKey}]` : "";
     for (const warning of run.warnings)
         console.warn(`Warning${label}: ${warning}`);
     for (const error of run.errors)
         console.error(`Error${label}: ${error}`);
-    if (!run.outputPath)
-        return;
-    console.log(`Created${label}: ${formatPath(run.outputPath, run.root)}`);
-    console.log(`Mode${label}: ${formatMode(run)}`);
-    console.log(`Files${label}: ${run.files.length} total`);
 }
 function reportMigration(migration) {
     if (migration.errors.length)
         return;
     if (!migration.needed) {
-        console.log("prodex.json is already using config version 4.");
+        console.log("prodex.json is already using config version 5.");
         return;
     }
     if (migration.written) {
         console.log(`Backed up prodex.json to ${formatPath(migration.backupPath, path_1.default.dirname(migration.path))}`);
-        console.log("Migrated prodex.json to version 4.");
+        console.log("Migrated prodex.json to version 5.");
         return;
     }
     const from = migration.fromVersion ?? "legacy";
-    console.log(`prodex.json can be migrated from version ${from} to version 4.`);
+    console.log(`prodex.json can be migrated from version ${from} to version 5.`);
     if (migration.changes.length) {
         console.log("");
         console.log("Changes:");
@@ -55,14 +81,25 @@ function reportMigration(migration) {
     console.log("");
     console.log("Run `prodex migrate --write` to update prodex.json.");
 }
-function reportProfiles(profiles) {
-    if (!profiles.length) {
-        console.log("No profiles configured.");
+function reportScopes(scopes) {
+    if (!scopes.length) {
+        console.log("No scopes configured.");
         return;
     }
-    console.log("Available profiles:");
-    for (const profile of profiles)
-        console.log(`  ${profile}`);
+    console.log("Available scopes:");
+    for (const scope of scopes)
+        console.log(`  ${scope}`);
+}
+function formatRunLabel(run) {
+    if (run.outputName)
+        return run.outputName;
+    if (run.scopeKey)
+        return run.scopeKey;
+    if (!run.outputPath)
+        return "run";
+    const ext = path_1.default.extname(run.outputPath);
+    const base = path_1.default.basename(run.outputPath, ext);
+    return base.replace(/-trace(?:_\d{6}-\d{4})?$/, "") || "run";
 }
 function formatPath(filePath, root) {
     const absolute = path_1.default.resolve(filePath);
@@ -71,10 +108,6 @@ function formatPath(filePath, root) {
         return (0, path_2.normalizePath)(relative);
     return (0, path_2.normalizePath)(absolute);
 }
-function formatMode(run) {
-    if (run.mode === "include-only")
-        return `include-only (${run.includes.length} include patterns)`;
-    if (run.mode === "mixed")
-        return `trace + includes (${run.entries.length} entries, ${run.includes.length} include patterns)`;
-    return `trace (${run.entries.length} entries)`;
+function maxWidth(values) {
+    return values.reduce((max, value) => Math.max(max, value.length), 0);
 }

package/dist/commands/{run-command.d.ts → git-command.d.ts}

@@ -1,11 +1,11 @@
 import type { ProdexFlags, RunResult } from "../types";
-export interface RunCommandResult {
+export interface GitCommandResult {
     runs: RunResult[];
     warnings: string[];
     errors: string[];
 }
-export declare function runCommand(params: {
+export declare function gitCommand(params: {
     rootArg?: string;
     flags?: Partial<ProdexFlags>;
     cwd?: string;
-}): Promise<RunCommandResult>;
+}): Promise<GitCommandResult>;

package/dist/commands/git-command.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitCommand = gitCommand;
+const shared_runner_1 = require("./shared-runner");
+async function gitCommand(params) {
+    return (0, shared_runner_1.executeCommandWithPlanner)("git", params);
+}

package/dist/commands/grep-command.d.ts

@@ -0,0 +1,11 @@
+import type { ProdexFlags, RunResult } from "../types";
+export interface GrepCommandResult {
+    runs: RunResult[];
+    warnings: string[];
+    errors: string[];
+}
+export declare function grepCommand(params: {
+    rootArg?: string;
+    flags?: Partial<ProdexFlags>;
+    cwd?: string;
+}): Promise<GrepCommandResult>;

package/dist/commands/grep-command.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grepCommand = grepCommand;
+const shared_runner_1 = require("./shared-runner");
+async function grepCommand(params) {
+    return (0, shared_runner_1.executeCommandWithPlanner)("grep", params);
+}

package/dist/commands/pack-command.d.ts

@@ -0,0 +1,11 @@
+import type { ProdexFlags, RunResult } from "../types";
+export interface PackCommandResult {
+    runs: RunResult[];
+    warnings: string[];
+    errors: string[];
+}
+export declare function packCommand(params: {
+    rootArg?: string;
+    flags?: Partial<ProdexFlags>;
+    cwd?: string;
+}): Promise<PackCommandResult>;

package/dist/commands/pack-command.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packCommand = packCommand;
+const shared_runner_1 = require("./shared-runner");
+async function packCommand(params) {
+    return (0, shared_runner_1.executeCommandWithPlanner)("pack", params);
+}

package/dist/commands/scope-command.d.ts

@@ -0,0 +1,12 @@
+import type { ProdexFlags, RunResult } from "../types";
+export interface ScopeCommandResult {
+    runs: RunResult[];
+    warnings: string[];
+    errors: string[];
+    scopes?: string[];
+}
+export declare function scopeCommand(params: {
+    rootArg?: string;
+    flags?: Partial<ProdexFlags>;
+    cwd?: string;
+}): Promise<ScopeCommandResult>;

package/dist/commands/scope-command.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scopeCommand = scopeCommand;
+const shared_runner_1 = require("./shared-runner");
+async function scopeCommand(params) {
+    return (0, shared_runner_1.executeCommandWithPlanner)("scope", params);
+}

package/dist/commands/shared-runner.d.ts

@@ -0,0 +1,12 @@
+import type { ProdexFlags, RunResult } from "../types";
+export interface PlannerCommandResult {
+    runs: RunResult[];
+    warnings: string[];
+    errors: string[];
+    scopes?: string[];
+}
+export declare function executeCommandWithPlanner(kind: "pack" | "trace" | "scope" | "git" | "grep", params: {
+    rootArg?: string;
+    flags?: Partial<ProdexFlags>;
+    cwd?: string;
+}): Promise<PlannerCommandResult>;

package/dist/commands/shared-runner.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCommandWithPlanner = executeCommandWithPlanner;
+const project_context_1 = require("../app/project-context");
+const planner_1 = require("../app/planner");
+const execute_run_1 = require("../app/execute-run");
+async function executeCommandWithPlanner(kind, params) {
+    const project = (0, project_context_1.loadProjectContext)(params.rootArg, params.cwd);
+    const warnings = [...project.warnings];
+    const errors = [...project.errors];
+    if (errors.length)
+        return { runs: [], warnings, errors };
+    const planned = (0, planner_1.createExecutionPlans)({
+        intent: { kind, rootArg: params.rootArg, flags: params.flags ?? {} },
+        userConfig: project.config,
+        root: project.root,
+    });
+    warnings.push(...planned.warnings);
+    errors.push(...planned.errors);
+    if (errors.length)
+        return { runs: [], warnings, errors };
+    if (planned.listScopes) {
+        return { runs: [], warnings, errors, scopes: planned.listScopes };
+    }
+    const runs = [];
+    for (const plan of planned.plans) {
+        runs.push(await (0, execute_run_1.executeRun)(plan));
+    }
+    return { runs, warnings, errors };
+}

package/dist/commands/trace-command.d.ts

@@ -0,0 +1,11 @@
+import type { ProdexFlags, RunResult } from "../types";
+export interface TraceCommandResult {
+    runs: RunResult[];
+    warnings: string[];
+    errors: string[];
+}
+export declare function traceCommand(params: {
+    rootArg?: string;
+    flags?: Partial<ProdexFlags>;
+    cwd?: string;
+}): Promise<TraceCommandResult>;

package/dist/commands/trace-command.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceCommand = traceCommand;
+const shared_runner_1 = require("./shared-runner");
+async function traceCommand(params) {
+    return (0, shared_runner_1.executeCommandWithPlanner)("trace", params);
+}

package/dist/config/default-config.js

@@ -2,22 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_PRODEX_CONFIG = void 0;
 exports.DEFAULT_PRODEX_CONFIG = {
-    version: 4,
+    version: 5,
     $schema: "https://raw.githubusercontent.com/emxhive/prodex/main/schema/prodex.schema.json",
     output: {
         dir: "prodex",
         versioned: true,
         format: "md",
     },
-    entry: [],
-    include: [],
-    exclude: ["node_modules/**", "vendor/**", "dist/**", "@shadcn/**", "**/components/ui/**"],
-    resolve: {
-        aliases: {
-            "@": "resources/js",
-        },
-        maxDepth: 10,
-        maxFiles: 200,
+    exclude: ["node_modules/**", "vendor/**", "dist/**"],
+    aliases: {
+        "@": "resources/js",
     },
-    profiles: {},
+    depth: 2,
+    maxFiles: 200,
+    scopes: {},
 };

package/dist/config/load.d.ts

@@ -6,4 +6,5 @@ export interface LoadConfigResult {
     errors: string[];
     exists: boolean;
 }
+export declare function validateConfig(config: any): string[];
 export declare function loadConfig(root: string): LoadConfigResult;

package/dist/config/load.js

@@ -3,19 +3,277 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = validateConfig;
 exports.loadConfig = loadConfig;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const default_config_1 = require("./default-config");
 const migration_1 = require("./migration");
 const json_1 = require("./json");
+function cloneDefaultConfig() {
+    return JSON.parse(JSON.stringify(default_config_1.DEFAULT_PRODEX_CONFIG));
+}
+function validateConfig(config) {
+    const errors = [];
+    if (!config || typeof config !== "object") {
+        errors.push("Configuration must be a JSON object.");
+        return errors;
+    }
+    if (config.version === undefined) {
+        errors.push("Config 'version' is required.");
+    }
+    else if (config.version !== 5) {
+        errors.push("Config 'version' must equal 5.");
+    }
+    if (config.output !== undefined) {
+        if (typeof config.output !== "object" || config.output === null || Array.isArray(config.output)) {
+            errors.push("Config 'output' must be an object.");
+        }
+        else {
+            const allowedOutputKeys = new Set(["dir", "versioned", "format"]);
+            for (const key of Object.keys(config.output)) {
+                if (!allowedOutputKeys.has(key)) {
+                    errors.push(`Config 'output' contains unknown key '${key}'.`);
+                }
+            }
+            if (config.output.dir !== undefined && typeof config.output.dir !== "string") {
+                errors.push("Config 'output.dir' must be a string.");
+            }
+            if (config.output.versioned !== undefined && typeof config.output.versioned !== "boolean") {
+                errors.push("Config 'output.versioned' must be a boolean.");
+            }
+            if (config.output.format !== undefined && config.output.format !== "md" && config.output.format !== "txt") {
+                errors.push("Config 'output.format' must be either 'md' or 'txt'.");
+            }
+        }
+    }
+    if (config.exclude !== undefined) {
+        if (!Array.isArray(config.exclude)) {
+            errors.push("Config 'exclude' must be an array.");
+        }
+        else {
+            for (let i = 0; i < config.exclude.length; i++) {
+                if (typeof config.exclude[i] !== "string") {
+                    errors.push(`Config 'exclude[${i}]' must be a string.`);
+                }
+            }
+        }
+    }
+    if (config.aliases !== undefined) {
+        if (typeof config.aliases !== "object" || config.aliases === null || Array.isArray(config.aliases)) {
+            errors.push("Config 'aliases' must be an object.");
+        }
+        else {
+            for (const [key, val] of Object.entries(config.aliases)) {
+                if (typeof val !== "string") {
+                    errors.push(`Config 'aliases.${key}' must be a string.`);
+                }
+            }
+        }
+    }
+    if (config.depth !== undefined) {
+        if (typeof config.depth !== "number" || !Number.isInteger(config.depth) || config.depth < 0) {
+            errors.push("Config --depth must be an integer greater than or equal to 0.");
+        }
+    }
+    if (config.maxFiles !== undefined) {
+        if (typeof config.maxFiles !== "number" || !Number.isInteger(config.maxFiles) || config.maxFiles <= 0) {
+            errors.push("Config --max-files must be an integer greater than 0.");
+        }
+    }
+    if (config.scopes !== undefined) {
+        if (typeof config.scopes !== "object" || config.scopes === null || Array.isArray(config.scopes)) {
+            errors.push("Config 'scopes' must be an object.");
+        }
+        else {
+            for (const [scopeKey, scopeVal] of Object.entries(config.scopes)) {
+                const scope = scopeVal;
+                if (typeof scope !== "object" || scope === null || Array.isArray(scope)) {
+                    errors.push(`Config 'scopes.${scopeKey}' must be an object.`);
+                }
+                else {
+                    const allowedScopeKeys = new Set(["name", "entry", "include", "exclude", "grep"]);
+                    for (const key of Object.keys(scope)) {
+                        if (!allowedScopeKeys.has(key)) {
+                            errors.push(`Config 'scopes.${scopeKey}' contains unknown key '${key}'.`);
+                        }
+                    }
+                    if (scope.name !== undefined && typeof scope.name !== "string") {
+                        errors.push(`Config 'scopes.${scopeKey}.name' must be a string.`);
+                    }
+                    if (scope.entry !== undefined) {
+                        if (!Array.isArray(scope.entry)) {
+                            errors.push(`Config 'scopes.${scopeKey}.entry' must be an array.`);
+                        }
+                        else {
+                            for (let i = 0; i < scope.entry.length; i++) {
+                                if (typeof scope.entry[i] !== "string") {
+                                    errors.push(`Config 'scopes.${scopeKey}.entry[${i}]' must be a string.`);
+                                }
+                            }
+                        }
+                    }
+                    if (scope.include !== undefined) {
+                        if (!Array.isArray(scope.include)) {
+                            errors.push(`Config 'scopes.${scopeKey}.include' must be an array.`);
+                        }
+                        else {
+                            for (let i = 0; i < scope.include.length; i++) {
+                                if (typeof scope.include[i] !== "string") {
+                                    errors.push(`Config 'scopes.${scopeKey}.include[${i}]' must be a string.`);
+                                }
+                            }
+                        }
+                    }
+                    if (scope.exclude !== undefined) {
+                        if (!Array.isArray(scope.exclude)) {
+                            errors.push(`Config 'scopes.${scopeKey}.exclude' must be an array.`);
+                        }
+                        else {
+                            for (let i = 0; i < scope.exclude.length; i++) {
+                                if (typeof scope.exclude[i] !== "string") {
+                                    errors.push(`Config 'scopes.${scopeKey}.exclude[${i}]' must be a string.`);
+                                }
+                            }
+                        }
+                    }
+                    if (scope.grep !== undefined) {
+                        if (typeof scope.grep !== "object" || scope.grep === null || Array.isArray(scope.grep)) {
+                            errors.push(`Config 'scopes.${scopeKey}.grep' must be an object.`);
+                        }
+                        else {
+                            const allowedGrepKeys = new Set(["query", "any", "all", "regex", "not", "within", "skip"]);
+                            for (const key of Object.keys(scope.grep)) {
+                                if (!allowedGrepKeys.has(key)) {
+                                    errors.push(`Config 'scopes.${scopeKey}.grep' contains unknown key '${key}'.`);
+                                }
+                            }
+                            if (scope.entry !== undefined) {
+                                errors.push(`Scope "${scopeKey}" cannot define both "entry" and "grep".`);
+                            }
+                            const searchModes = ["query", "any", "all", "regex"];
+                            const definedModes = searchModes.filter(m => scope.grep[m] !== undefined);
+                            if (definedModes.length !== 1) {
+                                errors.push(`Scope "${scopeKey}" grep config must define exactly one of "query", "any", "all", or "regex".`);
+                            }
+                            if (scope.grep.query !== undefined) {
+                                if (typeof scope.grep.query !== "string") {
+                                    errors.push(`Config 'scopes.${scopeKey}.grep.query' must be a string.`);
+                                }
+                                else if (!scope.grep.query.trim()) {
+                                    errors.push(`Config 'scopes.${scopeKey}.grep.query' cannot be blank.`);
+                                }
+                            }
+                            if (scope.grep.regex !== undefined) {
+                                if (typeof scope.grep.regex !== "string") {
+                                    errors.push(`Config 'scopes.${scopeKey}.grep.regex' must be a string.`);
+                                }
+                                else if (!scope.grep.regex.trim()) {
+                                    errors.push(`Config 'scopes.${scopeKey}.grep.regex' cannot be blank.`);
+                                }
+                            }
+                            if (scope.grep.any !== undefined) {
+                                if (!Array.isArray(scope.grep.any)) {
+                                    errors.push(`Config 'scopes.${scopeKey}.grep.any' must be an array.`);
+                                }
+                                else if (scope.grep.any.length === 0) {
+                                    errors.push(`Config 'scopes.${scopeKey}.grep.any' must contain at least one item.`);
+                                }
+                                else {
+                                    for (let i = 0; i < scope.grep.any.length; i++) {
+                                        if (typeof scope.grep.any[i] !== "string") {
+                                            errors.push(`Config 'scopes.${scopeKey}.grep.any[${i}]' must be a string.`);
+                                        }
+                                        else if (!scope.grep.any[i].trim()) {
+                                            errors.push(`Config 'scopes.${scopeKey}.grep.any[${i}]' cannot be blank.`);
+                                        }
+                                    }
+                                }
+                            }
+                            if (scope.grep.all !== undefined) {
+                                if (!Array.isArray(scope.grep.all)) {
+                                    errors.push(`Config 'scopes.${scopeKey}.grep.all' must be an array.`);
+                                }
+                                else if (scope.grep.all.length === 0) {
+                                    errors.push(`Config 'scopes.${scopeKey}.grep.all' must contain at least one item.`);
+                                }
+                                else {
+                                    for (let i = 0; i < scope.grep.all.length; i++) {
+                                        if (typeof scope.grep.all[i] !== "string") {
+                                            errors.push(`Config 'scopes.${scopeKey}.grep.all[${i}]' must be a string.`);
+                                        }
+                                        else if (!scope.grep.all[i].trim()) {
+                                            errors.push(`Config 'scopes.${scopeKey}.grep.all[${i}]' cannot be blank.`);
+                                        }
+                                    }
+                                }
+                            }
+                            if (scope.grep.not !== undefined) {
+                                if (!Array.isArray(scope.grep.not)) {
+                                    errors.push(`Config 'scopes.${scopeKey}.grep.not' must be an array.`);
+                                }
+                                else {
+                                    for (let i = 0; i < scope.grep.not.length; i++) {
+                                        if (typeof scope.grep.not[i] !== "string") {
+                                            errors.push(`Config 'scopes.${scopeKey}.grep.not[${i}]' must be a string.`);
+                                        }
+                                        else if (!scope.grep.not[i].trim()) {
+                                            errors.push(`Config 'scopes.${scopeKey}.grep.not[${i}]' cannot be blank.`);
+                                        }
+                                    }
+                                }
+                            }
+                            if (scope.grep.within !== undefined) {
+                                if (!Array.isArray(scope.grep.within)) {
+                                    errors.push(`Config 'scopes.${scopeKey}.grep.within' must be an array.`);
+                                }
+                                else {
+                                    for (let i = 0; i < scope.grep.within.length; i++) {
+                                        if (typeof scope.grep.within[i] !== "string") {
+                                            errors.push(`Config 'scopes.${scopeKey}.grep.within[${i}]' must be a string.`);
+                                        }
+                                        else if (!scope.grep.within[i].trim()) {
+                                            errors.push(`Config 'scopes.${scopeKey}.grep.within[${i}]' cannot be blank.`);
+                                        }
+                                    }
+                                }
+                            }
+                            if (scope.grep.skip !== undefined) {
+                                if (!Array.isArray(scope.grep.skip)) {
+                                    errors.push(`Config 'scopes.${scopeKey}.grep.skip' must be an array.`);
+                                }
+                                else {
+                                    for (let i = 0; i < scope.grep.skip.length; i++) {
+                                        if (typeof scope.grep.skip[i] !== "string") {
+                                            errors.push(`Config 'scopes.${scopeKey}.grep.skip[${i}]' must be a string.`);
+                                        }
+                                        else if (!scope.grep.skip[i].trim()) {
+                                            errors.push(`Config 'scopes.${scopeKey}.grep.skip[${i}]' cannot be blank.`);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    const allowedRootKeys = new Set(["$schema", "version", "output", "exclude", "aliases", "depth", "maxFiles", "scopes"]);
+    for (const key of Object.keys(config)) {
+        if (!allowedRootKeys.has(key)) {
+            errors.push(`Config contains unknown root key '${key}'.`);
+        }
+    }
+    return errors;
+}
 function loadConfig(root) {
     const configPath = path_1.default.join(root, "prodex.json");
     const warnings = [];
     const errors = [];
     if (!fs_1.default.existsSync(configPath)) {
         return {
-            config: default_config_1.DEFAULT_PRODEX_CONFIG,
+            config: cloneDefaultConfig(),
             path: configPath,
             warnings,
             errors,
@@ -24,11 +282,18 @@ function loadConfig(root) {
     }
     try {
         const parsed = (0, json_1.parseJsonFile)(fs_1.default.readFileSync(configPath, "utf8"));
-        if ((0, migration_1.requiresConfigMigration)(parsed)) {
+        if ((0, migration_1.isFutureConfig)(parsed)) {
+            errors.push(`prodex.json uses future config version ${parsed.version}, but this Prodex version only supports up to config version ${migration_1.REQUIRED_CONFIG_VERSION}.`);
+        }
+        else if ((0, migration_1.requiresConfigMigration)(parsed)) {
             errors.push((0, migration_1.isOutdatedConfig)(parsed) ? (0, migration_1.configVersionError)(parsed.version) : (0, migration_1.legacyConfigShapeError)());
         }
+        else {
+            const validationErrors = validateConfig(parsed);
+            errors.push(...validationErrors);
+        }
         return {
-            config: parsed,
+            config: errors.length > 0 ? cloneDefaultConfig() : parsed,
             path: configPath,
             warnings,
             errors,
@@ -38,7 +303,7 @@ function loadConfig(root) {
     catch (err) {
         errors.push(`Invalid prodex.json: ${err?.message || err}`);
         return {
-            config: default_config_1.DEFAULT_PRODEX_CONFIG,
+            config: cloneDefaultConfig(),
             path: configPath,
             warnings,
             errors,

package/dist/config/migration/detect.d.ts

@@ -1,4 +1,5 @@
-export declare const REQUIRED_CONFIG_VERSION = 4;
+export declare const REQUIRED_CONFIG_VERSION = 5;
 export declare function isOutdatedConfig(config: any): boolean;
+export declare function isFutureConfig(config: any): boolean;
 export declare function requiresConfigMigration(config: any): boolean;
 export declare function looksLikeLegacyConfig(config: any): boolean;

package/dist/config/migration/detect.js

@@ -2,17 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REQUIRED_CONFIG_VERSION = void 0;
 exports.isOutdatedConfig = isOutdatedConfig;
+exports.isFutureConfig = isFutureConfig;
 exports.requiresConfigMigration = requiresConfigMigration;
 exports.looksLikeLegacyConfig = looksLikeLegacyConfig;
-exports.REQUIRED_CONFIG_VERSION = 4;
+exports.REQUIRED_CONFIG_VERSION = 5;
 function isOutdatedConfig(config) {
     return typeof config?.version === "number" && config.version < exports.REQUIRED_CONFIG_VERSION;
 }
+function isFutureConfig(config) {
+    return typeof config?.version === "number" && config.version > exports.REQUIRED_CONFIG_VERSION;
+}
 function requiresConfigMigration(config) {
     return isOutdatedConfig(config) || looksLikeLegacyConfig(config);
 }
 function looksLikeLegacyConfig(config) {
-    return !!(config?.shortcuts ||
+    return !!(config?.profiles ||
+        config?.resolve ||
+        config?.shortcuts ||
+        config?.entry !== undefined ||
+        config?.include !== undefined ||
         config?.entry?.files ||
         config?.resolve?.include ||
         config?.resolve?.exclude ||