fix(rivetkit): tune legacy runner thresholds in development

.github/workflows/publish.yaml

@@ -580,6 +580,13 @@ jobs:
             --retries 3 \
             ${{ needs.context.outputs.trigger == 'release' && '--release-mode' || '' }}
 
+      - name: Generate engine checksum manifest
+        run: |
+          (
+            cd engine-artifacts
+            sha256sum rivet-engine-* > SHA256SUMS
+          )
+
       - name: Upload engine binaries to R2
         env:
           R2_RELEASES_ACCESS_KEY_ID: ${{ secrets.R2_RELEASES_ACCESS_KEY_ID }}

rivetkit-rust/packages/engine-process/src/lib.rs

@@ -367,7 +367,9 @@ fn pid_is_alive(_pid: u32) -> bool {
 ///
 /// Shared by the spawn path and by callers that exec the engine binary
 /// directly (for example the CLI `engine` proxy) so both operate on the same
-/// database, guard, api-peer, and metrics ports.
+/// database, guard, api-peer, and metrics ports. These callers are local
+/// development processes, so the Engine recovery and shutdown thresholds are
+/// intentionally shorter than the production defaults.
 pub fn engine_env(config: &EngineResolverConfig) -> Result<Vec<(String, String)>> {
 	let endpoint = &config.endpoint;
 	let endpoint_url =
@@ -400,6 +402,50 @@ pub fn engine_env(config: &EngineResolverConfig) -> Result<Vec<(String, String)>
 			"RIVET__FILE_SYSTEM__PATH".to_owned(),
 			db_path.to_string_lossy().into_owned(),
 		),
+		(
+			"RIVET__PEGBOARD__RETRY_RESET_DURATION".to_owned(),
+			"100".to_owned(),
+		),
+		(
+			"RIVET__PEGBOARD__BASE_RETRY_TIMEOUT".to_owned(),
+			"100".to_owned(),
+		),
+		(
+			"RIVET__PEGBOARD__RESCHEDULE_BACKOFF_MAX_EXPONENT".to_owned(),
+			"1".to_owned(),
+		),
+		(
+			"RIVET__PEGBOARD__RUNNER_ELIGIBLE_THRESHOLD".to_owned(),
+			"5000".to_owned(),
+		),
+		(
+			"RIVET__PEGBOARD__RUNNER_LOST_THRESHOLD".to_owned(),
+			"7000".to_owned(),
+		),
+		(
+			"RIVET__PEGBOARD__ENVOY_ELIGIBLE_THRESHOLD".to_owned(),
+			"5000".to_owned(),
+		),
+		(
+			"RIVET__PEGBOARD__ENVOY_LOST_THRESHOLD".to_owned(),
+			"7000".to_owned(),
+		),
+		(
+			"RIVET__PEGBOARD__MIN_METADATA_POLL_INTERVAL".to_owned(),
+			"1000".to_owned(),
+		),
+		(
+			"RIVET__RUNTIME__WORKER_SHUTDOWN_DURATION".to_owned(),
+			"1".to_owned(),
+		),
+		(
+			"RIVET__RUNTIME__GUARD_SHUTDOWN_DURATION".to_owned(),
+			"1".to_owned(),
+		),
+		(
+			"RIVET__RUNTIME__FORCE_SHUTDOWN_DURATION".to_owned(),
+			"2".to_owned(),
+		),
 	])
 }
 
@@ -991,6 +1037,24 @@ mod tests {
 		assert_eq!(resolve_bind_host(&config).unwrap(), "0.0.0.0");
 	}
 
+	#[test]
+	fn engine_env_uses_development_recovery_thresholds() {
+		let env = engine_env(&test_config(String::new(), false)).expect("build engine env");
+		let env = env.into_iter().collect::<HashMap<_, _>>();
+
+		assert_eq!(env["RIVET__PEGBOARD__RETRY_RESET_DURATION"], "100");
+		assert_eq!(env["RIVET__PEGBOARD__BASE_RETRY_TIMEOUT"], "100");
+		assert_eq!(env["RIVET__PEGBOARD__RESCHEDULE_BACKOFF_MAX_EXPONENT"], "1");
+		assert_eq!(env["RIVET__PEGBOARD__RUNNER_ELIGIBLE_THRESHOLD"], "5000");
+		assert_eq!(env["RIVET__PEGBOARD__RUNNER_LOST_THRESHOLD"], "7000");
+		assert_eq!(env["RIVET__PEGBOARD__ENVOY_ELIGIBLE_THRESHOLD"], "5000");
+		assert_eq!(env["RIVET__PEGBOARD__ENVOY_LOST_THRESHOLD"], "7000");
+		assert_eq!(env["RIVET__PEGBOARD__MIN_METADATA_POLL_INTERVAL"], "1000");
+		assert_eq!(env["RIVET__RUNTIME__WORKER_SHUTDOWN_DURATION"], "1");
+		assert_eq!(env["RIVET__RUNTIME__GUARD_SHUTDOWN_DURATION"], "1");
+		assert_eq!(env["RIVET__RUNTIME__FORCE_SHUTDOWN_DURATION"], "2");
+	}
+
 	#[cfg(unix)]
 	#[test]
 	fn pid_is_alive_true_for_self_false_for_missing() {

scripts/run/dev-env.sh

@@ -1,17 +1,21 @@
 # Development environment variables for running the Rivet engine locally.
 # Source this file before running the engine: source scripts/run/dev-env.sh
 #
-# NOTE: When modifying these env vars, also update the env block in
-# rivetkit-typescript/packages/rivetkit/src/engine-process/mod.ts to keep them in sync.
+# NOTE: When modifying these env vars, also update `engine_env` in
+# rivetkit-rust/packages/engine-process/src/lib.rs to keep them in sync.
 
-# Reduce backoff for runner recovery (in milliseconds)
+# Reduce backoff for actor recovery (in milliseconds)
 export RIVET__PEGBOARD__RETRY_RESET_DURATION="100"
 export RIVET__PEGBOARD__BASE_RETRY_TIMEOUT="100"
 export RIVET__PEGBOARD__RESCHEDULE_BACKOFF_MAX_EXPONENT="1"
 
 # Reduce thresholds for faster development iteration (in milliseconds)
+# Legacy runner paths still exist in older Engine builds, while RivetKit uses
+# the Envoy path. Keep both tuned for local development.
 export RIVET__PEGBOARD__RUNNER_ELIGIBLE_THRESHOLD="5000"
 export RIVET__PEGBOARD__RUNNER_LOST_THRESHOLD="7000"
+export RIVET__PEGBOARD__ENVOY_ELIGIBLE_THRESHOLD="5000"
+export RIVET__PEGBOARD__ENVOY_LOST_THRESHOLD="7000"
 
 # Allow faster metadata polling for hot-reload in development (in milliseconds)
 export RIVET__PEGBOARD__MIN_METADATA_POLL_INTERVAL="1000"