refactor(init): keep upstream server.go pristine; move init-timeout helper to its own file

The init-phase timeout / suppressed-init support previously edited the vendored
upstream internal/lambda/rapidcore/server.go (exported InitCompletionResponse,
extracted interpretInitFailure, added AwaitInitializedWithDetails and
AwaitInitializedWithTimeout). Modifying vendored upstream files causes rebase
conflicts when syncing with aws-lambda-runtime-interface-emulator.

Revert server.go to byte-identical upstream and move the only load-bearing
addition (AwaitInitializedWithTimeout, plus a local InitCompletionResponse and a
duplicated interpretInitFailure) into a new same-package file
server_localstack.go. It must stay in package rapidcore because it needs the
unexported getInitFailuresChan()/Release()/setRuntimeState() helpers, but as a
standalone file it never conflicts on rebase. AwaitInitializedWithDetails was
unused by cmd/localstack and is dropped.

No behavior change: RIE go test ./... and TestLambdaErrors both green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: joe4dev

internal/lambda/rapidcore/server.go

@@ -734,21 +734,14 @@ func (s *Server) Invoke(responseWriter http.ResponseWriter, invoke *interop.Invo
 	return err
 }
 
-// InitCompletionResponse carries the structured init failure cause (error type and
-// message) extracted from the InitFailure. It is exposed via AwaitInitializedWithDetails
-// so standalone callers can report the failure instead of only seeing the sentinel error.
-type InitCompletionResponse struct {
+type initCompletionResponse struct {
 	InitErrorType    fatalerror.ErrorType
 	InitErrorMessage error
 }
 
-func (s *Server) awaitInitialized() (InitCompletionResponse, error) {
+func (s *Server) awaitInitialized() (initCompletionResponse, error) {
 	initFailure, awaitingInitStatus := <-s.getInitFailuresChan()
-	return s.interpretInitFailure(initFailure, awaitingInitStatus)
-}
-
-func (s *Server) interpretInitFailure(initFailure interop.InitFailure, awaitingInitStatus bool) (InitCompletionResponse, error) {
-	resp := InitCompletionResponse{}
+	resp := initCompletionResponse{}
 
 	if initFailure.ResetReceived {
 		// Resets during Init are only received in standalone
@@ -775,51 +768,15 @@ func (s *Server) interpretInitFailure(initFailure interop.InitFailure, awaitingI
 // AwaitInitialized waits until init is complete. It must be idempotent,
 // since it can be called twice when a caller wants to wait until init is complete
 func (s *Server) AwaitInitialized() error {
-	_, err := s.AwaitInitializedWithDetails()
-	return err
-}
-
-// AwaitInitializedWithDetails behaves like AwaitInitialized but, on failure, also returns
-// the structured init error (type and message) carried by the InitFailure. This lets
-// standalone callers report the failure to their control plane instead of only observing
-// the sentinel error (ErrInitDoneFailed / ErrInitResetReceived).
-func (s *Server) AwaitInitializedWithDetails() (InitCompletionResponse, error) {
-	resp, err := s.awaitInitialized()
-	if err != nil {
-		if releaseErr := s.Release(); releaseErr != nil {
+	if _, err := s.awaitInitialized(); err != nil {
+		if releaseErr := s.Release(); err != nil {
 			log.Infof("Error releasing after init failure %s: %s", err, releaseErr)
 		}
 		s.setRuntimeState(runtimeInitFailed)
-		return resp, err
+		return err
 	}
 	s.setRuntimeState(runtimeInitComplete)
-	return resp, nil
-}
-
-// AwaitInitializedWithTimeout behaves like AwaitInitializedWithDetails but returns early if
-// init does not complete within the timeout. On timeout it returns timedOut=true WITHOUT
-// consuming the init-failures channel, so a subsequent invoke's Reserve()/awaitInitialized()
-// can still observe the init outcome and trigger the suppressed init. The caller is expected
-// to reset the in-progress init so that outcome becomes available.
-func (s *Server) AwaitInitializedWithTimeout(timeout time.Duration) (resp InitCompletionResponse, timedOut bool, err error) {
-	timer := time.NewTimer(timeout)
-	defer timer.Stop()
-
-	select {
-	case <-timer.C:
-		return InitCompletionResponse{}, true, nil
-	case initFailure, awaitingInitStatus := <-s.getInitFailuresChan():
-		resp, err = s.interpretInitFailure(initFailure, awaitingInitStatus)
-		if err != nil {
-			if releaseErr := s.Release(); releaseErr != nil {
-				log.Infof("Error releasing after init failure %s: %s", err, releaseErr)
-			}
-			s.setRuntimeState(runtimeInitFailed)
-			return resp, false, err
-		}
-		s.setRuntimeState(runtimeInitComplete)
-		return resp, false, nil
-	}
+	return nil
 }
 
 func (s *Server) AwaitRelease() (*statejson.ReleaseResponse, error) {

internal/lambda/rapidcore/server_localstack.go

@@ -0,0 +1,79 @@
+package rapidcore
+
+// This file contains LocalStack-specific additions to the rapidcore Server. It is kept
+// separate from server.go (which is vendored upstream from
+// aws-lambda-runtime-interface-emulator) so that upstream stays byte-identical and rebases
+// never conflict. Because the logic needs the unexported init-failures channel and runtime
+// state helpers, it must live in package rapidcore rather than in cmd/localstack.
+
+import (
+	"time"
+
+	"github.com/aws/aws-lambda-runtime-interface-emulator/internal/lambda/fatalerror"
+	"github.com/aws/aws-lambda-runtime-interface-emulator/internal/lambda/interop"
+
+	log "github.com/sirupsen/logrus"
+)
+
+// InitCompletionResponse carries the structured init failure cause (error type and message)
+// extracted from the InitFailure. It lets standalone callers report the failure instead of
+// only seeing the sentinel error (ErrInitDoneFailed / ErrInitResetReceived).
+type InitCompletionResponse struct {
+	InitErrorType    fatalerror.ErrorType
+	InitErrorMessage error
+}
+
+// interpretInitFailure mirrors the upstream Server.awaitInitialized body, mapping an
+// InitFailure to the sentinel error and structured cause. It is duplicated here (rather than
+// refactored out of server.go) to keep the upstream file untouched.
+func (s *Server) interpretInitFailure(initFailure interop.InitFailure, awaitingInitStatus bool) (InitCompletionResponse, error) {
+	resp := InitCompletionResponse{}
+
+	if initFailure.ResetReceived {
+		// Resets during Init are only received in standalone
+		// during an invoke timeout
+		s.setRuntimeState(runtimeInitFailed)
+		resp.InitErrorType = initFailure.ErrorType
+		resp.InitErrorMessage = initFailure.ErrorMessage
+		return resp, ErrInitResetReceived
+	}
+
+	if awaitingInitStatus {
+		// channel not closed, received init failure
+		// Sandbox can be reserved even if init failed (due to function errors)
+		s.setRuntimeState(runtimeInitFailed)
+		resp.InitErrorType = initFailure.ErrorType
+		resp.InitErrorMessage = initFailure.ErrorMessage
+		return resp, ErrInitDoneFailed
+	}
+
+	// not awaiting init status (channel closed)
+	return resp, nil
+}
+
+// AwaitInitializedWithTimeout behaves like the upstream AwaitInitialized but (1) returns the
+// structured init error on failure and (2) returns early if init does not complete within the
+// timeout. On timeout it returns timedOut=true WITHOUT consuming the init-failures channel and
+// without any side effects, so a subsequent invoke's Reserve()/awaitInitialized() can still
+// observe the init outcome and trigger the suppressed init. The caller is expected to reset the
+// in-progress init so that outcome becomes available.
+func (s *Server) AwaitInitializedWithTimeout(timeout time.Duration) (resp InitCompletionResponse, timedOut bool, err error) {
+	timer := time.NewTimer(timeout)
+	defer timer.Stop()
+
+	select {
+	case <-timer.C:
+		return InitCompletionResponse{}, true, nil
+	case initFailure, awaitingInitStatus := <-s.getInitFailuresChan():
+		resp, err = s.interpretInitFailure(initFailure, awaitingInitStatus)
+		if err != nil {
+			if releaseErr := s.Release(); releaseErr != nil {
+				log.Infof("Error releasing after init failure %s: %s", err, releaseErr)
+			}
+			s.setRuntimeState(runtimeInitFailed)
+			return resp, false, err
+		}
+		s.setRuntimeState(runtimeInitComplete)
+		return resp, false, nil
+	}
+}