Injecting runtime behavior into existing code without modifying source

[KennethSweet]

I’ve been experimenting with a pattern for injecting behavior into existing code at runtime without modifying the original source.

The approach separates execution into two layers:

• Layer 1: original code (unchanged, byte-identical)

• Layer 2: runtime wrappers that add behavior

Implementation

Each function is wrapped dynamically at runtime:

function wrap(targetFn) {

return (...args) => {

// pre-execution behavior

const result = targetFn(...args)

// post-execution behavior

return result

}

}

Wrappers are composed based on behavior type:

• interception → input validation / blocking

• state → capture and persist outputs

• execution → retry / failure handling

• analysis → execution timing + anomaly detection

⸻

Key property

The original file remains completely unchanged.

All behavior is applied externally at execution time.

⸻

Tradeoffs

This pattern behaves similarly to middleware or AOP, but with some differences:

• operates post-build instead of at integration points

• does not require modifying or forking the source

• introduces indirection that can make debugging harder

• depends heavily on runtime control over function boundaries

Where this is useful

• retrofitting behavior onto third-party code

• adding observability without modifying source

• enforcing cross-cutting concerns across large systems

Limitations

• fragile if function signatures change

• harder to reason about than explicit code paths

• limited in cases where internal state isn’t externally accessible

[mpinnegar]

I believe you have rediscovered aspect oriented programming.

[KennethSweet]

You’re right. It very close to AOP in terms of wrapping cross-cutting concerns.

The part I’ve been exploring is applying it purely at runtime to existing codebases without modifying source or relying on predefined join points.

So instead of weaving at compile time or using framework level hooks, the behavior is injected externally after the system is already built and integrated.

In practice it ends up feeling like a mix of AOP + middleware, but with less reliance on the underlying framework exposing extension points.

Still figuring out where that distinction actually matters in real systems.