dominds 1.3.1 → 1.4.2

package/dist/apps/enabled-apps.js

@@ -3,33 +3,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.materializeAppsResolution = materializeAppsResolution;
 exports.loadEnabledAppsSnapshot = loadEnabledAppsSnapshot;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
+const app_lock_file_1 = require("./app-lock-file");
 const assigned_port_1 = require("./assigned-port");
+const configuration_file_1 = require("./configuration-file");
 const manifest_1 = require("./manifest");
 const package_info_1 = require("./package-info");
 const resolution_file_1 = require("./resolution-file");
 const run_app_json_1 = require("./run-app-json");
-async function fileExists(filePathAbs) {
-    try {
-        await promises_1.default.access(filePathAbs);
-        return true;
-    }
-    catch (err) {
-        const isEnoent = typeof err === 'object' &&
-            err !== null &&
-            'code' in err &&
-            err.code === 'ENOENT';
-        if (isEnoent)
-            return false;
-        throw err;
-    }
+function getRuntimePort(entry) {
+    if (entry.assignedPort !== null)
+        return entry.assignedPort;
+    const defaultPort = entry.installJson.frontend?.defaultPort;
+    return typeof defaultPort === 'number' && defaultPort > 0 ? defaultPort : null;
 }
 async function dirExists(dirPathAbs) {
     try {
-        const st = await promises_1.default.stat(dirPathAbs);
-        return st.isDirectory();
+        const stat = await promises_1.default.stat(dirPathAbs);
+        return stat.isDirectory();
     }
     catch (err) {
         const isEnoent = typeof err === 'object' &&
@@ -41,57 +35,29 @@ async function dirExists(dirPathAbs) {
         throw err;
     }
 }
-async function tryLoadRtwsAppManifestDeps(params) {
-    const filePathAbs = node_path_1.default.resolve(params.rtwsRootAbs, '.minds', 'app.yaml');
-    if (!(await fileExists(filePathAbs)))
-        return [];
-    const loaded = await (0, manifest_1.loadDomindsAppManifest)({
-        packageRootAbs: params.rtwsRootAbs,
-        manifestRelPath: '.minds/app.yaml',
-    });
-    if (loaded.kind === 'error') {
-        throw new Error(`Failed to load rtws app manifest: ${loaded.errorText} (${loaded.filePathAbs})`);
-    }
-    return loaded.manifest.dependencies ?? [];
-}
-function indexOverlayApps(params) {
-    const byId = new Map();
-    const extras = [];
-    for (const e of params.overlayApps) {
-        if (byId.has(e.id)) {
-            // Loud: duplicate IDs means non-deterministic overrides.
-            throw new Error(`Invalid apps resolution overlay: duplicate app id '${e.id}'`);
-        }
-        byId.set(e.id, e);
-        extras.push(e);
-    }
-    return { byId, extras };
-}
 function normalizeStrategy(raw) {
     const order = raw?.order ??
-        resolution_file_1.DEFAULT_APPS_RESOLUTION_STRATEGY.order ??
+        configuration_file_1.DEFAULT_APPS_RESOLUTION_STRATEGY.order ??
         ['local'];
     const localRoots = raw?.localRoots ??
-        resolution_file_1.DEFAULT_APPS_RESOLUTION_STRATEGY.localRoots ?? ['dominds-apps'];
+        configuration_file_1.DEFAULT_APPS_RESOLUTION_STRATEGY.localRoots ?? ['dominds-apps'];
     if (order.length === 0) {
-        throw new Error(`Invalid ${resolution_file_1.APPS_RESOLUTION_REL_PATH}: resolutionStrategy.order must not be empty`);
+        throw new Error(`Invalid ${configuration_file_1.APPS_CONFIGURATION_REL_PATH}: resolutionStrategy.order must not be empty`);
     }
     if (localRoots.length === 0) {
-        throw new Error(`Invalid ${resolution_file_1.APPS_RESOLUTION_REL_PATH}: resolutionStrategy.localRoots must not be empty`);
+        throw new Error(`Invalid ${configuration_file_1.APPS_CONFIGURATION_REL_PATH}: resolutionStrategy.localRoots must not be empty`);
     }
-    const orderSet = new Set(order);
-    if (orderSet.size !== order.length) {
-        throw new Error(`Invalid ${resolution_file_1.APPS_RESOLUTION_REL_PATH}: resolutionStrategy.order has duplicates`);
+    if (new Set(order).size !== order.length) {
+        throw new Error(`Invalid ${configuration_file_1.APPS_CONFIGURATION_REL_PATH}: resolutionStrategy.order has duplicates`);
     }
-    const localRootsSet = new Set(localRoots);
-    if (localRootsSet.size !== localRoots.length) {
-        throw new Error(`Invalid ${resolution_file_1.APPS_RESOLUTION_REL_PATH}: resolutionStrategy.localRoots has duplicates`);
+    if (new Set(localRoots).size !== localRoots.length) {
+        throw new Error(`Invalid ${configuration_file_1.APPS_CONFIGURATION_REL_PATH}: resolutionStrategy.localRoots has duplicates`);
     }
     return { order, localRoots };
 }
 function getResolutionHint(params) {
-    const filePathAbs = node_path_1.default.resolve(params.rtwsRootAbs, resolution_file_1.APPS_RESOLUTION_REL_PATH);
-    const action = params.hasResolutionFile ? 'Edit' : 'Create';
+    const filePathAbs = node_path_1.default.resolve(params.rtwsRootAbs, configuration_file_1.APPS_CONFIGURATION_REL_PATH);
+    const action = params.hasConfigurationFile ? 'Edit' : 'Create';
     return (`${action} ${filePathAbs} to configure 'resolutionStrategy'. ` +
         `Default local root is 'dominds-apps' (rtws-relative) and expects local apps at '<root>/<appId>/'.`);
 }
@@ -104,7 +70,7 @@ async function resolveLocalAppPackageRootAbs(params) {
     }
     return null;
 }
-async function resolveAppManifestDepsFromInstalledApp(params) {
+async function loadManifestDepsFromResolvedApp(params) {
     const pkgInfo = await (0, package_info_1.readPackageInfo)({ packageRootAbs: params.packageRootAbs });
     const loaded = await (0, manifest_1.loadDomindsAppManifest)({
         packageRootAbs: params.packageRootAbs,
@@ -115,17 +81,75 @@ async function resolveAppManifestDepsFromInstalledApp(params) {
     }
     return loaded.manifest.dependencies ?? [];
 }
-async function resolveAppsFromRtwsHierarchy(params) {
-    const issues = [];
-    const pushIssue = (issue) => {
-        issues.push(issue);
+function makeLockedAppHint(entry) {
+    return {
+        packageName: entry.package.name,
+        version: entry.package.version,
     };
+}
+function buildNpxSpec(params) {
+    const packageName = params.lockedHint?.packageName ??
+        params.previousResolutionEntry?.installJson.package.name ??
+        params.appId;
+    const version = params.lockedHint?.version ?? null;
+    return version && version.trim() !== '' ? `${packageName}@${version}` : packageName;
+}
+async function probeAppByStrategy(params) {
+    for (const item of params.strategy.order) {
+        if (item === 'local') {
+            const packageRootAbs = await resolveLocalAppPackageRootAbs({
+                rtwsRootAbs: params.rtwsRootAbs,
+                appId: params.appId,
+                localRoots: params.strategy.localRoots,
+            });
+            if (!packageRootAbs)
+                continue;
+            const installJson = await (0, run_app_json_1.runDomindsAppJsonViaLocalPackage)({ packageRootAbs });
+            if (installJson.appId !== params.appId) {
+                throw new Error(`App id mismatch for local package '${packageRootAbs}': expected '${params.appId}', got '${installJson.appId}'`);
+            }
+            return { source: { kind: 'local', pathAbs: packageRootAbs }, installJson };
+        }
+        if (item === 'npx') {
+            const spec = buildNpxSpec({
+                appId: params.appId,
+                lockedHint: params.lockedHint,
+                previousResolutionEntry: params.previousResolutionEntry,
+            });
+            const installJson = await (0, run_app_json_1.runDomindsAppJsonViaNpx)({
+                spec,
+                cwdAbs: params.rtwsRootAbs,
+            });
+            if (installJson.appId !== params.appId) {
+                throw new Error(`App id mismatch for npx '${spec}': expected '${params.appId}', got '${installJson.appId}'`);
+            }
+            return { source: { kind: 'npx', spec }, installJson };
+        }
+        const exhaustive = item;
+        throw new Error(`Unreachable resolution strategy item: ${String(exhaustive)}`);
+    }
+    return null;
+}
+function makeResolutionEntry(params) {
+    return {
+        id: params.appId,
+        enabled: true,
+        source: params.probe.source,
+        assignedPort: params.cachedAssignedPort,
+        installJson: params.probe.installJson,
+    };
+}
+async function resolveGraph(params) {
+    const issues = [];
     const resolvedById = new Map();
     const depsByAppId = new Map();
+    const fatalApps = new Set();
     const requiredById = new Map();
     const requiredByParents = new Map();
-    const missingRequired = new Set();
-    const fatalApps = new Set();
+    const queue = [];
+    const pushIssue = (issue) => {
+        issues.push(issue);
+    };
     const addRequiredByParent = (depId, parentId) => {
         const existing = requiredByParents.get(depId);
         if (existing) {
@@ -140,24 +164,20 @@ async function resolveAppsFromRtwsHierarchy(params) {
             requiredById.set(id, required);
             return true;
         }
-        if (prev === true)
+        if (prev === true || required === false)
             return false;
-        if (required === true) {
-            requiredById.set(id, true);
-            return true;
-        }
-        return false;
+        requiredById.set(id, true);
+        return true;
     };
-    const queue = [];
     const enqueue = (id, required, parentId) => {
         const changed = mergeRequiredFlag(id, required);
-        if (parentId && required)
+        if (required && parentId)
             addRequiredByParent(id, parentId);
         if (changed)
             queue.push(id);
     };
     try {
-        const rootDeps = await tryLoadRtwsAppManifestDeps({ rtwsRootAbs: params.rtwsRootAbs });
+        const rootDeps = await (0, manifest_1.loadRtwsDeclaredAppDependencies)({ rtwsRootAbs: params.rtwsRootAbs });
         for (const dep of rootDeps) {
             enqueue(dep.id, dep.optional !== true, 'rtws');
         }
@@ -174,111 +194,81 @@ async function resolveAppsFromRtwsHierarchy(params) {
             },
         });
     }
-    // Also treat explicitly enabled overlay apps as roots so their own transitive dependencies
-    // are resolved and missing-required issues can be surfaced.
-    for (const e of params.overlay.extras) {
-        if (!e.userEnabled)
-            continue;
-        enqueue(e.id, true, 'resolution_overlay');
-    }
-    const resolveMissingApp = async (appId) => {
-        for (const item of params.strategy.order) {
-            if (item === 'local') {
-                const packageRootAbs = await resolveLocalAppPackageRootAbs({
-                    rtwsRootAbs: params.rtwsRootAbs,
-                    appId,
-                    localRoots: params.strategy.localRoots,
-                });
-                if (!packageRootAbs) {
-                    continue;
-                }
-                const installJson = await (0, run_app_json_1.runDomindsAppJsonViaLocalPackage)({ packageRootAbs });
-                if (installJson.appId !== appId) {
-                    throw new Error(`App id mismatch for local package '${packageRootAbs}': expected '${appId}', got '${installJson.appId}'`);
-                }
-                const source = { kind: 'local', pathAbs: packageRootAbs };
-                return {
-                    id: appId,
-                    enabled: true,
-                    userEnabled: true,
-                    source,
-                    assignedPort: null,
-                    installJson,
-                };
-            }
-            if (item === 'npx') {
-                throw new Error(`Apps resolution strategy 'npx' is not supported yet for missing app '${appId}'. ` +
-                    `Install it explicitly so it appears in ${resolution_file_1.APPS_RESOLUTION_REL_PATH}.`);
-            }
-            const _exhaustive = item;
-            throw new Error(`Unreachable: unknown resolution strategy item: ${String(_exhaustive)}`);
-        }
-        return null;
-    };
     while (queue.length > 0) {
         const appId = queue.shift();
         if (!appId)
             break;
-        if (resolvedById.has(appId) || missingRequired.has(appId) || fatalApps.has(appId)) {
+        if (resolvedById.has(appId) || fatalApps.has(appId))
             continue;
-        }
         const required = requiredById.get(appId) ?? true;
-        const overlayEntry = params.overlay.byId.get(appId) ?? null;
-        let entry = overlayEntry;
-        if (!entry) {
-            try {
-                entry = await resolveMissingApp(appId);
-            }
-            catch (err) {
-                if (required) {
-                    const roots = params.strategy.localRoots
-                        .map((r) => (node_path_1.default.isAbsolute(r) ? r : node_path_1.default.resolve(params.rtwsRootAbs, r)))
-                        .join(', ');
-                    pushIssue({
-                        kind: 'required_dependency_missing',
-                        severity: 'error',
-                        message: `Required app dependency '${appId}' failed to resolve.`,
-                        detail: {
-                            appId,
-                            searchedLocalRootsAbs: roots,
-                            hint: getResolutionHint({
-                                rtwsRootAbs: params.rtwsRootAbs,
-                                hasResolutionFile: params.hasResolutionFile,
-                            }),
-                            errorText: err instanceof Error ? err.message : String(err),
-                            requiredBy: [...(requiredByParents.get(appId) ?? new Set())].sort(),
-                        },
-                    });
-                    missingRequired.add(appId);
-                }
-                continue;
+        const explicitlyDisabled = params.configurationDisabledApps.has(appId);
+        const previousResolutionEntry = params.previousResolutionById.get(appId) ?? null;
+        let probe = null;
+        try {
+            probe = await probeAppByStrategy({
+                rtwsRootAbs: params.rtwsRootAbs,
+                appId,
+                strategy: params.strategy,
+                lockedHint: params.lockedHintsById.get(appId) ?? null,
+                previousResolutionEntry,
+            });
+        }
+        catch (err) {
+            if (required) {
+                const roots = params.strategy.localRoots
+                    .map((root) => (node_path_1.default.isAbsolute(root) ? root : node_path_1.default.resolve(params.rtwsRootAbs, root)))
+                    .join(', ');
+                pushIssue({
+                    kind: explicitlyDisabled ? 'required_dependency_disabled' : 'required_dependency_missing',
+                    severity: 'error',
+                    message: explicitlyDisabled
+                        ? `Required app dependency '${appId}' is disabled.`
+                        : `Required app dependency '${appId}' failed to resolve.`,
+                    detail: {
+                        appId,
+                        searchedLocalRootsAbs: roots,
+                        hint: getResolutionHint({
+                            rtwsRootAbs: params.rtwsRootAbs,
+                            hasConfigurationFile: params.hasConfigurationFile,
+                        }),
+                        errorText: err instanceof Error ? err.message : String(err),
+                        requiredBy: [...(requiredByParents.get(appId) ?? new Set())].sort(),
+                    },
+                });
             }
+            continue;
         }
-        if (!entry) {
+        if (!probe) {
             if (required) {
                 const roots = params.strategy.localRoots
-                    .map((r) => (node_path_1.default.isAbsolute(r) ? r : node_path_1.default.resolve(params.rtwsRootAbs, r)))
+                    .map((root) => (node_path_1.default.isAbsolute(root) ? root : node_path_1.default.resolve(params.rtwsRootAbs, root)))
                     .join(', ');
                 pushIssue({
-                    kind: 'required_dependency_missing',
+                    kind: explicitlyDisabled ? 'required_dependency_disabled' : 'required_dependency_missing',
                     severity: 'error',
-                    message: `Required app dependency '${appId}' is missing.`,
+                    message: explicitlyDisabled
+                        ? `Required app dependency '${appId}' is disabled.`
+                        : `Required app dependency '${appId}' is missing.`,
                     detail: {
                         appId,
                         searchedLocalRootsAbs: roots,
                         hint: getResolutionHint({
                             rtwsRootAbs: params.rtwsRootAbs,
-                            hasResolutionFile: params.hasResolutionFile,
+                            hasConfigurationFile: params.hasConfigurationFile,
                         }),
                         requiredBy: [...(requiredByParents.get(appId) ?? new Set())].sort(),
                     },
                 });
-                missingRequired.add(appId);
             }
             continue;
         }
+        const entry = makeResolutionEntry({
+            appId,
+            probe,
+            cachedAssignedPort: previousResolutionEntry?.assignedPort ?? null,
+        });
         resolvedById.set(appId, entry);
-        if (!entry.userEnabled) {
+        if (explicitlyDisabled) {
             if (required) {
                 pushIssue({
                     kind: 'required_dependency_disabled',
@@ -286,12 +276,8 @@ async function resolveAppsFromRtwsHierarchy(params) {
                     message: `Required app dependency '${appId}' is disabled.`,
                     detail: {
                         appId,
-                        resolutionFileRelPath: resolution_file_1.APPS_RESOLUTION_REL_PATH,
+                        configurationFileRelPath: configuration_file_1.APPS_CONFIGURATION_REL_PATH,
                         requiredBy: [...(requiredByParents.get(appId) ?? new Set())].sort(),
-                        hint: getResolutionHint({
-                            rtwsRootAbs: params.rtwsRootAbs,
-                            hasResolutionFile: params.hasResolutionFile,
-                        }),
                     },
                 });
             }
@@ -299,7 +285,7 @@ async function resolveAppsFromRtwsHierarchy(params) {
         }
         let manifestDeps;
         try {
-            manifestDeps = await resolveAppManifestDepsFromInstalledApp({
+            manifestDeps = await loadManifestDepsFromResolvedApp({
                 appId,
                 packageRootAbs: entry.installJson.package.rootAbs,
             });
@@ -318,51 +304,48 @@ async function resolveAppsFromRtwsHierarchy(params) {
             fatalApps.add(appId);
             continue;
         }
-        const edges = manifestDeps.map((d) => ({
-            depId: d.id,
-            required: d.optional !== true,
+        const edges = manifestDeps.map((dep) => ({
+            depId: dep.id,
+            required: dep.optional !== true,
         }));
         depsByAppId.set(appId, edges);
-        for (const e of edges) {
-            enqueue(e.depId, e.required, appId);
+        for (const edge of edges) {
+            enqueue(edge.depId, edge.required, appId);
         }
     }
     const effectiveEnabledById = new Map();
-    for (const [id, entry] of resolvedById.entries()) {
-        effectiveEnabledById.set(id, entry.userEnabled && !fatalApps.has(id));
+    for (const [appId] of resolvedById.entries()) {
+        effectiveEnabledById.set(appId, !params.configurationDisabledApps.has(appId) && !fatalApps.has(appId));
     }
-    // Fixed-point disable propagation: if an enabled app has a required dependency that is missing
-    // or effectively disabled, the app becomes effectively disabled.
     let changed = true;
     while (changed) {
         changed = false;
-        for (const [appId, entry] of resolvedById.entries()) {
-            if (!effectiveEnabledById.get(appId))
-                continue;
-            if (!entry.userEnabled)
+        for (const [appId] of resolvedById.entries()) {
+            if (!(effectiveEnabledById.get(appId) ?? false))
                 continue;
             const edges = depsByAppId.get(appId) ?? [];
             for (const edge of edges) {
                 if (!edge.required)
                     continue;
-                const depId = edge.depId;
-                const depResolved = resolvedById.get(depId) ?? null;
-                const depEnabled = depResolved ? (effectiveEnabledById.get(depId) ?? false) : false;
-                const depMissing = !depResolved && missingRequired.has(depId);
-                if (depMissing || !depEnabled) {
+                const depResolved = resolvedById.get(edge.depId) ?? null;
+                const depExplicitlyDisabled = params.configurationDisabledApps.has(edge.depId);
+                const depEffectiveEnabled = depResolved
+                    ? (effectiveEnabledById.get(edge.depId) ?? false)
+                    : false;
+                if (depExplicitlyDisabled || !depResolved || !depEffectiveEnabled) {
                     effectiveEnabledById.set(appId, false);
                     pushIssue({
                         kind: 'app_effectively_disabled_due_to_required_dependency',
                         severity: 'error',
-                        message: `App '${appId}' is effectively disabled due to missing/disabled required dependency '${depId}'.`,
+                        message: `App '${appId}' is effectively disabled due to missing/disabled required dependency '${edge.depId}'.`,
                         detail: {
                             appId,
-                            dependencyId: depId,
-                            dependencyState: depMissing
-                                ? 'missing'
-                                : depResolved && depResolved.userEnabled === false
-                                    ? 'disabled'
-                                    : 'effectively_disabled',
+                            dependencyId: edge.depId,
+                            dependencyState: depExplicitlyDisabled
+                                ? 'disabled'
+                                : depResolved
+                                    ? 'effectively_disabled'
+                                    : 'missing',
                         },
                     });
                     changed = true;
@@ -371,25 +354,22 @@ async function resolveAppsFromRtwsHierarchy(params) {
             }
         }
     }
-    const assignedPortById = new Map();
-    const resolvedEntriesForPort = [...resolvedById.values()];
+    const resolvedEntriesForPorts = [...resolvedById.values()];
     for (const [appId, entry] of resolvedById.entries()) {
-        if (!effectiveEnabledById.get(appId))
+        if (!(effectiveEnabledById.get(appId) ?? false))
             continue;
         const assigned = await (0, assigned_port_1.resolveStableAssignedPortWithReason)({
             appId,
             installJson: entry.installJson,
-            existingApps: resolvedEntriesForPort,
+            existingApps: resolvedEntriesForPorts,
             existingAssignedPort: entry.assignedPort,
         });
-        assignedPortById.set(appId, assigned.assignedPort);
         if (assigned.assignedPort !== entry.assignedPort) {
             const nextEntry = { ...entry, assignedPort: assigned.assignedPort };
             resolvedById.set(appId, nextEntry);
-            const idx = resolvedEntriesForPort.findIndex((a) => a.id === appId);
-            if (idx >= 0) {
-                resolvedEntriesForPort[idx] = nextEntry;
-            }
+            const idx = resolvedEntriesForPorts.findIndex((item) => item.id === appId);
+            if (idx >= 0)
+                resolvedEntriesForPorts[idx] = nextEntry;
         }
         if (assigned.reason === 'reassigned_from_existing_conflict' ||
             assigned.reason === 'reassigned_from_existing_unbindable') {
@@ -407,78 +387,63 @@ async function resolveAppsFromRtwsHierarchy(params) {
             });
         }
     }
-    const out = [];
+    const apps = [];
     for (const [appId, entry] of resolvedById.entries()) {
-        if (!effectiveEnabledById.get(appId))
-            continue;
-        out.push(entry.enabled ? entry : { ...entry, enabled: true });
-    }
-    return { apps: out, issues, effectiveEnabledById, assignedPortById };
-}
-async function loadAppsResolutionOverlay(params) {
-    const filePathAbs = node_path_1.default.resolve(params.rtwsRootAbs, resolution_file_1.APPS_RESOLUTION_REL_PATH);
-    const hasResolutionFile = await fileExists(filePathAbs);
-    if (!hasResolutionFile) {
-        const emptyFile = { schemaVersion: 1, apps: [] };
-        return {
-            overlay: indexOverlayApps({ overlayApps: [] }),
-            resolutionFile: emptyFile,
-            strategy: normalizeStrategy(undefined),
-            hasResolutionFile,
-        };
-    }
-    const loaded = await (0, resolution_file_1.loadAppsResolutionFile)({ rtwsRootAbs: params.rtwsRootAbs });
-    if (loaded.kind === 'error') {
-        throw new Error(`Failed to load apps resolution file overlay: ${loaded.errorText} (${loaded.filePathAbs})`);
+        apps.push({ ...entry, enabled: effectiveEnabledById.get(appId) ?? false });
     }
     return {
-        overlay: indexOverlayApps({ overlayApps: loaded.file.apps }),
-        resolutionFile: loaded.file,
-        strategy: normalizeStrategy(loaded.file.resolutionStrategy),
-        hasResolutionFile,
+        resolutionFile: { schemaVersion: 1, apps },
+        issues,
     };
 }
-async function loadEffectiveAppsResolution(params) {
-    const loaded = await loadAppsResolutionOverlay({ rtwsRootAbs: params.rtwsRootAbs });
-    const resolved = await resolveAppsFromRtwsHierarchy({
+async function materializeAppsResolution(params) {
+    const loadedConfig = await (0, configuration_file_1.loadAppsConfigurationFile)({ rtwsRootAbs: params.rtwsRootAbs });
+    if (loadedConfig.kind === 'error') {
+        throw new Error(`Failed to load apps configuration: ${loadedConfig.errorText} (${loadedConfig.filePathAbs})`);
+    }
+    const loadedResolution = await (0, resolution_file_1.loadAppsResolutionFile)({ rtwsRootAbs: params.rtwsRootAbs });
+    if (loadedResolution.kind === 'error') {
+        throw new Error(`Failed to load apps resolution snapshot: ${loadedResolution.errorText} (${loadedResolution.filePathAbs})`);
+    }
+    const loadedLock = await (0, app_lock_file_1.loadAppLockFile)({ rtwsRootAbs: params.rtwsRootAbs });
+    if (loadedLock.kind === 'error') {
+        throw new Error(`Failed to load app lock: ${loadedLock.errorText} (${loadedLock.filePathAbs})`);
+    }
+    const previousResolutionById = new Map();
+    for (const entry of loadedResolution.file.apps) {
+        previousResolutionById.set(entry.id, entry);
+    }
+    const lockedHintsById = new Map();
+    for (const entry of loadedLock.file.apps) {
+        lockedHintsById.set(entry.id, makeLockedAppHint(entry));
+    }
+    const resolved = await resolveGraph({
         rtwsRootAbs: params.rtwsRootAbs,
-        overlay: loaded.overlay,
-        strategy: loaded.strategy,
-        hasResolutionFile: loaded.hasResolutionFile,
+        strategy: normalizeStrategy(loadedConfig.file.resolutionStrategy),
+        configurationDisabledApps: new Set(loadedConfig.file.disabledApps ?? []),
+        previousResolutionById,
+        lockedHintsById,
+        hasConfigurationFile: loadedConfig.exists,
     });
-    if (loaded.hasResolutionFile) {
-        const withEffectiveEnabled = (0, resolution_file_1.applyEffectiveEnabledToResolvedApps)({
-            existing: loaded.resolutionFile,
-            effectiveEnabledById: resolved.effectiveEnabledById,
-        });
-        const nextResolutionFile = (0, resolution_file_1.applyAssignedPortToResolvedApps)({
-            existing: withEffectiveEnabled,
-            assignedPortById: resolved.assignedPortById,
+    if (JSON.stringify(loadedResolution.file) !== JSON.stringify(resolved.resolutionFile)) {
+        await (0, resolution_file_1.writeAppsResolutionFileIfChanged)({
+            rtwsRootAbs: params.rtwsRootAbs,
+            file: resolved.resolutionFile,
         });
-        if (nextResolutionFile !== loaded.resolutionFile) {
-            await (0, resolution_file_1.writeAppsResolutionFileIfChanged)({
-                rtwsRootAbs: params.rtwsRootAbs,
-                file: nextResolutionFile,
-            });
-        }
     }
-    return { apps: resolved.apps, issues: resolved.issues };
+    return resolved;
 }
 async function loadEnabledAppsSnapshot(params) {
-    const loaded = await loadEffectiveAppsResolution({ rtwsRootAbs: params.rtwsRootAbs });
-    const enabledApps = loaded.apps
-        .filter((a) => a.enabled)
-        .map((a) => ({
-        // Note: installJson.frontend.defaultPort may be 0 (meaning "runtime decides"); do not pass 0 as runtimePort.
-        id: a.id,
-        runtimePort: a.assignedPort ??
-            (a.installJson.frontend &&
-                a.installJson.frontend.defaultPort &&
-                a.installJson.frontend.defaultPort > 0
-                ? a.installJson.frontend.defaultPort
-                : null),
-        installJson: a.installJson,
-        source: a.source,
-    }));
-    return { enabledApps, issues: loaded.issues };
+    const resolved = await materializeAppsResolution({ rtwsRootAbs: params.rtwsRootAbs });
+    return {
+        enabledApps: resolved.resolutionFile.apps
+            .filter((app) => app.enabled)
+            .map((app) => ({
+            id: app.id,
+            runtimePort: getRuntimePort(app),
+            installJson: app.installJson,
+            source: app.source,
+        })),
+        issues: resolved.issues,
+    };
 }