fix(init): drain the reset-interrupted init failure so it cannot mask the suppressed init's real error

After the timeout path resets the in-progress init, awaitInitCompletion is
parked sending a ResetReceived failure on the unbuffered initFailures
channel. The first invoke's Reserve()/awaitInitialized() consumed it and
cached a generic placeholder error (Sandbox.Failure with an EMPTY payload,
see the ErrInitResetReceived handling in Invoke), which took precedence over
the real failure when the suppressed init re-run crashed without calling
/init/error: the invocation returned an empty error payload instead of e.g.
Runtime.ExitError "Runtime exited with error: exit status 1" (AWS-validated
by test_lambda_init_timeout_then_crash in localstack-pro).

Drain the notification right after the synchronous reset, so the invoke's
awaitInitialized() observes the closed channel, treats the init outcome as
pending, and the suppressed init's own result stays authoritative. This also
unparks the awaitInitCompletion goroutine for environments that time out
their init but never receive an invoke.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: joe4dev

cmd/localstack/main.go

@@ -317,6 +317,11 @@ func main() {
 			// itself has completed and the suppressed-init retry stays valid.
 			log.Debugf("Reset after init timeout returned: %s", resetErr)
 		}
+		// Consume the reset-interrupted init's failure notification: if the first invoke's
+		// awaitInitialized() consumed it instead, rapidcore would cache a generic placeholder
+		// error (Sandbox.Failure with an empty payload) that masks the real error when the
+		// suppressed init re-run fails (e.g. a runtime crash without /init/error).
+		interopServer.delegate.DrainInitFailure()
 	case interopServer.onDemand && errors.Is(err, rapidcore.ErrInitDoneFailed):
 		// On-demand: AWS folds a failed cold-start init into the first invocation (suppressed
 		// init). Signal ready and keep the process alive so LocalStack dispatches the first

internal/lambda/rapidcore/server_localstack.go

@@ -51,6 +51,21 @@ func (s *Server) interpretInitFailure(initFailure interop.InitFailure, awaitingI
 	return resp, nil
 }
 
+// DrainInitFailure consumes (without any side effects) the init-failure notification left
+// behind after resetting a timed-out init. The reset aborts the in-progress init, leaving
+// awaitInitCompletion parked on the unbuffered initFailures channel with a ResetReceived
+// failure; if the first invoke's Reserve()/awaitInitialized() consumed that instead, it would
+// cache a generic placeholder error (Sandbox.Failure with an empty payload, see the
+// ErrInitResetReceived handling in Invoke) that later masks the real outcome of the suppressed
+// init re-run. Draining it here lets awaitInitialized() observe the closed channel and treat
+// the init outcome as pending, so the suppressed init's own result is authoritative.
+// The receive cannot block indefinitely: once the reset has completed, awaitInitCompletion is
+// committed to either sending the failure or closing the channel (init succeeded just before
+// the reset took effect).
+func (s *Server) DrainInitFailure() {
+	<-s.getInitFailuresChan()
+}
+
 // 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