fix(init): keep container alive on hot-reload reset during init

A hot-reload code change detected while the init phase is still running
fires Reset("HotReload"), which aborts init with ErrInitResetReceived.
main.go treated this as terminal and returned, killing the container and
failing the in-flight invocation.

When hot reloading is enabled, wait for the in-flight reset to complete
(ordering the reset's Server.Release before the ready signal so it cannot
cancel the first invoke's reservation), then fall through to signal ready
and keep the container alive, letting the next invoke re-init with the
reloaded code via suppressed init. Non-hot-reload resets (sandbox teardown,
standalone /test/reset) still exit as before.

CustomInteropServer gains a buffered resetDone signal, fired non-blockingly
after delegate.Reset returns, that the main flow waits on.

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

Author: joe4dev

cmd/localstack/awsutil.go

@@ -156,8 +156,15 @@ func resetListener(changeChannel <-chan bool, server *CustomInteropServer) {
 
 }
 
+// isHotReloadingEnabled reports whether hot reloading is configured. When
+// LOCALSTACK_HOT_RELOADING_PATHS is unset, strings.Split yields a single empty
+// element, which means disabled.
+func isHotReloadingEnabled(targetPaths []string) bool {
+	return !(len(targetPaths) == 1 && targetPaths[0] == "")
+}
+
 func RunHotReloadingListener(server *CustomInteropServer, targetPaths []string, ctx context.Context, fileWatcherStrategy string) {
-	if len(targetPaths) == 1 && targetPaths[0] == "" {
+	if !isHotReloadingEnabled(targetPaths) {
 		log.Debugln("Hot reloading disabled.")
 		return
 	}

cmd/localstack/custom_interop.go

@@ -38,6 +38,11 @@ type CustomInteropServer struct {
 	// LocalStack instead of a synthesized one. Written from the runtime API handler flow and
 	// read from the main flow after init failed, hence atomic.
 	initErrorPayload atomic.Value
+	// resetDone signals (non-blocking, buffered-1) that a Reset has fully completed
+	// — i.e. delegate.Reset returned after the underlying Server.Release. The main flow
+	// waits on this when a hot-reload reset aborts the init phase, so the ready signal is
+	// ordered after the reset's Release and cannot cancel the first invoke's reservation.
+	resetDone chan struct{}
 }
 
 type LocalStackAdapter struct {
@@ -109,6 +114,7 @@ func NewCustomInteropServer(lsOpts *LsOpts, delegate interop.Server, logCollecto
 			RuntimeId:        lsOpts.RuntimeId,
 		},
 		eventsAPI: eventsAPI,
+		resetDone: make(chan struct{}, 1),
 	}
 
 	// TODO: extract this
@@ -339,7 +345,15 @@ func (c *CustomInteropServer) Reserve(id string, traceID, lambdaSegmentID string
 
 func (c *CustomInteropServer) Reset(reason string, timeoutMs int64) (*statejson.ResetDescription, error) {
 	log.Traceln("Reset called")
-	return c.delegate.Reset(reason, timeoutMs)
+	resp, err := c.delegate.Reset(reason, timeoutMs)
+	// delegate.Reset has returned, so the reset (including Server.Release) is complete.
+	// Signal a waiter (the main flow on a hot-reload reset during init) without blocking
+	// normal post-init reloads, which have no reader.
+	select {
+	case c.resetDone <- struct{}{}:
+	default:
+	}
+	return resp, err
 }
 
 func (c *CustomInteropServer) AwaitRelease() (*statejson.ReleaseResponse, error) {

cmd/localstack/main.go

@@ -266,6 +266,7 @@ func main() {
 	if err != nil {
 		log.Fatalln(err)
 	}
+	hotReloadEnabled := isHotReloadingEnabled(lsOpts.HotReloadingPaths)
 	go RunHotReloadingListener(interopServer, lsOpts.HotReloadingPaths, fileWatcherContext, lsOpts.FileWatcherStrategy)
 
 	log.Debugf("Awaiting initialization of runtime api at %s.", runtimeAPIAddress)
@@ -352,10 +353,21 @@ func main() {
 		// INIT_REPORT(phase=invoke) line for the retried (folded-in) init.
 		log.Debugln("Init failed; deferring to first invocation (on-demand suppressed init).")
 	case errors.Is(initErr, rapidcore.ErrInitResetReceived):
-		// An external reset (e.g. hot reloading) aborted the init phase: exit without
-		// reporting an init error; the container exit surfaces the failure.
-		log.Errorln("Runtime init was reset before completing. Exiting.")
-		return
+		if !hotReloadEnabled {
+			// A reset aborted the init phase (e.g. sandbox teardown or a standalone
+			// /test/reset): exit without reporting an init error; the container exit
+			// surfaces the failure.
+			log.Errorln("Runtime init was reset before completing. Exiting.")
+			return
+		}
+		// Hot reloading aborted the in-progress init. Reset("HotReload") has already
+		// cleared rapidcore state (s.Clear + runtimeNotStarted) for a fresh suppressed
+		// init at the first invocation. Wait for that reset to finish so its Server.Release
+		// is ordered before the ready signal below (otherwise a late Release could cancel
+		// the first invoke's reservation), then fall through to signal ready and keep the
+		// container alive so the next invoke re-inits with the reloaded code.
+		log.Infoln("Runtime init was reset by hot reloading; deferring to suppressed init on first invocation.")
+		<-interopServer.resetDone
 	default:
 		// Provisioned concurrency / Managed Instances: report the failure now and exit,
 		// failing the provisioning operation. ReportInitFailure forwards the runtime's own