@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/mutation/semantic-impact-scan.js

@@ -0,0 +1,434 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateSemanticMutationImpact = estimateSemanticMutationImpact;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_perf_hooks_1 = require("node:perf_hooks");
+const core_1 = require("../rg-wrapper/core");
+const SOURCE_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"]);
+const RESOLVABLE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs", ".json"];
+const MAX_CANDIDATES = 64;
+const MAX_MATCHED_FILES = 2_000;
+const MAX_FILE_BYTES = 1_000_000;
+const EXCLUDED_RG_GLOBS = [
+    "!node_modules/**",
+    "!dist/**",
+    "!dist-stable/**",
+    "!out/**",
+    "!build/**",
+    "!coverage/**",
+    "!.git/**",
+    "!.tmp/**"
+];
+function estimateSemanticMutationImpact(input) {
+    const startedAt = node_perf_hooks_1.performance.now();
+    const cwd = path.resolve(input.cwd);
+    const sourceFiles = Array.from(new Set(input.sourceFiles.map((file) => path.resolve(cwd, file)).filter(Boolean)));
+    const existingSources = sourceFiles.filter((file) => fs.existsSync(file));
+    if (existingSources.length === 0) {
+        return emptyImpact(sourceFiles.length, 0, input.entities.length, node_perf_hooks_1.performance.now() - startedAt, "missing-source-files");
+    }
+    const aliasStartedAt = node_perf_hooks_1.performance.now();
+    const candidates = buildCandidateSpecifiers(cwd, existingSources);
+    const rgPatterns = buildRgSearchPatterns(existingSources, candidates);
+    const aliasBuildMs = elapsed(aliasStartedAt);
+    if (rgPatterns.size === 0) {
+        return emptyImpact(sourceFiles.length, existingSources.length, input.entities.length, node_perf_hooks_1.performance.now() - startedAt, "no-candidates", aliasBuildMs);
+    }
+    const limitedPatterns = [...rgPatterns].slice(0, MAX_CANDIDATES);
+    const rgStartedAt = node_perf_hooks_1.performance.now();
+    const rgModel = (0, core_1.runBrgOptimizedModel)({
+        cwd,
+        args: [
+            "--fixed-strings",
+            "--glob",
+            "*.ts",
+            "--glob",
+            "*.tsx",
+            "--glob",
+            "*.mts",
+            "--glob",
+            "*.cts",
+            ...EXCLUDED_RG_GLOBS.flatMap((glob) => ["--glob", glob]),
+            ...limitedPatterns.flatMap((candidate) => ["-e", candidate]),
+            "."
+        ]
+    });
+    const rgMs = elapsed(rgStartedAt);
+    if (rgModel.exitCode !== 0 && rgModel.exitCode !== 1) {
+        return emptyImpact(sourceFiles.length, existingSources.length, input.entities.length, node_perf_hooks_1.performance.now() - startedAt, "rg-failed", aliasBuildMs, rgMs);
+    }
+    const matchedFiles = new Set(rgModel.files.map((file) => path.resolve(cwd, file.path)));
+    let truncated = rgPatterns.size > MAX_CANDIDATES || matchedFiles.size > MAX_MATCHED_FILES;
+    const parseStartedAt = node_perf_hooks_1.performance.now();
+    const impactFiles = new Set();
+    const counters = {
+        importStatementCount: 0,
+        exportStatementCount: 0,
+        matchedNamedSpecifierCount: 0,
+        namespaceImportCount: 0,
+        defaultImportCount: 0,
+        riskyImportCount: 0
+    };
+    const sourceBases = new Set(existingSources.map(normalizeResolvedModuleBase));
+    const entities = new Set(input.entities.filter(Boolean));
+    for (const file of [...matchedFiles].slice(0, MAX_MATCHED_FILES)) {
+        if (sourceBases.has(normalizeResolvedModuleBase(file))) {
+            continue;
+        }
+        const text = readSmallTextFile(file);
+        if (text === null) {
+            continue;
+        }
+        for (const declaration of collectImportExportDeclarations(text)) {
+            if (!declarationMatchesSource(file, declaration.specifier, candidates, sourceBases)) {
+                continue;
+            }
+            impactFiles.add(file);
+            if (declaration.kind === "export") {
+                counters.exportStatementCount += 1;
+            }
+            else {
+                counters.importStatementCount += 1;
+            }
+            const namedMatches = countNamedSpecifierMatches(declaration.clause, entities);
+            counters.matchedNamedSpecifierCount += namedMatches;
+            if (/\*\s+as\s+\w+/.test(declaration.clause)) {
+                counters.namespaceImportCount += 1;
+            }
+            if (declaration.kind === "import" && hasDefaultImport(declaration.clause)) {
+                counters.defaultImportCount += 1;
+            }
+            if (namedMatches === 0 || declaration.kind === "export" || /\*\s+as\s+\w+/.test(declaration.clause)) {
+                counters.riskyImportCount += 1;
+            }
+        }
+    }
+    const parseMatchedFilesMs = elapsed(parseStartedAt);
+    return {
+        sourceFileCount: sourceFiles.length,
+        existingSourceFileCount: existingSources.length,
+        entityCount: entities.size,
+        candidateSpecifierCount: candidates.size,
+        rgPatternCount: rgPatterns.size,
+        rgMatchedFileCount: Math.min(matchedFiles.size, MAX_MATCHED_FILES),
+        matchedFileCount: impactFiles.size,
+        ...counters,
+        truncated,
+        fallbackReason: truncated ? "truncated" : null,
+        timings: {
+            aliasBuildMs,
+            rgMs,
+            parseMatchedFilesMs,
+            totalMs: elapsed(startedAt)
+        }
+    };
+}
+function buildCandidateSpecifiers(cwd, sourceFiles) {
+    const candidates = new Set();
+    const configs = collectTsconfigAliasRules(cwd, sourceFiles);
+    for (const sourceFile of sourceFiles) {
+        addCandidate(candidates, moduleBase(path.relative(cwd, sourceFile)));
+        for (const config of configs) {
+            const baseUrl = path.resolve(path.dirname(config.configPath), config.baseUrl ?? ".");
+            addCandidate(candidates, moduleBase(path.relative(baseUrl, sourceFile)));
+            for (const rule of config.rules) {
+                const candidate = candidateFromPathRule(sourceFile, baseUrl, rule);
+                if (candidate) {
+                    addCandidate(candidates, candidate);
+                }
+            }
+        }
+        for (const packageCandidate of packageSelfNameCandidates(cwd, sourceFile)) {
+            addCandidate(candidates, packageCandidate);
+        }
+    }
+    return candidates;
+}
+function buildRgSearchPatterns(sourceFiles, candidates) {
+    const patterns = new Set(candidates);
+    for (const sourceFile of sourceFiles) {
+        const baseName = path.basename(moduleBase(sourceFile));
+        if (baseName) {
+            patterns.add(baseName);
+        }
+        if (path.basename(sourceFile).startsWith("index.")) {
+            const parentName = path.basename(path.dirname(sourceFile));
+            if (parentName) {
+                patterns.add(parentName);
+            }
+        }
+    }
+    return patterns;
+}
+function collectTsconfigAliasRules(cwd, sourceFiles) {
+    const configs = new Map();
+    for (const sourceFile of sourceFiles) {
+        for (const configPath of findTsconfigsUpwards(path.dirname(sourceFile), cwd)) {
+            if (configs.has(configPath)) {
+                continue;
+            }
+            const parsed = readJsonFile(configPath);
+            const compilerOptions = isObject(parsed?.compilerOptions) ? parsed.compilerOptions : {};
+            const paths = isObject(compilerOptions.paths) ? compilerOptions.paths : {};
+            const rules = [];
+            for (const [key, value] of Object.entries(paths)) {
+                const targets = Array.isArray(value) ? value : [];
+                for (const target of targets) {
+                    if (typeof key === "string" && typeof target === "string") {
+                        rules.push({ key, target });
+                    }
+                }
+            }
+            configs.set(configPath, {
+                configPath,
+                baseUrl: typeof compilerOptions.baseUrl === "string" ? compilerOptions.baseUrl : undefined,
+                rules
+            });
+        }
+    }
+    return [...configs.values()];
+}
+function findTsconfigsUpwards(startDir, stopDir) {
+    const configs = [];
+    let dir = path.resolve(startDir);
+    const stop = path.resolve(stopDir);
+    while (dir.startsWith(stop)) {
+        const configPath = path.join(dir, "tsconfig.json");
+        if (fs.existsSync(configPath)) {
+            configs.push(configPath);
+        }
+        if (dir === stop) {
+            break;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            break;
+        }
+        dir = parent;
+    }
+    return configs;
+}
+function candidateFromPathRule(sourceFile, baseUrl, rule) {
+    const keyParts = splitWildcard(rule.key);
+    const targetParts = splitWildcard(rule.target);
+    const sourceBase = normalizePathForSpecifier(stripKnownExtension(path.resolve(sourceFile)));
+    const targetPrefix = normalizePathForSpecifier(stripKnownExtension(path.resolve(baseUrl, targetParts.prefix)));
+    const targetSuffix = normalizePathForSpecifier(stripKnownExtension(targetParts.suffix));
+    if (targetParts.hasWildcard) {
+        if (!sourceBase.startsWith(targetPrefix)) {
+            return null;
+        }
+        let rest = sourceBase.slice(targetPrefix.length);
+        if (rest.startsWith("/")) {
+            rest = rest.slice(1);
+        }
+        if (targetSuffix && rest.endsWith(targetSuffix)) {
+            rest = rest.slice(0, -targetSuffix.length);
+        }
+        return `${keyParts.prefix}${rest}${keyParts.suffix}`;
+    }
+    const exactTarget = normalizePathForSpecifier(stripKnownExtension(path.resolve(baseUrl, rule.target)));
+    if (sourceBase === exactTarget) {
+        return rule.key;
+    }
+    return null;
+}
+function splitWildcard(value) {
+    const index = value.indexOf("*");
+    if (index === -1) {
+        return { prefix: value, suffix: "", hasWildcard: false };
+    }
+    return {
+        prefix: value.slice(0, index),
+        suffix: value.slice(index + 1),
+        hasWildcard: true
+    };
+}
+function packageSelfNameCandidates(cwd, sourceFile) {
+    const packagePath = findPackageJson(path.dirname(sourceFile), cwd);
+    if (!packagePath) {
+        return [];
+    }
+    const parsed = readJsonFile(packagePath);
+    const name = typeof parsed?.name === "string" ? parsed.name : "";
+    if (!name) {
+        return [];
+    }
+    const packageRoot = path.dirname(packagePath);
+    const relative = moduleBase(path.relative(packageRoot, sourceFile));
+    return relative ? [`${name}/${relative}`] : [name];
+}
+function findPackageJson(startDir, stopDir) {
+    let dir = path.resolve(startDir);
+    const stop = path.resolve(stopDir);
+    while (dir.startsWith(stop)) {
+        const packagePath = path.join(dir, "package.json");
+        if (fs.existsSync(packagePath)) {
+            return packagePath;
+        }
+        if (dir === stop) {
+            break;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            break;
+        }
+        dir = parent;
+    }
+    return null;
+}
+function collectImportExportDeclarations(text) {
+    const declarations = [];
+    collectDeclarations(declarations, text, /\bimport\s+(?!\()([\s\S]*?)\s+from\s*["']([^"']+)["']/g, "import");
+    collectDeclarations(declarations, text, /\bexport\s+(?:type\s+)?([\s\S]*?)\s+from\s*["']([^"']+)["']/g, "export");
+    return declarations;
+}
+function collectDeclarations(declarations, text, pattern, kind) {
+    for (const match of text.matchAll(pattern)) {
+        const clause = match[1] ?? "";
+        const specifier = match[2] ?? "";
+        if (specifier) {
+            declarations.push({ kind, clause, specifier });
+        }
+    }
+}
+function declarationMatchesSource(importerFile, specifier, candidates, sourceBases) {
+    if (candidates.has(specifier)) {
+        return true;
+    }
+    if (!specifier.startsWith(".")) {
+        return false;
+    }
+    const resolved = normalizeResolvedModuleBase(path.resolve(path.dirname(importerFile), specifier));
+    return sourceBases.has(resolved);
+}
+function countNamedSpecifierMatches(clause, entities) {
+    const named = /\{([\s\S]*?)\}/.exec(clause)?.[1];
+    if (!named) {
+        return 0;
+    }
+    let count = 0;
+    for (const rawPart of named.split(",")) {
+        const imported = rawPart
+            .trim()
+            .replace(/^type\s+/, "")
+            .split(/\s+as\s+/)[0]
+            ?.trim();
+        if (imported && entities.has(imported)) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function hasDefaultImport(clause) {
+    const beforeNamed = clause.split("{")[0]?.trim() ?? "";
+    return beforeNamed.length > 0 && !beforeNamed.startsWith("*") && beforeNamed !== "type";
+}
+function moduleBase(filePath) {
+    return normalizePathForSpecifier(stripKnownExtension(filePath)).replace(/\/index$/, "");
+}
+function stripKnownExtension(filePath) {
+    for (const extension of RESOLVABLE_EXTENSIONS) {
+        if (filePath.endsWith(extension)) {
+            return filePath.slice(0, -extension.length);
+        }
+    }
+    return filePath;
+}
+function addCandidate(candidates, value) {
+    const normalized = normalizePathForSpecifier(value).replace(/^\.\//, "");
+    if (normalized && !normalized.startsWith("..") && !path.isAbsolute(normalized)) {
+        candidates.add(normalized);
+    }
+}
+function normalizeResolvedModuleBase(filePath) {
+    return normalizePathForSpecifier(moduleBase(path.resolve(filePath))).toLowerCase();
+}
+function normalizePathForSpecifier(value) {
+    return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function readSmallTextFile(file) {
+    try {
+        const stat = fs.statSync(file);
+        if (stat.size > MAX_FILE_BYTES || !SOURCE_EXTENSIONS.has(path.extname(file))) {
+            return null;
+        }
+        return fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function readJsonFile(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function emptyImpact(sourceFileCount, existingSourceFileCount, entityCount, totalMs, fallbackReason, aliasBuildMs = 0, rgMs = 0) {
+    return {
+        sourceFileCount,
+        existingSourceFileCount,
+        entityCount,
+        candidateSpecifierCount: 0,
+        rgPatternCount: 0,
+        rgMatchedFileCount: 0,
+        matchedFileCount: 0,
+        importStatementCount: 0,
+        exportStatementCount: 0,
+        matchedNamedSpecifierCount: 0,
+        namespaceImportCount: 0,
+        defaultImportCount: 0,
+        riskyImportCount: 0,
+        truncated: false,
+        fallbackReason,
+        timings: {
+            aliasBuildMs,
+            rgMs,
+            parseMatchedFilesMs: 0,
+            totalMs: Math.round(totalMs)
+        }
+    };
+}
+function elapsed(startedAt) {
+    return Math.round(node_perf_hooks_1.performance.now() - startedAt);
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/mutation/semantic-model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/mutation/semantic-move-best-effort-planner.js

@@ -0,0 +1,209 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planSemanticMoveBestEffort = planSemanticMoveBestEffort;
+exports.isSemanticMoveSplittableFailure = isSemanticMoveSplittableFailure;
+const path = __importStar(require("node:path"));
+const file_mutation_discovery_1 = require("./file-mutation-discovery");
+const semantic_move_standalone_planner_1 = require("./semantic-move-standalone-planner");
+const SPLITTABLE_CODES = new Set([
+    "SEMANTIC_MOVE_PROVIDER_UNSUPPORTED",
+    "SEMANTIC_MOVE_CHANGES_OVERLAP",
+    "SEMANTIC_MOVE_ENTITY_NOT_FOUND",
+    "SEMANTIC_MOVE_ENTITY_AMBIGUOUS",
+    "SEMANTIC_MOVE_ENTITIES_NOT_CONTIGUOUS"
+]);
+const DEFAULT_MAX_ATTEMPTS = 31;
+const DEFAULT_MAX_DEPTH = 6;
+const DEFAULT_MAX_ENTITIES = 64;
+async function planSemanticMoveBestEffort(input, dependencies = {
+    discover: file_mutation_discovery_1.discoverFileMutationConsumers,
+    plan: semantic_move_standalone_planner_1.planStandaloneSemanticMove
+}) {
+    const root = path.resolve(input.workspaceRoot);
+    const sourceFile = path.resolve(root, input.sourceFile);
+    const dispositions = input.entities.map((entity, index) => ({
+        index,
+        id: entity.id ?? `entity-${index + 1}`,
+        name: entity.name,
+        status: "unprocessed",
+        code: "SEMANTIC_MOVE_NOT_ATTEMPTED"
+    }));
+    const attempts = [];
+    const planningEvidence = [];
+    const maxAttempts = boundedLimit(input.limits?.maxAttempts, DEFAULT_MAX_ATTEMPTS);
+    const maxDepth = boundedLimit(input.limits?.maxDepth, DEFAULT_MAX_DEPTH);
+    const maxEntities = boundedLimit(input.limits?.maxEntities, DEFAULT_MAX_ENTITIES);
+    if (input.entities.length === 0 || input.entities.length > maxEntities) {
+        const code = input.entities.length === 0
+            ? "SEMANTIC_MOVE_ENTITY_REQUIRED"
+            : "SEMANTIC_MOVE_SCHEDULER_ENTITY_LIMIT";
+        return result(false, false, code, "", attempts, dispositions.map((item) => ({ ...item, code })), []);
+    }
+    let discovery;
+    try {
+        discovery = input.discovery ?? dependencies.discover({ workspaceRoot: root, sourceFiles: [sourceFile] });
+    }
+    catch {
+        return terminalResult("SEMANTIC_MOVE_DISCOVERY_FAILED", [], attempts, dispositions, "", []);
+    }
+    const state = { terminal: null };
+    let budgetExhausted = false;
+    const markUnprocessed = (entityIndexes) => {
+        budgetExhausted = true;
+        for (const index of entityIndexes) {
+            dispositions[index] = {
+                ...dispositions[index],
+                status: "unprocessed",
+                code: "SEMANTIC_MOVE_SPLIT_BUDGET_EXHAUSTED"
+            };
+        }
+    };
+    const visit = async (entityIndexes, depth) => {
+        if (state.terminal)
+            return;
+        if (attempts.length >= maxAttempts || depth > maxDepth) {
+            markUnprocessed(entityIndexes);
+            return;
+        }
+        const attemptIndex = attempts.length;
+        let plan;
+        try {
+            plan = await dependencies.plan({
+                ...input,
+                workspaceRoot: root,
+                sourceFile,
+                entities: entityIndexes.map((index) => input.entities[index]),
+                discovery,
+                ...(input.metrics ? { metrics: input.metrics } : {})
+            });
+        }
+        catch {
+            state.terminal = { code: "SEMANTIC_MOVE_SCHEDULER_PLANNER_FAILED", entityIndexes };
+            return;
+        }
+        const allWorkersReclaimed = plan.configWorkers.every((worker) => worker.terminationConfirmed);
+        const splittable = isSemanticMoveSplittableFailure(plan.code);
+        attempts.push({
+            index: attemptIndex,
+            depth,
+            entityIndexes: [...entityIndexes],
+            complete: plan.complete,
+            code: plan.code,
+            ...(plan.error ? { error: plan.error } : {}),
+            splittable,
+            workerCount: plan.configWorkers.length,
+            allWorkersReclaimed
+        });
+        if (!allWorkersReclaimed) {
+            state.terminal = { code: "SEMANTIC_MOVE_WORKER_TERMINATION_FAILED", entityIndexes };
+            return;
+        }
+        if (plan.complete) {
+            const planIndex = planningEvidence.length;
+            planningEvidence.push(plan);
+            for (const index of entityIndexes) {
+                dispositions[index] = {
+                    ...dispositions[index],
+                    status: "succeeded",
+                    code: plan.code,
+                    attemptIndex,
+                    planIndex
+                };
+            }
+            return;
+        }
+        if (!splittable) {
+            state.terminal = { code: plan.code, entityIndexes };
+            return;
+        }
+        if (entityIndexes.length === 1) {
+            const index = entityIndexes[0];
+            dispositions[index] = {
+                ...dispositions[index],
+                status: "unsupported",
+                code: plan.code,
+                attemptIndex
+            };
+            return;
+        }
+        if (attempts.length >= maxAttempts || depth >= maxDepth) {
+            markUnprocessed(entityIndexes);
+            return;
+        }
+        const midpoint = Math.floor(entityIndexes.length / 2);
+        await visit(entityIndexes.slice(0, midpoint), depth + 1);
+        await visit(entityIndexes.slice(midpoint), depth + 1);
+    };
+    await visit(input.entities.map((_, index) => index), 0);
+    if (state.terminal) {
+        return terminalResult(state.terminal.code, state.terminal.entityIndexes, attempts, dispositions, discovery.workspaceFingerprint, planningEvidence);
+    }
+    const unsupported = dispositions.some((item) => item.status === "unsupported");
+    const complete = dispositions.every((item) => item.status === "succeeded");
+    const code = budgetExhausted
+        ? "SEMANTIC_MOVE_SPLIT_BUDGET_EXHAUSTED"
+        : unsupported
+            ? "SEMANTIC_MOVE_BEST_EFFORT_PARTIAL"
+            : "SEMANTIC_MOVE_BEST_EFFORT_COMPLETE";
+    return result(complete, false, code, discovery.workspaceFingerprint, attempts, dispositions, planningEvidence);
+}
+function isSemanticMoveSplittableFailure(code) {
+    return SPLITTABLE_CODES.has(code);
+}
+function terminalResult(code, failedIndexes, attempts, current, discoveryFingerprint, planningEvidence) {
+    const failed = new Set(failedIndexes);
+    const dispositions = current.map((item) => ({
+        ...item,
+        status: (failed.size === 0 || failed.has(item.index) ? "failed" : "unprocessed"),
+        code
+    }));
+    return result(false, true, code, discoveryFingerprint, attempts, dispositions, planningEvidence.length > 0 ? [] : planningEvidence);
+}
+function result(complete, terminal, code, discoveryFingerprint, attempts, dispositions, planningEvidence) {
+    return {
+        complete,
+        terminal,
+        readyForApply: false,
+        code,
+        discoveryFingerprint,
+        attempts,
+        dispositions,
+        planningEvidence
+    };
+}
+function boundedLimit(value, fallback) {
+    return Number.isSafeInteger(value) && value !== undefined && value > 0 ? value : fallback;
+}