Will your change reload?

Compile a supported edit into a watched output. Existing object fields remain on the JVM method-body-only path. Framework follow-up can separately recreate beans.

Next: Compile, check the same JVM and inspect the changed result.

Stock-JDK companion mode supports hot-compiled calls; new methods do not become native members of the original Class. Previously held removed members can retain their last implementation.

Next: Compile affected watched callers; use a supported framework adapter for reflection.

Stock mode stores added fields separately. Isolated initializers run on first read for existing objects; constructor-dependent or entangled initializers retain type defaults with a reason.

Next: Read the initializer diagnostic and verify an existing object.

Both owner and caller must be watched/reloaded in the measured direct-access shape. Field-type changes and every inherited/loader variant are not certified.

Next: Compile both sides and check the shared value on an existing object.

Compile-time constants and separable initializers, including bounded forward conditionals/switches, are supported. Existing static blocks and values are not reset.

Next: Check the new value and any extraction refusal reason.

Later saves preserve the current added static value, including null or application writes. Reload does not replay arbitrary static initialization.

Next: Restart to run startup initialization again; account for external side effects.

Callers can retain their old literal until recompiled. AutoCompile can rebuild detected watched sources; unwatched consumers remain outside that repair.

Next: Recompile affected callers or use supported AutoCompile.

Documented on JDK 17–25 with ordinal-preserving edits. Existing application arrays sized from the old enum length do not grow.

Next: Check enum consumers and any fixed-size application arrays.

The edit renumbers ordinals; Reclazz refuses it. Restart alone does not migrate persisted ordinal data.

Next: Review persisted ordinals and restart for the type change.

Requires a compatible enhanced-redefinition JVM such as JBR/DCEVM. Stock JVMs refuse the type change.

Next: Use a supported enhanced runtime or restart.

The loaded superclass stays unchanged. Eligible bodies may apply; dependent methods stay pinned and unsafe signatures/constructors can refuse the whole save.

Next: Read partial/refused reporting and restart for the hierarchy.

On stock JVMs the original Class lacks companion members. Explicit framework adapters have separate scope; arbitrary reflective consumers do not.

Next: Restart, or use a compatible enhanced JVM/explicitly supported adapter.

Java 17+ is the target. The main recorded portable lanes are stock SapMachine 17/21 on macOS arm64, not every vendor, OS or future JDK.

Next: Validate the exact runtime and change shape.

Supported bean paths destroy/recreate the singleton and repair bounded references. Mutable bean state can reset; arbitrary external holders are not repaired.

Next: Check lifecycle effects, current references and the served result.

Direct/composed stereotypes, native name/condition selection and singleton/prototype/lazy creation are supported. Not a repeat of full startup scanning.

Next: Compile the new class and check registration/condition outcome.

The new-component path refuses these scope shapes. Normal singleton/prototype support does not imply custom scope enrollment.

Next: Restart under the application’s normal configuration.

New-component conditions are registration-time decisions. General later rediscovery and startup import/auto-configuration replay are outside this path.

Next: Use a restart for a changed startup topology; validate any narrower path.

Bounded lite/full/static configuration paths support documented arguments, aliases, selection and direct conditions. Existing names/custom scopes/unknown composed conditions are restricted.

Next: Use the exact factory allowlist and check product identity/lifecycle.

Spring metadata caches are refreshed on supported bean paths. Recreation has state and reference limits; it is not an arbitrary graph rewrite.

Next: Check the recreated bean’s injection and lifecycle behavior.

Supported plain singletons use the javax Spring 5 / Jakarta Spring 6 lanes. Each instance keeps its added destroy callback through later edits/removal.

Next: Verify creation/injection/destruction for the affected instance.

Supported public singleton operations use native interceptors; bounded composed metadata is supported. Compile the caller and respect the proxy/advice allowlist.

Next: Verify commit/rollback or cache behavior, not only the method result.

Named classic/modern Spring Security graphs support direct and bounded composed policies. Unknown security infrastructure/advice shapes are refused.

Next: Check both allowed and denied calls with the installed security graph.

Updates supported existing mutable singleton JDK/CGLIB proxy chains. Previously unproxied targets and unsupported proxy shapes are outside this path.

Next: Check an already-injected reference and inspect unsupported targets.

Direct no-argument void callbacks on supported singletons, with documented proxy/transaction/cache/async combinations. Removal cancels the registration.

Next: Check one current schedule and retirement of its predecessor.

Direct callbacks with one reference event input and void/single-event return on supported singletons. Filtering/order/conditions and advice have bounded scope.

Next: Publish a test event; check current delivery and no stale registration.

Direct void methods on supported unproxied singletons; Spring handles phase/fallback/conditions/order. Reload retires queued callbacks from the old added registration.

Next: Check the intended transaction phase and a later edit/removal.

Direct public methods support void, Future and CompletableFuture with native executor/error handling and supported transaction/cache advice.

Next: Check execution, returned completion and exception handling.

Exact supported factories, plain two-node shapes and one measured direct-child context form. Aliases, broader graphs, proxies/factory products and lifecycle-owned shapes are excluded.

Next: Read the ownership contract and verify the retained caller’s value.

Supported controller mapping rescans include added methods on stock JVMs. Receiver, metadata and classloader shapes still matter.

Next: Compile and send a request to the intended route.

Plain controllers/advice and standard resolver on Framework 5.3.39/6.1.14; bounded synchronous metadata. Proxy/inheritance/generic/composed/custom resolver shapes are excluded.

Next: Check status/body and handler precedence; fix ambiguous mappings.

Supported plain controller/advice adapters preserve named binding, model rules and native advice order/selectors. Read the exact callback allowlist.

Next: Check a real binding/model request through the current controller.

Supported Spring-managed mapper adapter; mutable DTOs and saved annotations. Final added fields are not writable; creator/record/builder additions are excluded.

Next: Check JSON input and output against the installed Jackson version.

Jackson’s explicit adapter does not establish arbitrary Gson/custom mapper or record-creator support. Stock original-class reflection remains limited.

Next: Validate the serializer or restart for native reflective visibility.

Supported Hibernate Validator metadata caches are cleared in both javax/Jakarta factory discovery paths. Do not infer arbitrary validator/provider compatibility.

Next: Submit both invalid and valid input; inspect the native validation result.

Supported SecurityFilterChain beans rebuild into the live FilterChainProxy. Inline ignoring chains remain; a failed rebuild can keep the previous rules serving.

Next: Verify allowed and denied requests; inspect whether the new rules became live.

Plain singleton, direct callback, explicit literal ID, documented topic/group/options and standard record-mode factory. Native consumers retire before replacement.

Next: Verify message delivery, new route and old-consumer retirement.

Plain singleton with standard processor/registry/default container factory. Literal or placeholder destinations/selectors; bounded result and callback shapes.

Next: Verify delivery/selector behavior and complete consumer destruction.

Documented return types and direct @SendTo. JMSReplyTo takes priority; null sends nothing. No arbitrary DTO/Future/reactive return claim.

Next: Check conversion, correlation and destination on a test request.

Plain receiver, standard simple container, AUTO acknowledgment/default executor and bounded queue/options. Startup worker hook must track complete retirement.

Next: Wait for worker retirement and verify real message delivery.

Documented native SpEL values are reevaluated when the listener is saved. Evaluation occurs after old consumers retire and can fail without restoring them.

Next: Save the listener again and check the exact route/group.

The documented added Kafka/Rabbit expression path does not automatically reroute on a property/bean-only edit; a listener re-save is the supported live action.

Next: Re-save/compile the listener, or restart for native startup resolution.

Separately measured narrow root-context leaf-owner transactions; exact factories, constructor and callback shapes. Not arbitrary consumer graphs.

Next: Use the constructor ownership guide and check current-value delivery.

Measured on Framework 5.3.39/AMQP 2.4.17 and Framework 6.1.14/AMQP 3.1.7, stock JDK 17/21 on macOS arm64: one root context, plain local helper/leaf owner, one void literal-ID callback, native simple containers, AUTO acknowledgment and nontransacted channels.

Next: Verify current helper/owner values and complete worker retirement; unsupported ownership, stop timeout or partial reconstruction requires restart.

Unsupported mixed ownership is refused before owned consumers retire. Single-broker coordination is not a combined broker transaction.

Next: Separate the ownership shape or restart.

Local broker observations do not certify every hosted/failure/transactional topology. Rabbit reply/async and broader custom container paths are separate gaps.

Next: Run targeted acceptance for your broker, lifecycle and delivery policy.

Candidate binding/conversion/validation occurs before live mutation. Uncheckable/invalid candidates remain pending; live setter/recreation failure can partially apply.

Next: Fix rejected input, save again and inspect actual runtime values.

Already-loaded local Boot resources with stable source/document ownership. Current native lane is Boot 2.7.18 / SnakeYAML 1.30, not all Boot versions.

Next: Edit the actual runtime file and inspect source precedence.

Removal reveals lower-priority values/defaults in the supported source path. Mutable property identities are preserved; read-only/write-only removal shapes are uncheckable.

Next: Verify resulting defaults and supported consumer rebinding.

Stable source positions/document activation are prerequisites. Startup config topology is not rebuilt by a value save.

Next: Restart with the new startup configuration.

Fields, scalar constructor inputs and supported factory arguments have distinct check/recreation paths. Unsupported expression operations hold the candidate.

Next: Check the documented expression/consumer shape before retrying.

Resolved local file/context ownership plus supported value shape. Setter errors can preserve metadata but still have application side effects.

Next: Inspect the property result and independent-bean diagnostics.

Bounded ordinary singleton recreation, stable concrete type/ownership and supported direct holders. Native observer: Spring 5.3.39 / JDK 21.

Next: Check creation/destruction, repaired references and any restore failure.

Existing metadata changes such as depends-on/primary/autowire/effective lazy flag are guarded. Supported property edits do not rebuild startup policy.

Next: Follow the bean-specific restart diagnostic.

A proven unchanged standard definition stays quiet, including known abstract/prototype shapes. Unknown/custom metadata retains conservative diagnostics.

Next: Expect no reconstruction; real unsupported edits still require restart.

Captured-local discovery does not cover remote/JAR resources, pre-hook loads or a general import-topology rebuild.

Next: Edit the actually owned local resource or restart.

Named native Spring message-source/cache lanes; arbitrary custom basenames and automatic source-to-output copying are not established.

Next: Edit the runtime file and check a warmed formatted lookup.

Named FreeMarker/Thymeleaf file-resolver lanes. Malformed saves can produce render errors; last-valid retention is not promised.

Next: Render the current output; fix malformed input and retry.

Physical-file observers do not establish packaged-resource replacement or arbitrary view-resolver integration.

Next: Use unpacked recognized runtime resources or restart/redeploy.

Supported logging.level keys or logback/log4j2 config refresh. Removing a level without a fallback can still need reset/restart.

Next: Verify the target logger; keep SAP property pairs separate.

ChangeKind recognizes specific suffixes and owned resources. Unknown kinds have no Reclazz reload action; another framework may independently serve the file.

Next: Check the resource classifier and your application’s own resource pipeline.

Requires enhanced visibility plus supported jpaRefresh=true/DDL-enabled mapping path; stock companion fields are not native ORM members.

Next: Prepare schema/mapping prerequisites or restart.

jpaRefresh=true, explicit Hibernate validate, one unit and standard provider/factory in the recorded graph. No automatic migration or update-mode switch.

Next: Prepare table/columns, compile and verify native mapping installation.

Failed candidate leaves the previous factory open before install. Identical bytes are ignored; changing pending mapping declarations is refused.

Next: Fix schema, then compile a body-only edit to the same pending entity.

A successful persistence-unit swap retires the old native factory. Holding active old contexts across it is unsupported.

Next: Finish database work first; restart/recover unsupported retained contexts.

Warm singleton Repository products and bounded direct holder repair. Scalar H2 native-query evidence does not cover new interface methods/all query shapes.

Next: Check the query result and the retained managed consumer.

Observed synchronous Spring cache dependencies in stock companion mode; region-level conservative eviction. Async/unwatched/pre-attach work is not complete.

Next: Exercise the cache first, reload and check next-call freshness.

refreshOwnersOnHelper opt-in for supported singleton owners. Non-singletons, FactoryBeans and event-listener owners are declined.

Next: Name the eligible owner and check lifecycle/state reset.

Platform generation/build can reload generated classes. Persistence/type-system updates and native reflection are separate requirements.

Next: Verify generated bytecode; update the platform schema when required.

Manual HAC action is separate from reload. autoUpdateRunningSystem=true is a distinct off-by-default dev-only DDL opt-in.

Next: Choose the schema action explicitly and verify the type/persistence result.

Changed keys reach the Config path; successful keys acknowledge independently. Startup-only consumers are still reported as restart-required.

Next: Check each key’s runtime consumer and pending status.

Recognized physical locale/label files refresh the platform caches they serve. Broader tenant/cluster acceptance is not implied.

Next: Check a new lookup or reopen the affected Backoffice view.

autoImpex=true opt-in writes live development data. REMOVE/macro-expanded REMOVE is refused unless separately permitted; no rollback.

Next: Use disposable data; inspect import results and guard diagnostics.

Mappings are captured before bean refresh and re-registered in the actual SAP registry. SDK contract is not live model-save tenant acceptance.

Next: Check the registry result and a relevant live model operation.

Dedicated field-set/request-mapping/populator/list-merge paths have individual ownership and registration limits. Not arbitrary platform topology reload.

Next: Read the matching path and verify the actual OCC response.

The extension list is established at startup. Generated-bytecode reload does not enroll a new extension.

Next: Build the platform and restart.

The source resets supported CockpitConfigurationService caches through Resettable.reset, without resetToDefaults. Packaged module copies can still answer until rebuilt.

Next: Reopen the view and verify the actual loaded configuration; build a packaged copy if needed.

Class replacement does not register the new action in existing widgets. Existing action-body edits use ordinary class reload; label/config caches are separate.

Next: Read the widget-specific PENDING entry and restart to register the added action.

Recognized local process-definition resources produce a diagnostic only. No running process is changed or replayed; unrelated XML does not become a process resource by name.

Next: Validate the definition and restart to load it.

The running JVM startup classpath is not replaced by watching class outputs.

Next: Restart with the updated launch classpath.

reloadBoundary=request at startup, supported native MVC hook/lifetimes. Drain deadline defers; it is not batch/schema/background atomicity.

Next: Check the measured servlet graph and queued-work diagnostics.

Build admission holds output until a successful captured batch; SCAN alone cannot release the hold. Manual pause is an independent switch.

Next: Complete the build, release the correct hold and verify completion.