@empire-builder-kit/nx 1.0.0-rc.4 → 1.0.0-rc.40

package/src/local-dev/fleet-runtime.js

@@ -4,6 +4,7 @@ exports.resolveDevelopmentRouter = resolveDevelopmentRouter;
 exports.startFleetRuntime = startFleetRuntime;
 const node_fs_1 = require("node:fs");
 const node_crypto_1 = require("node:crypto");
+const node_path_1 = require("node:path");
 const deterministic_order_js_1 = require("../deterministic-order.js");
 const preflight_js_1 = require("../foundation/preflight.js");
 const discovery_js_1 = require("../foundation/discovery.js");
@@ -14,12 +15,16 @@ const errors_js_1 = require("./errors.js");
 const fleet_logs_js_1 = require("./fleet-logs.js");
 const fleet_process_js_1 = require("./fleet-process.js");
 const fleet_session_js_1 = require("./fleet-session.js");
+const fleet_web_start_js_1 = require("./fleet-web-start.js");
+const native_completion_js_1 = require("./native-completion.js");
 const fleet_supervisor_js_1 = require("./fleet-supervisor.js");
 const fleet_startup_js_1 = require("./fleet-startup.js");
 const gateway_js_1 = require("./gateway.js");
 const identity_js_1 = require("./identity.js");
+const task_authority_js_1 = require("./task-authority.js");
 const nx_workspace_js_1 = require("./nx-workspace.js");
 const ports_js_1 = require("./ports.js");
+const port_claims_js_1 = require("./port-claims.js");
 const personal_stage_js_1 = require("./personal-stage.js");
 const process_identity_js_1 = require("./process-identity.js");
 const proxy_js_1 = require("./proxy.js");
@@ -74,7 +79,7 @@ async function startFleetRuntime(startupPath, dependencies = {}) {
     if ((0, node_fs_1.realpathSync)(process.cwd()) !== request.workspaceRealpath) {
         return runtimeError('Fleet supervisor current directory does not match its startup checkout.');
     }
-    const identity = (dependencies.personalStageResolver ?? (0, personal_stage_js_1.createPersonalStageResolver)()).resolve();
+    const identity = (dependencies.personalStageResolver ?? (0, personal_stage_js_1.createPersonalStageResolver)()).resolve(request.workspaceRealpath);
     if (identity.stage !== request.identity.stage ||
         identity.resolverVersion !== request.identity.resolverVersion ||
         identity.identitySource !== request.identity.identitySource) {
@@ -95,10 +100,8 @@ async function startFleetRuntime(startupPath, dependencies = {}) {
     const runtimePaths = (0, runtime_paths_js_1.fleetRuntimePaths)(fleetId, request.appData);
     const hostname = (0, identity_js_1.createFleetHostname)(fleetId, request.context.hostSuffix);
     const doctor = await (dependencies.inspectDoctor ?? dev_doctor_js_1.inspectLocalDevelopment)({ appData: request.appData, hostname }, { projectName: request.workspaceName, root: request.workspaceRealpath });
-    if (doctor.tls !== 'ready' ||
-        doctor.trust !== 'ready' ||
-        doctor.connectivity !== 'ready') {
-        throw new errors_js_1.LocalDevContractError('prerequisite-unavailable', 'Local HTTPS trust or effect-based connectivity is incomplete. Run ebk dev doctor and ebk dev setup --trust.');
+    if (doctor.tls !== 'ready' || doctor.connectivity !== 'ready') {
+        throw new errors_js_1.LocalDevContractError('prerequisite-unavailable', 'Local TLS state or its private-chain loopback handshake is incomplete. Run ebk dev doctor and ebk dev setup. Browser verification uses scoped trust; system trust is optional.');
     }
     const tls = (0, tls_js_1.localTlsPaths)(request.appData);
     const leaf = new node_crypto_1.X509Certificate((0, node_fs_1.readFileSync)(tls.leafCertificate));
@@ -124,245 +127,281 @@ async function startFleetRuntime(startupPath, dependencies = {}) {
     });
     (0, environment_inspector_js_1.assertEnvironmentReady)(environment);
     const allocate = dependencies.allocatePort ?? ports_js_1.allocateFleetPort;
-    const reserved = new Set();
-    const proxyPort = await allocate(`${request.workspaceRealpath}:${fleetId}:proxy`, { reserved });
-    reserved.add(proxyPort);
-    const gatewayPort = await allocate(`${request.workspaceRealpath}:${fleetId}:gateway`, { reserved });
-    reserved.add(gatewayPort);
-    const ports = new Map();
-    for (const name of [...plan.adapters.keys()].sort()) {
-        const port = await allocate(`${request.workspaceRealpath}:${fleetId}:${name}`, { reserved });
-        reserved.add(port);
-        ports.set(name, port);
-    }
-    const origin = new URL(`https://${hostname}:${gatewayPort}`);
-    const routes = [...plan.adapters]
-        .sort(([left], [right]) => (0, deterministic_order_js_1.compareUtf16)(left, right))
-        .map(([name, adapter]) => ({
-        adapter,
-        name,
-        selected: false,
-        state: 'remote',
-    }));
-    const proxy = new proxy_js_1.FleetSessionProxy({
-        certificateExpires: doctor.certificateExpires ?? leaf.validTo,
-        consumerStage: request.identity.stage,
-        fleetOrigin: origin,
-        foundationStage: 'development',
-        remoteOrigin: router,
-        routes,
-        safeMethodFallback: request.context.safeMethodFallback,
-    });
-    const gatewayCapability = (0, node_fs_1.readFileSync)(tls.capability, 'utf8').trim();
-    const registry = new gateway_js_1.GatewayRegistry(gatewayCapability);
-    const registration = {
-        action: 'register',
-        capability: gatewayCapability,
-        clientFrameworkVersion: request.frameworkVersion,
-        hostname,
-        protocol: {
-            maximum: contracts_js_1.GATEWAY_PROTOCOL_VERSION,
-            minimum: contracts_js_1.GATEWAY_PROTOCOL_VERSION,
-        },
-        proxyPort,
-        sessionId: fleetId,
-        sessionManifestVersion: contracts_js_1.SESSION_MANIFEST_VERSION,
-    };
-    registry.register(registration);
-    const gateway = new gateway_js_1.MachineGateway(registry, {
-        cert: (0, node_fs_1.readFileSync)(tls.leafCertificate),
-        key: (0, node_fs_1.readFileSync)(tls.leafKey),
-    });
-    const gatewayIpc = (0, tls_js_1.createLocalIpcPath)(runtimePaths.sessionDirectory, `session-gateway-${fleetId}`);
-    if (process.platform !== 'win32')
-        (0, node_fs_1.rmSync)(gatewayIpc, { force: true });
-    let gatewayHeartbeat;
-    const proxyHost = {
-        async close() {
-            if (gatewayHeartbeat)
-                clearInterval(gatewayHeartbeat);
-            registry.unregister(registration.hostname, registration.sessionId);
-            await gateway.close();
-            if (process.platform !== 'win32')
-                (0, node_fs_1.rmSync)(gatewayIpc, { force: true });
-            await proxy.close();
-        },
-        async listen(port) {
-            await proxy.listen(port);
-            await gateway.listen(gatewayPort, gatewayIpc);
-            proxy.setMode('explicit-port', 'standalone');
-            gatewayHeartbeat = setInterval(() => {
-                try {
-                    registry.heartbeat(hostname, fleetId);
-                }
-                catch {
-                    // State and control remain authoritative; gateway TTL fails closed.
-                }
-            }, 5_000);
-            gatewayHeartbeat.unref();
-        },
-    };
-    const nxRuntime = (0, nx_workspace_js_1.resolveWorkspaceNxRuntime)(request.workspaceRealpath);
     const processOwner = (0, process_identity_js_1.captureProcessIdentity)();
-    const logStore = new fleet_logs_js_1.FleetLogStore(runtimePaths.logDirectory, fleetId, request.sessionGeneration, [gatewayCapability]);
-    const session = new fleet_session_js_1.FleetSession({
-        adapters: plan.adapters,
-        allocatePort: async (name) => ports.get(name),
+    const portClaims = (0, port_claims_js_1.createFleetPortClaims)((0, node_path_1.join)(runtimePaths.appData, 'port-claims'), {
         fleetId,
-        processFactory: ({ adapter, name, onStateChange, upstream }) => {
-            let activeRunner;
-            return new fleet_process_js_1.FleetProcessController({
-                adapter,
-                logStore,
-                maxRestartAttempts: request.context.maxRestartAttempts,
-                name,
-                onStateChange,
-                upstream,
-            }, {
-                cleanup: async () => {
-                    if (!activeRunner) {
-                        throw new errors_js_1.LocalDevContractError('cleanup-incomplete', `Fleet Slice runner state for ${name} is missing.`);
-                    }
+        sessionGeneration: request.sessionGeneration,
+        process: processOwner,
+    });
+    try {
+        const ephemeralRange = (0, ports_js_1.readAutomaticTcpPortRange)();
+        const reserved = new Set();
+        const proxyPort = await allocate(`${request.workspaceRealpath}:${fleetId}:proxy`, { reserved, ephemeralRange, claim: portClaims.claim });
+        reserved.add(proxyPort);
+        const gatewayPort = await allocate(`${request.workspaceRealpath}:${fleetId}:gateway`, { reserved, ephemeralRange, claim: portClaims.claim });
+        reserved.add(gatewayPort);
+        const ports = new Map();
+        for (const name of [...plan.adapters.keys()].sort()) {
+            const port = await allocate(`${request.workspaceRealpath}:${fleetId}:${name}`, { reserved, ephemeralRange, claim: portClaims.claim });
+            reserved.add(port);
+            ports.set(name, port);
+        }
+        const origin = new URL(`https://${hostname}:${gatewayPort}`);
+        const routes = [...plan.adapters]
+            .sort(([left], [right]) => (0, deterministic_order_js_1.compareUtf16)(left, right))
+            .map(([name, adapter]) => ({
+            adapter,
+            name,
+            selected: false,
+            state: 'remote',
+        }));
+        const proxy = new proxy_js_1.FleetSessionProxy({
+            certificateExpires: doctor.certificateExpires ?? leaf.validTo,
+            consumerStage: request.identity.stage,
+            fleetOrigin: origin,
+            foundationStage: 'development',
+            remoteOrigin: router,
+            routes,
+            safeMethodFallback: request.context.safeMethodFallback,
+        });
+        const gatewayCapability = (0, node_fs_1.readFileSync)(tls.capability, 'utf8').trim();
+        const registry = new gateway_js_1.GatewayRegistry(gatewayCapability);
+        const registration = {
+            action: 'register',
+            capability: gatewayCapability,
+            clientFrameworkVersion: request.frameworkVersion,
+            hostname,
+            protocol: {
+                maximum: contracts_js_1.GATEWAY_PROTOCOL_VERSION,
+                minimum: contracts_js_1.GATEWAY_PROTOCOL_VERSION,
+            },
+            proxyPort,
+            sessionId: fleetId,
+            sessionManifestVersion: contracts_js_1.SESSION_MANIFEST_VERSION,
+        };
+        registry.register(registration);
+        const gateway = new gateway_js_1.MachineGateway(registry, {
+            cert: (0, node_fs_1.readFileSync)(tls.leafCertificate),
+            key: (0, node_fs_1.readFileSync)(tls.leafKey),
+        });
+        const gatewayIpc = (0, tls_js_1.createLocalIpcPath)(runtimePaths.sessionDirectory, `session-gateway-${fleetId}`);
+        if (process.platform !== 'win32')
+            (0, node_fs_1.rmSync)(gatewayIpc, { force: true });
+        let gatewayHeartbeat;
+        const proxyHost = {
+            async close() {
+                if (gatewayHeartbeat)
+                    clearInterval(gatewayHeartbeat);
+                registry.unregister(registration.hostname, registration.sessionId);
+                await gateway.close();
+                if (process.platform !== 'win32')
+                    (0, node_fs_1.rmSync)(gatewayIpc, { force: true });
+                await proxy.close();
+                portClaims.release();
+            },
+            async listen(port) {
+                await proxy.listen(port);
+                await gateway.listen(gatewayPort, gatewayIpc);
+                proxy.setMode('explicit-port', 'standalone');
+                gatewayHeartbeat = setInterval(() => {
                     try {
-                        (0, slice_runner_js_1.assertFleetSliceRunnerCleanup)(activeRunner.statePath, activeRunner.request);
+                        registry.heartbeat(hostname, fleetId);
                     }
                     catch {
-                        await (0, slice_runner_js_1.retryFleetSliceRunnerCleanup)(activeRunner);
-                        (0, slice_runner_js_1.assertFleetSliceRunnerCleanup)(activeRunner.statePath, activeRunner.request);
-                    }
-                    await (0, slice_runner_js_1.recoverFleetSliceRunnerCleanupsForSlices)({
-                        fleetId: activeRunner.request.fleetId,
-                        sessionGeneration: activeRunner.request.sessionGeneration,
-                    }, [name], runtimePaths);
-                },
-                launch: (attempt) => {
-                    activeRunner = (0, slice_runner_js_1.launchFleetSliceRunner)({
-                        origin,
-                        parent: processOwner,
-                        port: ports.get(name),
-                        runnerGeneration: `${request.sessionGeneration}:${name}:${attempt}:${(0, node_crypto_1.randomUUID)()}`,
-                        runtimePaths,
-                        sessionGeneration: request.sessionGeneration,
-                        slice: name,
-                        startupPath,
-                        workspaceRealpath: request.workspaceRealpath,
-                    });
-                    return { attempt, child: activeRunner.child };
-                },
-                prepareRestart: async () => {
-                    if (!activeRunner) {
-                        throw new errors_js_1.LocalDevContractError('cleanup-incomplete', `Fleet Slice runner state for ${name} is missing.`);
+                        // State and control remain authoritative; gateway TTL fails closed.
                     }
-                    (0, slice_runner_js_1.requestFleetSliceRunnerRestart)(activeRunner);
-                },
-                runnerGeneration: () => activeRunner?.request.runnerGeneration,
-                terminate: fleet_process_js_1.terminateOwnedChild,
-            });
-        },
-        proxy: proxyHost,
-        proxyPort,
-        routes,
-        sessionGeneration: request.sessionGeneration,
-        sliceClaimsDirectory: runtimePaths.sliceClaimsDirectory,
-        supervisor: processOwner,
-    });
-    const gatedHost = {
-        allSlices: () => session.allSlices(),
-        closeProxyWhenEmpty: () => session.closeProxyWhenEmpty(),
-        down: (slices) => session.down(slices),
-        restart: async (slices) => {
-            const assessment = await (0, environment_inspector_js_1.inspectDevelopmentEnvironment)({
-                adapters: slices.map((name) => plan.adapters.get(name)),
-                command: 'restart',
-                context: request.context,
-                frameworkVersion: request.frameworkVersion,
-                identity: request.identity,
-                workspaceRoot: request.workspaceRealpath,
-            });
-            (0, environment_inspector_js_1.assertEnvironmentReady)(assessment);
-            return session.restart(slices);
-        },
-        selectedSlices: () => session.selectedSlices(),
-        sliceStates: () => session.snapshot().routes.map((route) => ({
-            cleanup: route.cleanup,
-            name: route.name,
-            restartAttempts: route.restartAttempts,
-            routeState: route.state,
-            ...(route.runnerGeneration
-                ? { runnerGeneration: route.runnerGeneration }
-                : {}),
-            selected: route.selected,
-        })),
-        up: async (slices) => {
-            const assessment = await (0, environment_inspector_js_1.inspectDevelopmentEnvironment)({
-                adapters: slices.map((name) => plan.adapters.get(name)),
-                command: 'up',
+                }, 5_000);
+                gatewayHeartbeat.unref();
+            },
+        };
+        const nxRuntime = (0, nx_workspace_js_1.resolveWorkspaceNxRuntime)(request.workspaceRealpath);
+        const logStore = new fleet_logs_js_1.FleetLogStore(runtimePaths.logDirectory, fleetId, request.sessionGeneration, [gatewayCapability]);
+        const session = new fleet_session_js_1.FleetSession({
+            adapters: plan.adapters,
+            allocatePort: async (name) => ports.get(name),
+            fleetId,
+            processFactory: ({ adapter, name, onStateChange, upstream }) => {
+                let activeRunner;
+                return new fleet_process_js_1.FleetProcessController({
+                    adapter,
+                    logStore,
+                    maxRestartAttempts: request.context.maxRestartAttempts,
+                    name,
+                    onStateChange,
+                    upstream,
+                }, {
+                    ...(plan.projects[name]?.targets?.[adapter.target]?.executor ===
+                        '@empire-builder-kit/nx:dev'
+                        ? {
+                            nativeDeployment: async (signal) => activeRunner
+                                ? (0, native_completion_js_1.readNativeDevelopmentCompletion)({
+                                    projectRoot: (0, node_path_1.join)(request.workspaceRealpath, plan.projects[name].root),
+                                    stage: request.identity.stage,
+                                    startedAt: activeRunner.request.createdAt,
+                                }, signal)
+                                : 'pending',
+                            applicationStarted: () => Boolean(activeRunner &&
+                                (0, fleet_web_start_js_1.hasFleetWebStarted)(activeRunner.requestPath, activeRunner.request)),
+                        }
+                        : {}),
+                    cleanup: async () => {
+                        if (!activeRunner) {
+                            throw new errors_js_1.LocalDevContractError('cleanup-incomplete', `Fleet Slice runner state for ${name} is missing.`);
+                        }
+                        try {
+                            (0, slice_runner_js_1.assertFleetSliceRunnerCleanup)(activeRunner.statePath, activeRunner.request);
+                        }
+                        catch {
+                            await (0, slice_runner_js_1.retryFleetSliceRunnerCleanup)(activeRunner);
+                            (0, slice_runner_js_1.assertFleetSliceRunnerCleanup)(activeRunner.statePath, activeRunner.request);
+                        }
+                        await (0, slice_runner_js_1.recoverFleetSliceRunnerCleanupsForSlices)({
+                            fleetId: activeRunner.request.fleetId,
+                            sessionGeneration: activeRunner.request.sessionGeneration,
+                        }, [name], runtimePaths);
+                    },
+                    launch: (attempt) => {
+                        activeRunner = (0, slice_runner_js_1.launchFleetSliceRunner)({
+                            origin,
+                            parent: processOwner,
+                            port: ports.get(name),
+                            runnerGeneration: `${request.sessionGeneration}:${name}:${attempt}:${(0, node_crypto_1.randomUUID)()}`,
+                            runtimePaths,
+                            sessionGeneration: request.sessionGeneration,
+                            slice: name,
+                            startupPath,
+                            workspaceRealpath: request.workspaceRealpath,
+                        });
+                        return { attempt, child: activeRunner.child };
+                    },
+                    prepareRestart: async () => {
+                        if (!activeRunner) {
+                            throw new errors_js_1.LocalDevContractError('cleanup-incomplete', `Fleet Slice runner state for ${name} is missing.`);
+                        }
+                        (0, slice_runner_js_1.requestFleetSliceRunnerRestart)(activeRunner);
+                    },
+                    runnerGeneration: () => activeRunner?.request.runnerGeneration,
+                    terminate: async (child) => {
+                        if (!activeRunner || activeRunner.child !== child) {
+                            throw new errors_js_1.LocalDevContractError('cleanup-incomplete', 'Fleet runner ownership changed before shutdown.');
+                        }
+                        await (0, fleet_process_js_1.terminateCoordinatingFleetRunner)(child, activeRunner.request.runnerGeneration);
+                    },
+                });
+            },
+            proxy: proxyHost,
+            proxyPort,
+            routes,
+            sessionGeneration: request.sessionGeneration,
+            sliceClaimsDirectory: runtimePaths.sliceClaimsDirectory,
+            supervisor: processOwner,
+        });
+        const gatedHost = {
+            allSlices: () => session.allSlices(),
+            closeProxyWhenEmpty: () => session.closeProxyWhenEmpty(),
+            down: (slices) => session.down(slices),
+            interruptStartup: (slices) => session.interruptStartup(slices),
+            restart: async (slices) => {
+                await (0, task_authority_js_1.bindCurrentTaskEnvironment)(request.workspaceRealpath, request.context);
+                const assessment = await (0, environment_inspector_js_1.inspectDevelopmentEnvironment)({
+                    adapters: slices.map((name) => plan.adapters.get(name)),
+                    command: 'restart',
+                    context: request.context,
+                    frameworkVersion: request.frameworkVersion,
+                    identity: request.identity,
+                    workspaceRoot: request.workspaceRealpath,
+                });
+                (0, environment_inspector_js_1.assertEnvironmentReady)(assessment);
+                return session.restart(slices);
+            },
+            selectedSlices: () => session.selectedSlices(),
+            sliceStates: () => session.snapshot().routes.map((route) => ({
+                cleanup: route.cleanup,
+                name: route.name,
+                restartAttempts: route.restartAttempts,
+                routeState: route.state,
+                ...(route.runnerGeneration
+                    ? { runnerGeneration: route.runnerGeneration }
+                    : {}),
+                selected: route.selected,
+            })),
+            up: async (slices) => {
+                await (0, task_authority_js_1.bindCurrentTaskEnvironment)(request.workspaceRealpath, request.context);
+                const assessment = await (0, environment_inspector_js_1.inspectDevelopmentEnvironment)({
+                    adapters: slices.map((name) => plan.adapters.get(name)),
+                    command: 'up',
+                    context: request.context,
+                    frameworkVersion: request.frameworkVersion,
+                    identity: request.identity,
+                    workspaceRoot: request.workspaceRealpath,
+                });
+                (0, environment_inspector_js_1.assertEnvironmentReady)(assessment);
+                return session.up(slices);
+            },
+        };
+        const now = new Date();
+        const state = {
+            configurationFingerprint: (0, fleet_configuration_js_1.fleetConfigurationFingerprint)({
                 context: request.context,
                 frameworkVersion: request.frameworkVersion,
                 identity: request.identity,
-                workspaceRoot: request.workspaceRealpath,
-            });
-            (0, environment_inspector_js_1.assertEnvironmentReady)(assessment);
-            return session.up(slices);
-        },
-    };
-    const now = new Date();
-    const state = {
-        configurationFingerprint: (0, fleet_configuration_js_1.fleetConfigurationFingerprint)({
-            context: request.context,
+                nxVersion: nxRuntime.version,
+                plan,
+                routerOrigin: router.origin,
+            }),
+            contextDigest: (0, contract_validation_js_1.sha256Digest)(request.context),
+            controlProtocolVersion: 1,
+            createdAt: now.toISOString(),
+            fleetId,
             frameworkVersion: request.frameworkVersion,
-            identity: request.identity,
+            gitCommonDirectory: request.gitCommonDirectory,
+            heartbeatAt: now.toISOString(),
+            identitySource: request.identity.identitySource,
             nxVersion: nxRuntime.version,
-            plan,
+            operations: [],
+            origin: origin.origin,
+            resolvedStage: request.identity.stage,
             routerOrigin: router.origin,
-        }),
-        contextDigest: (0, contract_validation_js_1.sha256Digest)(request.context),
-        controlProtocolVersion: 1,
-        createdAt: now.toISOString(),
-        fleetId,
-        frameworkVersion: request.frameworkVersion,
-        gitCommonDirectory: request.gitCommonDirectory,
-        heartbeatAt: now.toISOString(),
-        identitySource: request.identity.identitySource,
-        nxVersion: nxRuntime.version,
-        operations: [],
-        origin: origin.origin,
-        resolvedStage: request.identity.stage,
-        routerOrigin: router.origin,
-        routerSource: (0, fleet_configuration_js_1.fleetRouterSource)(request.context),
-        schemaVersion: 1,
-        sessionGeneration: request.sessionGeneration,
-        slices: [...plan.adapters]
-            .sort(([left], [right]) => (0, deterministic_order_js_1.compareUtf16)(left, right))
-            .map(([name, adapter]) => ({
-            adapterVersion: adapter.adapterVersion,
-            cleanup: adapter.adapterVersion === 2 && adapter.lifecycle
-                ? 'pending'
-                : 'not-declared',
-            lastTransitionAt: now.toISOString(),
-            logSequence: 0,
-            name,
-            port: ports.get(name),
-            restartAttempts: 0,
-            routeState: 'remote',
-            selected: false,
-        })),
-        supervisor: processOwner,
-        workspaceRealpath: request.workspaceRealpath,
-    };
-    const supervisor = new fleet_supervisor_js_1.FleetSupervisor({
-        host: gatedHost,
-        initialState: state,
-        paths: runtimePaths,
-    }, { processIdentity: () => processOwner });
-    try {
-        await session.start();
-        await supervisor.start();
+            routerSource: (0, fleet_configuration_js_1.fleetRouterSource)(request.context),
+            schemaVersion: 1,
+            sessionGeneration: request.sessionGeneration,
+            slices: [...plan.adapters]
+                .sort(([left], [right]) => (0, deterministic_order_js_1.compareUtf16)(left, right))
+                .map(([name, adapter]) => ({
+                adapterVersion: adapter.adapterVersion,
+                cleanup: adapter.adapterVersion !== 1 && adapter.lifecycle
+                    ? 'pending'
+                    : 'not-declared',
+                lastTransitionAt: now.toISOString(),
+                logSequence: 0,
+                name,
+                port: ports.get(name),
+                restartAttempts: 0,
+                routeState: 'remote',
+                selected: false,
+            })),
+            supervisor: processOwner,
+            workspaceRealpath: request.workspaceRealpath,
+        };
+        const supervisor = new fleet_supervisor_js_1.FleetSupervisor({
+            adapters: plan.adapters,
+            host: gatedHost,
+            initialState: state,
+            paths: runtimePaths,
+        }, { processIdentity: () => processOwner });
+        try {
+            await session.start();
+            await supervisor.start();
+        }
+        catch (error) {
+            await proxyHost.close().catch(() => undefined);
+            throw error;
+        }
+        return { fleetId, origin: origin.origin, session, supervisor };
     }
     catch (error) {
-        await proxyHost.close().catch(() => undefined);
+        portClaims.release();
         throw error;
     }
-    return { fleetId, origin: origin.origin, session, supervisor };
 }
 //# sourceMappingURL=fleet-runtime.js.map

package/src/local-dev/fleet-session.d.ts

@@ -7,6 +7,7 @@ export interface FleetSliceProcess {
     readonly restartAttempts?: number;
     readonly runnerGeneration?: string;
     readonly state: FleetProcessRouteState;
+    interruptStartup?(): void;
     restart(): Promise<void>;
     start(): Promise<void>;
     stop(options: {
@@ -64,6 +65,7 @@ export declare class FleetSession {
     restart(names: readonly string[]): Promise<FleetSessionTargetResult[]>;
     down(names: readonly string[]): Promise<FleetSessionTargetResult[]>;
     selectedSlices(): string[];
+    interruptStartup(names: readonly string[]): void;
     allSlices(): string[];
     snapshot(): FleetSessionSnapshot;
     closeProxyWhenEmpty(): Promise<boolean>;