@@ -11,69 +11,29 @@ import (
 
 	basev0 "github.com/codefly-dev/core/generated/go/codefly/base/v0"
 	runtimev0 "github.com/codefly-dev/core/generated/go/codefly/services/runtime/v0"
-	"github.com/codefly-dev/core/resources"
-	"github.com/codefly-dev/core/standards"
 	"github.com/stretchr/testify/require"
 )
 
-const initStartProject = `[project]
-name = "init-start-probe"
-version = "0.0.0"
-`
-
-// initStartTestRuntime stands a Runtime up at the point Init is called from,
-// with a runner environment already in place so Init runs its publishing
-// section — runtime context, network mappings, ports, environment variables —
-// without building a real one.
+// initStartTestRuntime builds on initTestRuntime and adds what an Init/Start
+// overlap needs: a runner environment Start can launch against without a real
+// uv, a cache location for the dependency hashes, and a configuration, so Init
+// still has environment-manager work to do after its runner section — the
+// window a Start can land in.
 func initStartTestRuntime(t *testing.T) (*Runtime, *fakeRunnerEnvironment, *runtimev0.InitRequest) {
 	t.Helper()
 
-	runtime := NewRuntime(NewService())
-	runtime.Location = t.TempDir()
-	// Load is what supplies these; these tests call Init and Start directly.
-	runtime.Logger = runtime.Wool
-	runtime.Identity = resources.ServiceIdentityFromProto(&basev0.ServiceIdentity{
-		Name:          "probe",
-		Module:        "mod",
-		Workspace:     "workspace",
-		WorkspacePath: runtime.Location,
-	})
-
-	source := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(source, "src"), 0o700))
-	require.NoError(t, os.WriteFile(filepath.Join(source, "pyproject.toml"), []byte(initStartProject), 0o600))
-	require.NoError(t, os.WriteFile(filepath.Join(source, "src", "main.py"), []byte("app = None\n"), 0o600))
-	runtime.Service.SourceLocation = source
+	runtime, req := initTestRuntime(t)
 	runtime.cacheLocation = t.TempDir()
-
-	endpoint := &basev0.Endpoint{Module: "mod", Service: "probe", Name: "rest", Api: standards.REST}
-	runtime.FastAPI.RestEndpoint = endpoint
-
 	env := &fakeRunnerEnvironment{}
 	runtime.runnerEnvironment = env
-	t.Cleanup(runtime.Base.StopWatcher)
-
-	return runtime, env, &runtimev0.InitRequest{
-		RuntimeContext: resources.NewRuntimeContextNative(),
-		// A configuration leaves Init environment-manager work to do after its
-		// runner section, which is where a Start can overlap it.
-		Configuration: &basev0.Configuration{
-			Origin: "mod/probe",
-			Infos: []*basev0.ConfigurationInformation{{
-				Name:                "postgres",
-				ConfigurationValues: []*basev0.ConfigurationValue{{Key: "url", Value: "postgres://localhost"}},
-			}},
-		},
-		ProposedNetworkMappings: []*basev0.NetworkMapping{{
-			Endpoint: endpoint,
-			Instances: []*basev0.NetworkInstance{{
-				Access:   resources.NewNativeNetworkAccess(),
-				Hostname: "localhost",
-				Port:     9999,
-				Address:  "http://localhost:9999",
-			}},
+	req.Configuration = &basev0.Configuration{
+		Origin: "mod/probe",
+		Infos: []*basev0.ConfigurationInformation{{
+			Name:                "postgres",
+			ConfigurationValues: []*basev0.ConfigurationValue{{Key: "url", Value: "postgres://localhost"}},
 		}},
 	}
+	return runtime, env, req
 }
 
 // uvicornProc returns the process Start launched, told apart from the ones Init
@@ -89,6 +49,16 @@ func uvicornProc(t *testing.T, env *fakeRunnerEnvironment) *fakeProc {
 	return nil
 }
 
+// uvicornPort returns the port Start bound the process to.
+func uvicornPort(t *testing.T, env *fakeRunnerEnvironment) string {
+	t.Helper()
+	args := uvicornProc(t, env).args
+	i := slices.Index(args, "--port")
+	require.GreaterOrEqual(t, i, 0, "uvicorn was launched without a port: %v", args)
+	require.Less(t, i+1, len(args), "uvicorn was launched with a bare --port: %v", args)
+	return args[i+1]
+}
+
 // gatingEnv holds Init inside its runner section until the test releases it, so
 // a Start can be issued while Init is demonstrably mid-flight.
 type gatingEnv struct {
@@ -107,7 +77,19 @@ func (e *gatingEnv) Init(context.Context) error {
 // port Start binds uvicorn to, so a Start landing in the middle of an Init runs
 // after it and launches on the published port rather than on whatever the field
 // happened to hold.
+//
+// It is also where `-race` sees the two calls overlap on the state Init
+// publishes. Gating Init inside its runner section is what makes that reliable:
+// released from a bare start gate the two bodies order themselves through
+// runnerMu, and the detector reports nothing at all.
 func TestStartWaitsForInitToPublishItsPorts(t *testing.T) {
+	for range 20 {
+		runInitAgainstStart(t)
+	}
+}
+
+func runInitAgainstStart(t *testing.T) {
+	t.Helper()
 	runtime, fake, req := initStartTestRuntime(t)
 	env := &gatingEnv{fakeRunnerEnvironment: fake, entered: make(chan struct{}), release: make(chan struct{})}
 	runtime.runnerEnvironment = env
@@ -123,56 +105,89 @@ func TestStartWaitsForInitToPublishItsPorts(t *testing.T) {
 
 	<-env.entered
 
+	startDone := make(chan struct{})
 	var startResp *runtimev0.StartResponse
 	var startErr error
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
 		startResp, startErr = runtime.Start(context.Background(), &runtimev0.StartRequest{})
+		close(startDone)
 	}()
 
 	// Nothing observable says the Start goroutine reached the lock, so give it
-	// the room an unserialized Start would need to launch on the unwritten port.
-	time.Sleep(100 * time.Millisecond)
+	// the room an unserialized Start would need. Observing startDone is only
+	// safe on the failing side: receiving from it would order the Start
+	// goroutine ahead of the release below and hide the very race this test
+	// exists to surface, so the good path must fall through the timeout having
+	// synchronized with nothing.
+	select {
+	case <-startDone:
+		t.Fatal("Start ran to completion while Init was still inside its runner section")
+	case <-time.After(50 * time.Millisecond):
+	}
 	close(env.release)
 	wg.Wait()
 
 	require.NoError(t, initErr)
 	require.Equal(t, runtimev0.InitStatus_READY, initResp.GetStatus().GetState(), initResp.GetStatus().GetMessage())
 	require.NoError(t, startErr)
 	require.Equal(t, runtimev0.StartStatus_STARTED, startResp.GetStatus().GetState(), startResp.GetStatus().GetMessage())
+	require.Equal(t, "9999", uvicornPort(t, fake))
+}
 
-	proc := uvicornProc(t, fake)
-	require.Contains(t, proc.args, "--port")
-	require.Equal(t, "9999", proc.args[slices.Index(proc.args, "--port")+1])
+// TestInitIsSafeWithConcurrentStartOnAColdRuntime covers the path the gated
+// test cannot reach: the first Init, which runs CreateRunnerEnvironment. That
+// function reads the network mappings and the whole environment manager, and
+// publishes ActiveEnv — none of it exercised once a runner environment is
+// already in place.
+//
+// Start is pointed at a source location that does not exist, so it does all of
+// its reading and then fails in exec rather than launching a real uvicorn.
+func TestInitIsSafeWithConcurrentStartOnAColdRuntime(t *testing.T) {
+	isolateWorkingDir(t)
+	for range 20 {
+		runColdInitAgainstStart(t)
+	}
 }
 
-// TestInitIsSafeWithConcurrentStart overlaps the two calls that own the same
-// fields. Under `-race` this is what catches Init publishing the ports, the
-// network mappings, the runtime context and the environment-variable manager
-// outside the lock Start reads them under; without it, it still pins that
-// neither side panics however they interleave.
-func TestInitIsSafeWithConcurrentStart(t *testing.T) {
-	runtime, env, req := initStartTestRuntime(t)
+func runColdInitAgainstStart(t *testing.T) {
+	t.Helper()
+	runtime, req := initTestRuntime(t)
+	// Init creates and publishes the runner environment — the section under
+	// test — and then stops on the missing project file, well before uv.
+	require.NoError(t, os.Remove(filepath.Join(runtime.Service.SourceLocation, "pyproject.toml")))
+	runtime.Service.SourceLocation = filepath.Join(runtime.Service.SourceLocation, "does-not-exist")
+
+	var initResp *runtimev0.InitResponse
+	var initErr error
+	var startResp *runtimev0.StartResponse
 
 	gate := make(chan struct{})
 	var wg sync.WaitGroup
-	var initErr, startErr error
 	wg.Add(2)
 	go func() {
 		defer wg.Done()
 		<-gate
-		_, initErr = runtime.Init(context.Background(), req)
+		initResp, initErr = runtime.Init(context.Background(), req)
 	}()
 	go func() {
 		defer wg.Done()
 		<-gate
-		_, startErr = runtime.Start(context.Background(), &runtimev0.StartRequest{})
+		// Land in the window Init is vulnerable in. Before the environment is
+		// published Start refuses at once, having read none of the state Init
+		// is writing, and the accesses that would race never execute.
+		waitForRunnerEnvironment(runtime)
+		startResp, _ = runtime.Start(context.Background(), &runtimev0.StartRequest{})
 	}()
 	close(gate)
 	wg.Wait()
 
 	require.NoError(t, initErr)
-	require.NoError(t, startErr)
-	uvicornProc(t, env)
+	require.NotNil(t, initResp, "Init must not panic when a Start lands mid-flight")
+	require.Contains(t, initResp.GetStatus().GetMessage(), "no pyproject.toml",
+		"Init must run past its runner section, or this tests nothing")
+	require.NotNil(t, startResp, "Start must not panic against a concurrent Init")
+	require.DirExists(t, filepath.Join(runtime.Location, ".cache/local"),
+		"Init must have created and published the runner environment")
 }