diff --git a/.squad/agents/jubilee/history.md b/.squad/agents/jubilee/history.md
index e3273590..c629f92b 100644
--- a/.squad/agents/jubilee/history.md
+++ b/.squad/agents/jubilee/history.md
@@ -473,3 +473,16 @@ This wave establishes **documentation patterns** that will guide future control
 - **Page uses `@inject ClientScriptShim ClientScript`** — injected as scoped service. Calls `FlushAsync(JS)` in `OnAfterRenderAsync` since the page doesn't inherit BaseWebFormsComponent.
 - **Pattern:** Source code section at bottom showing complete `@code` block with escaped `@@` directives for display. Follows established migration demo conventions.
 - **Build verified:** 0 errors, pre-existing BL0005 warnings only.
+
+### PostBack & ScriptManager Demo Page (ClientScript Phase 2)
+
+- **Created** `samples/AfterBlazorServerSide/Components/Pages/ControlSamples/PostBackDemo/Index.razor` — three-section demo page for Phase 2 ClientScript postback shims.
+- **Section 1: GetPostBackEventReference** — button with `onclick="@_postBackScript"` fires `__doPostBack` from JS. PostBack event on WebFormsPageBase receives it server-side. Stable IDs: `postback-button`, `postback-script`, `postback-result`.
+- **Section 2: GetPostBackClientHyperlink** — anchor `href="@_postBackHyperlink"` triggers postback via `javascript:__doPostBack(...)` URL. Stable IDs: `postback-link`, `hyperlink-script`, `hyperlink-result`.
+- **Section 3: ScriptManager.GetCurrent** — uses `ScriptManagerShim.GetCurrent(this)` to register startup script that writes into `#scriptmanager-target`. Same Web Forms code pattern.
+- **Source Code section** at bottom with escaped `@@` directives.
+- **Inherits WebFormsPageBase** (not `@inject`) — gives access to `ClientScript`, `PostBack` event, and `ScriptManagerShim.GetCurrent(this)`. This differs from the ClientScriptShim demo which uses `@inject`.
+- **Updated** `ComponentCatalog.cs` — added "PostBack Demo" entry in "Migration Helpers" category after "IsPostBack".
+- **Updated** `ComponentList.razor` — added PostBack & ScriptManager link in Migration Helpers section.
+- **Build verified:** 0 errors, pre-existing BL0005 warnings only.
+- **Lesson:** Pages that need the PostBack event must `@inherits WebFormsPageBase`. The ClientScript property is available via inheritance (no separate `@inject` needed). `OnAfterRenderAsync` in WebFormsPageBase handles `FlushAsync` automatically.
diff --git a/docs/Analyzers/BWFC022.md b/docs/Analyzers/BWFC022.md
index 17118ca7..3704ca9a 100644
--- a/docs/Analyzers/BWFC022.md
+++ b/docs/Analyzers/BWFC022.md
@@ -78,7 +78,7 @@ If you prefer to modernize your code now, rewrite to `IJSRuntime` directly. The
 | `RegisterStartupScript()` | `ClientScriptShim` (⭐ Easy) or `OnAfterRenderAsync()` + `IJSRuntime` (⭐⭐ Moderate) | ⭐ Easy |
 | `RegisterClientScriptInclude()` | `ClientScriptShim` (⭐ Easy) or `<script>` tag in layout (⭐ Easy) | ⭐ Easy |
 | `RegisterClientScriptBlock()` | `ClientScriptShim` (⭐ Easy) or JS module (⭐ Easy) | ⭐ Easy |
-| `GetPostBackEventReference()` | `@onclick` or `EventCallback<T>` | ⭐⭐ Medium |
+| `GetPostBackEventReference()` | `ClientScriptShim` (⭐ Easy — Phase 2) or `@onclick` / `EventCallback<T>` (⭐⭐ Medium) | ⭐ Easy |
 
 ### Common Fix: Startup Script
 
@@ -144,7 +144,17 @@ If you prefer to modernize your code now, rewrite to `IJSRuntime` directly. The
     }
     ```
 
-=== "Blazor (After)"
+=== "Blazor (After — Phase 2 with Shim, Zero Rewrite)"
+    ```csharp
+    // Same code works! ClientScriptShim returns __doPostBack() string
+    public string GetDeleteButtonScript()
+    {
+        return ClientScript.GetPostBackEventReference(
+            new PostBackOptions(btnDelete, "clicked"));
+    }
+    ```
+
+=== "Blazor (Modern Approach)"
     ```razor
     <button @onclick="HandleDelete">Delete</button>
     
diff --git a/docs/Analyzers/BWFC024.md b/docs/Analyzers/BWFC024.md
index c92a3262..35a6e220 100644
--- a/docs/Analyzers/BWFC024.md
+++ b/docs/Analyzers/BWFC024.md
@@ -11,12 +11,14 @@
 
 This analyzer warns when you use `ScriptManager` code-behind methods like `GetCurrent()`, `SetFocus()`, `RegisterAsyncPostBackControl()`, and similar — Web Forms APIs for managing client scripts and UpdatePanel behavior.
 
+**Note:** Phase 2 now includes support for `GetCurrent()` and script registration methods via `ScriptManagerShim`. Methods like `SetFocus()` and `RegisterAsyncPostBackControl()` still require modernization.
+
 **Detected patterns:**
-- `ScriptManager.GetCurrent(Page)` / `ScriptManager.GetCurrent(this)`
-- `.SetFocus(control)`
-- `.RegisterAsyncPostBackControl(control)`
-- `.RegisterUpdateProgress(...)`
-- `.RegisterPostBackControl(...)`
+- `ScriptManager.GetCurrent(Page)` / `ScriptManager.GetCurrent(this)` — ✅ Phase 2 supported
+- `.SetFocus(control)` — ❌ Still requires JS interop
+- `.RegisterAsyncPostBackControl(control)` — ❌ Still requires component binding
+- `.RegisterUpdateProgress(...)` — ❌ Still requires component state
+- `.RegisterPostBackControl(...)` — ❌ Not supported
 
 ---
 
@@ -60,7 +62,36 @@ These methods have **no direct equivalents**. Each requires a different approach
 
 ## How to Fix
 
-The fix depends on **which** ScriptManager method you're using.
+The fix depends on **which** ScriptManager method you're using and which Phase you're in.
+
+### ✅ Phase 2: GetCurrent() and Script Registration Methods
+
+`ScriptManager.GetCurrent()` now returns a working `ScriptManagerShim` that delegates to `ClientScriptShim`.
+
+=== "Web Forms (Before)"
+    ```csharp
+    protected void Page_Load(object sender, EventArgs e)
+    {
+        ScriptManager sm = ScriptManager.GetCurrent(Page);
+        sm.RegisterStartupScript(this.GetType(), "init", "initPage();", true);
+    }
+    ```
+
+=== "Blazor (After — Phase 2, Zero Rewrite)"
+    ```csharp
+    protected override void OnInitialized()
+    {
+        // Same code works! ScriptManagerShim returns the component's ClientScriptShim
+        ScriptManager sm = ScriptManager.GetCurrent(this);
+        sm.RegisterStartupScript(this.GetType(), "init", "initPage();", true);
+    }
+    ```
+
+---
+
+### Still Requiring Modernization
+
+Other ScriptManager methods still require refactoring. See the fixes below.
 
 ### Fix 1: SetFocus() → JavaScript Interop
 
@@ -245,7 +276,7 @@ await module.InvokeVoidAsync("focusElement", searchBox);
 
 | Web Forms Method | Blazor Equivalent | Approach |
 |---|---|---|
-| `GetCurrent(Page)` | — | Remove; use component state |
+| `GetCurrent(Page)` | `ScriptManager.GetCurrent(this)` (Phase 2 — Zero Rewrite) | Easy |
 | `.SetFocus(control)` | `JS.InvokeVoidAsync("focus", @ref)` | JavaScript interop |
 | `.RegisterAsyncPostBackControl()` | Component parameter binding | Remove; use `@bind` or `EventCallback` |
 | `.RegisterPostBackControl()` | — | Remove; not needed in Blazor |
diff --git a/docs/Migration/ClientScriptMigrationGuide.md b/docs/Migration/ClientScriptMigrationGuide.md
index e71c738d..09aed7cf 100644
--- a/docs/Migration/ClientScriptMigrationGuide.md
+++ b/docs/Migration/ClientScriptMigrationGuide.md
@@ -66,9 +66,9 @@ Inject `ClientScriptShim` and use it the same way:
 | `IsStartupScriptRegistered(Type, string)` | ✅ Supported | Deduplication check |
 | `IsClientScriptBlockRegistered(Type, string)` | ✅ Supported | Deduplication check |
 | `IsClientScriptIncludeRegistered(string)` | ✅ Supported | Deduplication check |
-| `GetPostBackEventReference(...)` | ❌ Throws | Use `@onclick` / `EventCallback<T>` instead |
-| `GetPostBackClientHyperlink(...)` | ❌ Throws | Use `NavigationManager` or `<a>` tags |
-| `GetCallbackEventReference(...)` | ❌ Throws | Use `IJSRuntime` + `EventCallback<T>` |
+| `GetPostBackEventReference(...)` | ✅ Supported (Phase 2) | Returns `__doPostBack()` string; handled by postback shim |
+| `GetPostBackClientHyperlink(...)` | ✅ Supported (Phase 2) | Returns hyperlink-compatible postback string |
+| `GetCallbackEventReference(...)` | ✅ Supported (Phase 2) | Returns callback bridge string; requires JS handler |
 
 ### How It Works Internally
 
@@ -462,10 +462,11 @@ For truly global scripts, you can inline them in `index.html` or the layout:
 
 ### What It Does
 
-`GetPostBackEventReference()` generates a dynamic JavaScript call to trigger a postback event, often used in client-side event handlers that need to notify the server.
+`GetPostBackEventReference()` generates a dynamic JavaScript call to trigger a postback event, often used in client-side event handlers that need to notify the server. **Phase 2 now includes a working shim for this pattern.**
 
-### Web Forms
+### 🎯 Easiest Approach: ClientScriptShim (Phase 2 — Zero Rewrite)
 
+**Web Forms:**
 ```csharp
 public string GetDeleteButtonScript()
 {
@@ -481,74 +482,360 @@ public string GetDeleteButtonScript()
 // <a href='<%# GetDeleteButtonScript() %>'>Delete</a>
 ```
 
-When the user clicks the link, `__doPostBack()` POSTs the form back to the server with event data.
+**Blazor with BWFC — Zero rewrite!**
+```csharp
+// Same code works! ClientScriptShim returns a working __doPostBack() JS string
+public string GetDeleteButtonScript()
+{
+    return ClientScript.GetPostBackEventReference(
+        new PostBackOptions(btnDelete, "clicked")
+        {
+            PerformValidation = false
+        });
+}
 
-### Blazor Equivalent
+// Usage in markup:
+// <a href="@GetDeleteButtonScript()">Delete</a>
+```
 
-Blazor has **no `__doPostBack()` equivalent** because there's no postback cycle. Instead, bind a click handler directly to a component method using `@onclick` or `EventCallback`:
+### How It Works (Phase 2)
+
+1. **`GetPostBackEventReference()` returns `__doPostBack('controlId', 'arg')`** — the exact same function name as Web Forms.
+
+2. **BWFC ships `bwfc-postback.js`** which defines `__doPostBack()` as a JavaScript bridge function:
+   ```javascript
+   window.__doPostBack = async function(eventTarget, eventArgument) {
+       // Bridge back into Blazor via JS interop
+       await DotNet.invokeMethodAsync('BlazorWebFormsComponents', 'HandlePostBackFromJs', 
+           eventTarget, eventArgument);
+   };
+   ```
+
+3. **The page registers itself as a postback target** in `OnAfterRenderAsync`, exposing a .NET callback method via `DotNetObjectReference`.
+
+4. **When JavaScript calls `__doPostBack()`**, it invokes the .NET `HandlePostBackFromJs` method via JS interop, which fires the page's `PostBack` event.
+
+5. **Your C# code handles the PostBack event**, just like Web Forms:
+   ```csharp
+   @code {
+       protected override void OnInitialized()
+       {
+           PostBack += (sender, args) =>
+           {
+               // args.EventTarget — the control that triggered the postback
+               // args.EventArgument — the argument passed
+               HandleMyPostBack(args.EventTarget, args.EventArgument);
+           };
+       }
+       
+       private void HandleMyPostBack(string eventTarget, string eventArgument)
+       {
+           if (eventTarget == "btnDelete" && eventArgument == "clicked")
+           {
+               DeleteItem();
+           }
+       }
+   }
+   ```
+
+### Usage Pattern
+
+Use `GetPostBackEventReference()` in data-bound attributes or JavaScript event handlers that need to trigger server-side actions:
+
+```razor
+@foreach (var item in items)
+{
+    <a href="@ClientScript.GetPostBackEventReference(item, "edit")">
+        Edit
+    </a>
+    <a href="@ClientScript.GetPostBackEventReference(item, "delete")">
+        Delete
+    </a>
+}
+
+@code {
+    protected override void OnInitialized()
+    {
+        PostBack += (sender, args) =>
+        {
+            if (args.EventArgument == "edit")
+            {
+                EditItem(args.EventTarget);
+            }
+            else if (args.EventArgument == "delete")
+            {
+                DeleteItem(args.EventTarget);
+            }
+        };
+    }
+}
+```
+
+### Alternative: Modern Blazor Approach
+
+If you prefer to modernize away from postback patterns, use `@onclick` or `EventCallback` instead:
 
 === "Simple Case: @onclick"
     ```razor
-    <button @onclick="HandleDelete">Delete</button>
+    @foreach (var item in items)
+    {
+        <button @onclick="() => EditItem(item.Id)">Edit</button>
+        <button @onclick="() => DeleteItem(item.Id)">Delete</button>
+    }
     
     @code {
-        private async Task HandleDelete()
-        {
-            // Handle delete directly in component
-            await DeleteItem();
-        }
+        private async Task EditItem(int itemId) { ... }
+        private async Task DeleteItem(int itemId) { ... }
     }
     ```
 
 === "Parameterized Case: EventCallback"
     ```razor
     <!-- Parent component -->
-    <ChildComponent ItemId="@itemId" OnDelete="HandleDelete" />
+    @foreach (var item in items)
+    {
+        <ChildComponent Item="@item" OnEdit="HandleEdit" OnDelete="HandleDelete" />
+    }
     
     @code {
-        private async Task HandleDelete(int itemId)
-        {
-            await DeleteItemAsync(itemId);
-        }
+        private async Task HandleEdit(Item item) { ... }
+        private async Task HandleDelete(Item item) { ... }
     }
     
     <!-- ChildComponent.razor -->
-    @inject NavigationManager Nav
-    
-    <button @onclick="RaiseDelete">Delete</button>
-    
     @code {
         [Parameter]
-        public int ItemId { get; set; }
+        public Item Item { get; set; }
         
         [Parameter]
-        public EventCallback<int> OnDelete { get; set; }
+        public EventCallback<Item> OnEdit { get; set; }
         
-        private async Task RaiseDelete()
-        {
-            await OnDelete.InvokeAsync(ItemId);
-        }
+        [Parameter]
+        public EventCallback<Item> OnDelete { get; set; }
+        
+        private async Task RaiseEdit() => await OnEdit.InvokeAsync(Item);
+        private async Task RaiseDelete() => await OnDelete.InvokeAsync(Item);
     }
     ```
 
 ### Key Differences
 
-| Aspect | Web Forms | Blazor |
-|--------|-----------|--------|
-| **Mechanism** | JavaScript `__doPostBack()` → HTTP POST | Direct component method call |
-| **Server roundtrip** | Full page reload on postback | Blazor diff sync (no page reload) |
-| **Validation** | Server-side `Page.IsValid` | `EditContext`-based validation |
-| **Event data** | Form-encoded POST body | Method parameters |
+| Aspect | Web Forms | Blazor (Phase 2 with Shim) | Blazor (Modern) |
+|--------|-----------|--------------------------|----------------|
+| **Mechanism** | `__doPostBack()` → HTTP POST | `__doPostBack()` → JS interop → .NET | Direct component method call |
+| **Server roundtrip** | Full page reload | Blazor diff sync (no page reload) | Instant (no roundtrip) |
+| **Compatibility** | Zero rewrite | Zero rewrite | Requires refactoring |
+| **Best for** | Code migration (Phase 1) | Code migration (Phase 2) | New development |
+
+---
+
+## 5. Callback Event References (Phase 2)
+
+### What It Does
+
+`GetCallbackEventReference()` generates a JavaScript callback bridge for server callback processing (AJAX-style communication without UpdatePanel). **Phase 2 includes a working shim for this pattern.**
+
+### Web Forms
+
+```csharp
+protected void Page_Load(object sender, EventArgs e)
+{
+    string callback = Page.ClientScript.GetCallbackEventReference(
+        this, 
+        "arg",           // JavaScript argument to pass
+        "onSuccess",     // JavaScript function to call on success
+        "ctx",           // Context object to pass to callback
+        "onError",       // JavaScript function to call on error
+        true);           // useAsync
+    
+    // Inject the callback string into a JavaScript function
+    Page.ClientScript.RegisterStartupScript(this.GetType(), "initCallback",
+        $"var callback = '{callback}'; " +
+        "function myCallback(arg) { callback(arg); }",
+        true);
+}
+
+// In markup:
+// <button onclick="myCallback('someData')">Call Server</button>
 
-### When to Use Each
+// Server-side callback handler:
+public void RaiseCallbackEvent(string eventArgument)
+{
+    // Process eventArgument and prepare return value
+}
 
-- **`@onclick`** — Simple button click, no complex validation
-- **`EventCallback<T>`** — Parent/child communication, reusable components
-- **Form handlers** — For multi-field validation, use `EditForm` + `EditContext`
+public string GetCallbackResult()
+{
+    // Return result to JavaScript
+    return "Server processed: " + eventArgument;
+}
+```
+
+### Blazor with BWFC (Phase 2 — Zero Rewrite)
+
+```csharp
+// Same pattern works! ClientScriptShim provides the callback bridge
+protected override void OnInitialized()
+{
+    string callback = ClientScript.GetCallbackEventReference(
+        this, 
+        "arg",
+        "onSuccess",
+        "ctx",
+        "onError",
+        useAsync: true);
+    
+    // Register the callback into the page
+    ClientScript.RegisterStartupScript(this.GetType(), "initCallback",
+        $"var callback = '{callback}'; " +
+        "function myCallback(arg) { callback(arg); }",
+        true);
+}
+
+// Handler methods (same as Web Forms):
+public void RaiseCallbackEvent(string eventArgument)
+{
+    // Process eventArgument
+}
+
+public string GetCallbackResult()
+{
+    // Return result to JavaScript
+}
+```
+
+### How It Works (Phase 2)
+
+1. **`GetCallbackEventReference()` returns a JavaScript function call string** that bridges back to .NET:
+   ```javascript
+   // Returned string looks like:
+   "WebForm_DoCallback('controlId',arg,onSuccess,ctx,onError,true)"
+   ```
+
+2. **BWFC ships `bwfc-callback.js`** which defines `WebForm_DoCallback()` as a bridge:
+   ```javascript
+   window.WebForm_DoCallback = async function(controlId, arg, onSuccess, ctx, onError, async) {
+       try {
+           const result = await DotNet.invokeMethodAsync('BlazorWebFormsComponents', 
+               'HandleCallbackFromJs', controlId, arg);
+           if (onSuccess) {
+               onSuccess(result, ctx);
+           }
+       } catch (err) {
+           if (onError) {
+               onError(err, ctx);
+           }
+       }
+   };
+   ```
+
+3. **Your C# methods handle the callback**, just like Web Forms:
+   ```csharp
+   public void RaiseCallbackEvent(string eventArgument)
+   {
+       // Process the callback argument
+       // Set _callbackResult for GetCallbackResult()
+   }
+   
+   public string GetCallbackResult()
+   {
+       // Return data back to the JavaScript callback
+       return _callbackResult;
+   }
+   ```
+
+4. **JavaScript receives the result** in the `onSuccess` callback:
+   ```javascript
+   function onSuccess(result, context) {
+       console.log('Server returned:', result);
+       // Update UI with server response
+   }
+   ```
+
+### Usage Pattern
+
+Use callback events for AJAX-style server communication without page reload:
+
+```razor
+@inject IJSRuntime JS
+
+<button @onclick="FetchDataViaCallback">Fetch Data</button>
+<div id="result"></div>
+
+@code {
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (firstRender)
+        {
+            // Define JavaScript callback handlers
+            await JS.InvokeVoidAsync("eval", @"
+                window.onCallbackSuccess = function(result, context) {
+                    document.getElementById('result').innerHTML = result;
+                };
+                window.onCallbackError = function(error, context) {
+                    console.error('Callback error:', error);
+                };
+            ");
+        }
+    }
+    
+    private async Task FetchDataViaCallback()
+    {
+        // Get the callback reference
+        string callback = ClientScript.GetCallbackEventReference(
+            this,
+            "\"userQuery\"",  // Argument to pass
+            "onCallbackSuccess",
+            "null",
+            "onCallbackError",
+            useAsync: true);
+        
+        // Execute it via JS interop
+        await JS.InvokeVoidAsync("eval", $"{callback};");
+    }
+    
+    public void RaiseCallbackEvent(string eventArgument)
+    {
+        // Process the query
+        _callbackResult = $"Data for: {eventArgument}";
+    }
+    
+    private string _callbackResult = "";
+    
+    public string GetCallbackResult()
+    {
+        return _callbackResult;
+    }
+}
+```
+
+### Alternative: Modern Blazor Approach
+
+For new development, use `IJSRuntime` with direct method calls instead of callbacks:
+
+```razor
+@inject IJSRuntime JS
+@inject HttpClient Http
+
+<button @onclick="FetchData">Fetch Data</button>
+<div id="result">@result</div>
+
+@code {
+    private string result = "";
+    
+    private async Task FetchData()
+    {
+        // Direct async call to server
+        result = await Http.GetStringAsync("/api/data");
+    }
+}
+```
+
+This is cleaner, type-safe, and easier to test than callback-based patterns.
 
 ---
 
-## 5. Form Validation Scripts
+## 6. Form Validation Scripts
 
 ### What It Does
 
@@ -659,7 +946,7 @@ public DateTime EventDate { get; set; }
 
 ---
 
-## 6. IPostBackEventHandler — Custom Event Binding
+## 7. IPostBackEventHandler — Custom Event Binding
 
 ### What It Does
 
@@ -743,7 +1030,7 @@ If the postback event passes data:
 
 ---
 
-## 7. ScriptManager Code-Behind Patterns
+## 8. ScriptManager Code-Behind Patterns
 
 ### SetFocus()
 
@@ -831,24 +1118,68 @@ Show a loading indicator using component state:
 }
 ```
 
-### GetCurrent() and Related Methods
+### GetCurrent() and Related Methods (Phase 2)
 
 **Web Forms:**
 ```csharp
 ScriptManager sm = ScriptManager.GetCurrent(Page);
+sm.RegisterStartupScript(this.GetType(), "init", "initPage();", true);
 sm.SetFocus(txtSearch);
-sm.RegisterAsyncPostBackControl(gridView);
 ```
 
-**Blazor:**
-`ScriptManager.GetCurrent()` returns `null` in Blazor. **Do not use it.** Instead:
-- For `SetFocus`: Use `@ref` + `IJSRuntime` (see above)
-- For `RegisterAsyncPostBackControl`: Use component parameter binding
-- For `RegisterUpdateProgress`: Use component state
+**Blazor with BWFC (Phase 2 — Zero Rewrite):**
+```csharp
+// Same pattern works! ScriptManagerShim wraps ClientScriptShim
+ScriptManager sm = ScriptManager.GetCurrent(this);  // 'this' is the component (replaces Page)
+sm.RegisterStartupScript(this.GetType(), "init", "initPage();", true);
+// SetFocus still requires JS interop (see above)
+```
+
+### How It Works (Phase 2)
+
+1. **`ScriptManager.GetCurrent(page)`** extracts the `ClientScriptShim` from the component's dependency injection context.
+
+2. **All `RegisterStartupScript`, `RegisterClientScriptBlock`, `RegisterClientScriptInclude` calls delegate to `ClientScriptShim`**, which queues scripts during initialization.
+
+3. **Scripts are flushed in `OnAfterRenderAsync`** via `IJSRuntime`, exactly like Phase 1.
+
+4. **Focus and other component methods require JavaScript interop**, as documented in the sections above.
+
+### Pattern: RegisterStartupScript via ScriptManager
+
+Instead of calling `Page.ClientScript` directly, you can use `ScriptManager.GetCurrent()`:
+
+```csharp
+// Web Forms
+ScriptManager sm = ScriptManager.GetCurrent(Page);
+sm.RegisterStartupScript(this.GetType(), "init", "console.log('loaded');", true);
+
+// Blazor (Phase 2)
+ScriptManager sm = ScriptManager.GetCurrent(this);
+sm.RegisterStartupScript(this.GetType(), "init", "console.log('loaded');", true);
+// Zero code change! Same methods, same behavior
+```
+
+### Key Differences
+
+| Method | Phase 1 | Phase 2 | Notes |
+|--------|---------|---------|-------|
+| `RegisterStartupScript()` | ✅ ClientScriptShim | ✅ Via ScriptManager | Both work; ScriptManager delegates to ClientScriptShim |
+| `RegisterClientScriptBlock()` | ✅ ClientScriptShim | ✅ Via ScriptManager | Both work; same delegation |
+| `RegisterClientScriptInclude()` | ✅ ClientScriptShim | ✅ Via ScriptManager | Both work; same delegation |
+| `GetCurrent()` | ❌ Unsupported | ✅ Phase 2 | Returns the component's ClientScriptShim |
+| `SetFocus()` | ❌ Unsupported | ❌ Still not supported | Use `JS.InvokeVoidAsync("focus", @ref)` instead |
+| `RegisterAsyncPostBackControl()` | ❌ Unsupported | ❌ Still not supported | UpdatePanel is not emulated; use component binding |
+
+### When to Use ScriptManager vs ClientScriptShim
+
+- **Directly** — Both `ClientScript` property (Phase 1) and `ScriptManager.GetCurrent()` (Phase 2) work
+- **No functional difference** — ScriptManager just wraps ClientScriptShim for API compatibility
+- **Choose based on your Web Forms code** — If you used `ScriptManager`, keep using it; if you used `Page.ClientScript`, use `ClientScript` property
 
 ---
 
-## 8. Common Pitfalls and Solutions
+## 9. Common Pitfalls and Solutions
 
 ### Pitfall 1: Script Runs Multiple Times Due to Re-renders
 
@@ -1034,7 +1365,7 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
 
 ---
 
-## 9. What We Don't Support (And Why)
+## 10. What We Don't Support (And Why)
 
 ### `__doPostBack()` and Postback Events
 
@@ -1078,7 +1409,7 @@ Our Roslyn analyzers (BWFC022, BWFC023, BWFC024) detect problematic patterns and
 
 ---
 
-## 10. Analyzers and CLI Transforms
+## 11. Analyzers and CLI Transforms
 
 To help automate migration detection, BWFC provides three diagnostic rules:
 
@@ -1133,7 +1464,7 @@ See [BWFC024 Reference](../Analyzers/BWFC024.md) for details.
 
 ---
 
-## 11. Real-World Examples
+## 12. Real-World Examples
 
 ### Example 1: jQuery Plugin Initialization
 
diff --git a/samples/AfterBlazorServerSide.Tests/Migration/PostBackTests.cs b/samples/AfterBlazorServerSide.Tests/Migration/PostBackTests.cs
new file mode 100644
index 00000000..f4c80423
--- /dev/null
+++ b/samples/AfterBlazorServerSide.Tests/Migration/PostBackTests.cs
@@ -0,0 +1,154 @@
+using Microsoft.Playwright;
+
+namespace AfterBlazorServerSide.Tests.Migration;
+
+/// <summary>
+/// Integration tests for the PostBack demo page at /postback-demo.
+/// Verifies GetPostBackEventReference, GetPostBackClientHyperlink,
+/// and ScriptManager.GetCurrent startup script registration.
+/// </summary>
+[Collection(nameof(PlaywrightCollection))]
+public class PostBackTests
+{
+    private readonly PlaywrightFixture _fixture;
+
+    public PostBackTests(PlaywrightFixture fixture)
+    {
+        _fixture = fixture;
+    }
+
+    /// <summary>
+    /// Verifies that clicking the postback button triggers a __doPostBack call
+    /// and the result area displays the event target and argument.
+    /// </summary>
+    [Fact]
+    public async Task PostBack_Button_TriggersPostBackEvent()
+    {
+        var page = await _fixture.NewPageAsync();
+
+        try
+        {
+            await page.GotoAsync($"{_fixture.BaseUrl}/postback-demo", new PageGotoOptions
+            {
+                WaitUntil = WaitUntilState.NetworkIdle,
+                Timeout = 30000
+            });
+
+            // Wait for Blazor interactive circuit to be ready
+            var button = page.Locator("#postback-button");
+            await button.WaitForAsync(new LocatorWaitForOptions
+            {
+                State = WaitForSelectorState.Attached,
+                Timeout = 10000
+            });
+
+            await button.ClickAsync();
+
+            // Wait for the result to appear after the server round-trip
+            var result = page.Locator("#postback-result");
+            await result.WaitForAsync(new LocatorWaitForOptions
+            {
+                State = WaitForSelectorState.Attached,
+                Timeout = 10000
+            });
+
+            // Allow time for Blazor to process the postback and re-render
+            await page.WaitForTimeoutAsync(2000);
+
+            var resultText = await result.TextContentAsync();
+            Assert.NotNull(resultText);
+            Assert.Contains("PostBack received!", resultText!);
+        }
+        finally
+        {
+            await page.CloseAsync();
+        }
+    }
+
+    /// <summary>
+    /// Verifies that clicking the postback hyperlink (javascript:__doPostBack)
+    /// triggers a postback and the hyperlink result area is updated.
+    /// </summary>
+    [Fact]
+    public async Task PostBackHyperlink_Click_TriggersPostBackEvent()
+    {
+        var page = await _fixture.NewPageAsync();
+
+        try
+        {
+            await page.GotoAsync($"{_fixture.BaseUrl}/postback-demo", new PageGotoOptions
+            {
+                WaitUntil = WaitUntilState.NetworkIdle,
+                Timeout = 30000
+            });
+
+            // Wait for Blazor interactive circuit to be ready
+            var link = page.Locator("#postback-link");
+            await link.WaitForAsync(new LocatorWaitForOptions
+            {
+                State = WaitForSelectorState.Attached,
+                Timeout = 10000
+            });
+
+            await link.ClickAsync();
+
+            // Wait for the result to appear after the server round-trip
+            var result = page.Locator("#hyperlink-result");
+            await result.WaitForAsync(new LocatorWaitForOptions
+            {
+                State = WaitForSelectorState.Attached,
+                Timeout = 10000
+            });
+
+            // Allow time for Blazor to process the postback and re-render
+            await page.WaitForTimeoutAsync(2000);
+
+            var resultText = await result.TextContentAsync();
+            Assert.NotNull(resultText);
+            Assert.Contains("PostBack received!", resultText!);
+        }
+        finally
+        {
+            await page.CloseAsync();
+        }
+    }
+
+    /// <summary>
+    /// Verifies that ScriptManager.GetCurrent registers a startup script
+    /// that populates the target div on page load.
+    /// </summary>
+    [Fact]
+    public async Task ScriptManager_GetCurrent_RegistersStartupScript()
+    {
+        var page = await _fixture.NewPageAsync();
+
+        try
+        {
+            await page.GotoAsync($"{_fixture.BaseUrl}/postback-demo", new PageGotoOptions
+            {
+                WaitUntil = WaitUntilState.NetworkIdle,
+                Timeout = 30000
+            });
+
+            // Wait for the startup script to execute and populate the target
+            var target = page.Locator("#scriptmanager-target");
+            await target.WaitForAsync(new LocatorWaitForOptions
+            {
+                State = WaitForSelectorState.Attached,
+                Timeout = 10000
+            });
+
+            // Allow time for OnAfterRenderAsync to fire and JS to execute
+            await page.WaitForTimeoutAsync(2000);
+
+            var targetText = await target.TextContentAsync();
+            Assert.NotNull(targetText);
+            Assert.False(string.IsNullOrWhiteSpace(targetText),
+                "ScriptManager target should have text content after startup script runs");
+        }
+        finally
+        {
+            await page.CloseAsync();
+        }
+    }
+}
diff --git a/samples/AfterBlazorServerSide/ComponentCatalog.cs b/samples/AfterBlazorServerSide/ComponentCatalog.cs
index 70901547..4ef973e0 100644
--- a/samples/AfterBlazorServerSide/ComponentCatalog.cs
+++ b/samples/AfterBlazorServerSide/ComponentCatalog.cs
@@ -200,6 +200,8 @@ public static class ComponentCatalog
             Keywords: new[] { "response", "redirect", "navigation", "tilde", "aspx", "migration", "shim" }),
         new("IsPostBack", "Migration Helpers", "/migration/ispostback", "IsPostBack status, guard pattern, and IsHttpContextAvailable check",
             Keywords: new[] { "ispostback", "postback", "guard", "httpcontext", "lifecycle", "migration", "shim" }),
+        new("PostBack Demo", "Migration Helpers", "/ControlSamples/PostBackDemo", "GetPostBackEventReference, GetPostBackClientHyperlink, and ScriptManager.GetCurrent demos",
+            Keywords: new[] { "postback", "dopostback", "scriptmanager", "clientscript", "hyperlink", "callback", "migration", "shim" }),
 
         // Cross-Cutting / Base Properties
         new("BaseProperties", "Utility", "/ControlSamples/BaseProperties", "AccessKey, ToolTip, BackColor, ForeColor and other base class properties",
diff --git a/samples/AfterBlazorServerSide/Components/Pages/ComponentList.razor b/samples/AfterBlazorServerSide/Components/Pages/ComponentList.razor
index 8a8b2607..cfc7fa39 100644
--- a/samples/AfterBlazorServerSide/Components/Pages/ComponentList.razor
+++ b/samples/AfterBlazorServerSide/Components/Pages/ComponentList.razor
@@ -107,6 +107,7 @@
 		<ul>
 			<li><a href="/ControlSamples/ClientScript">ClientScript (IJSRuntime)</a></li>
 			<li><a href="/ControlSamples/ClientScriptShim">ClientScriptShim (Zero-Rewrite)</a></li>
+			<li><a href="/ControlSamples/PostBackDemo">PostBack &amp; ScriptManager</a></li>
 		</ul>
 
 		<h3>Migration Tools</h3>
diff --git a/samples/AfterBlazorServerSide/Components/Pages/ControlSamples/PostBackDemo/Index.razor b/samples/AfterBlazorServerSide/Components/Pages/ControlSamples/PostBackDemo/Index.razor
new file mode 100644
index 00000000..dd2357a7
--- /dev/null
+++ b/samples/AfterBlazorServerSide/Components/Pages/ControlSamples/PostBackDemo/Index.razor
@@ -0,0 +1,214 @@
+@page "/ControlSamples/PostBackDemo"
+@inherits WebFormsPageBase
+
+<PageTitle>PostBack &amp; ScriptManager Demo</PageTitle>
+
+<h2>PostBack &amp; ScriptManager Demo</h2>
+
+<p>This sample demonstrates the Phase 2 <strong>ClientScript</strong> postback shims.
+   These methods return the same JavaScript strings as Web Forms, letting migrated
+   code-behind work unchanged in Blazor.</p>
+
+<div class="alert alert-info">
+    <h4 class="alert-heading">💡 What this shows</h4>
+    <ul class="mb-0">
+        <li><code>GetPostBackEventReference()</code> — returns a <code>__doPostBack('id','arg')</code> JS string</li>
+        <li><code>GetPostBackClientHyperlink()</code> — returns a <code>javascript:__doPostBack(...)</code> URL</li>
+        <li><code>ScriptManagerShim.GetCurrent(this)</code> — obtains a ScriptManager, registers startup scripts</li>
+    </ul>
+</div>
+
+<hr />
+
+@* ═══════════════════════════ Section 1: GetPostBackEventReference ═══════════════════════════ *@
+
+<h3>1. GetPostBackEventReference</h3>
+
+<p><code>ClientScript.GetPostBackEventReference(this, "save")</code> returns a
+   <code>__doPostBack</code> call string — the same pattern Web Forms uses for server-side
+   event wiring.</p>
+
+<div class="row">
+    <div class="col-md-6">
+        <h4>Before (Web Forms)</h4>
+        <pre><code class="language-csharp">string script = ClientScript.GetPostBackEventReference(this, "save");
+btnSave.Attributes["onclick"] = script;</code></pre>
+    </div>
+    <div class="col-md-6">
+        <h4>After (Blazor with BWFC)</h4>
+        <pre><code class="language-csharp">// Same API — works unchanged
+_postBackScript = ClientScript.GetPostBackEventReference(this, "save");
+// Wire via onclick="@@_postBackScript"</code></pre>
+    </div>
+</div>
+
+<div class="card mt-3" data-audit-control="postback-event-reference-demo">
+    <div class="card-body">
+        <h5 class="card-title">Live Demo — PostBack via Button</h5>
+        <p>Click the button to fire <code>__doPostBack</code> from JavaScript.
+           The <code>PostBack</code> event on <code>WebFormsPageBase</code> receives it server-side.</p>
+        <button id="postback-button" class="btn btn-primary" onclick="@_postBackScript">
+            Trigger PostBack
+        </button>
+        <p class="mt-2">Generated script: <code id="postback-script">@_postBackScript</code></p>
+        <p id="postback-result" class="fw-bold">@_postBackMessage</p>
+    </div>
+</div>
+
+<hr />
+
+@* ═══════════════════════════ Section 2: GetPostBackClientHyperlink ═══════════════════════════ *@
+
+<h3>2. GetPostBackClientHyperlink</h3>
+
+<p><code>ClientScript.GetPostBackClientHyperlink(this, "navigate")</code> returns a
+   <code>javascript:__doPostBack(...)</code> URL — drop it into an <code>href</code>
+   and it triggers a postback when clicked.</p>
+
+<div class="row">
+    <div class="col-md-6">
+        <h4>Before (Web Forms)</h4>
+        <pre><code class="language-csharp">lnk.NavigateUrl = ClientScript.GetPostBackClientHyperlink(this, "navigate");</code></pre>
+    </div>
+    <div class="col-md-6">
+        <h4>After (Blazor with BWFC)</h4>
+        <pre><code class="language-csharp">// Same call
+_hyperlink = ClientScript.GetPostBackClientHyperlink(this, "navigate");</code></pre>
+    </div>
+</div>
+
+<div class="card mt-3" data-audit-control="postback-hyperlink-demo">
+    <div class="card-body">
+        <h5 class="card-title">Live Demo — PostBack via Hyperlink</h5>
+        <p>An anchor tag whose <code>href</code> is a <code>javascript:__doPostBack</code> URL:</p>
+        <a id="postback-link" href="@_postBackHyperlink" class="btn btn-outline-primary">
+            Click to PostBack via Link
+        </a>
+        <p class="mt-2">Generated href: <code id="hyperlink-script">@_postBackHyperlink</code></p>
+        <p id="hyperlink-result" class="fw-bold">@_hyperlinkMessage</p>
+    </div>
+</div>
+
+<hr />
+
+@* ═══════════════════════════ Section 3: ScriptManager.GetCurrent ═══════════════════════════ *@
+
+<h3>3. ScriptManager.GetCurrent</h3>
+
+<p><code>ScriptManager.GetCurrent(this)</code> returns a <code>ScriptManagerShim</code> that
+   wraps <code>ClientScriptShim</code>. You can call <code>RegisterStartupScript</code> on it —
+   the same code you wrote in Web Forms.</p>
+
+<div class="row">
+    <div class="col-md-6">
+        <h4>Before (Web Forms)</h4>
+        <pre><code class="language-csharp">var sm = ScriptManager.GetCurrent(this);
+sm.RegisterStartupScript(GetType(), "init",
+    "document.getElementById('target').innerText = 'Hello!';",
+    true);</code></pre>
+    </div>
+    <div class="col-md-6">
+        <h4>After (Blazor with BWFC)</h4>
+        <pre><code class="language-csharp">// Same pattern
+var sm = ScriptManagerShim.GetCurrent(this);
+sm.RegisterStartupScript(GetType(), "init",
+    "document.getElementById('target').innerText = 'Hello!';",
+    true);</code></pre>
+    </div>
+</div>
+
+<div class="card mt-3" data-audit-control="scriptmanager-getcurrent-demo">
+    <div class="card-body">
+        <h5 class="card-title">Live Demo — ScriptManager Startup Script</h5>
+        <p>On first render, <code>ScriptManagerShim.GetCurrent(this).RegisterStartupScript(...)</code>
+           sets the text below via JavaScript — just like Web Forms.</p>
+        <div id="scriptmanager-target" class="alert alert-secondary">
+            (waiting for startup script…)
+        </div>
+    </div>
+</div>
+
+<hr />
+
+@* ═══════════════════════════ Section 4: Source Code ═══════════════════════════ *@
+
+<h3>Source Code</h3>
+
+<pre><code class="language-csharp">@@page "/ControlSamples/PostBackDemo"
+@@inherits WebFormsPageBase
+
+@@code {
+    private string _postBackScript = "";
+    private string _postBackMessage = "No postback received yet.";
+    private string _postBackHyperlink = "";
+    private string _hyperlinkMessage = "No hyperlink postback received yet.";
+
+    protected override void OnInitialized()
+    {
+        base.OnInitialized();
+
+        // GetPostBackEventReference — same call as Web Forms
+        _postBackScript = ClientScript.GetPostBackEventReference(this, "save");
+
+        // GetPostBackClientHyperlink — same call as Web Forms
+        _postBackHyperlink = ClientScript.GetPostBackClientHyperlink(this, "navigate");
+
+        // Subscribe to PostBack event
+        PostBack += (sender, args) =>
+        {
+            if (args.EventArgument == "save")
+                _postBackMessage = $"PostBack received! Target: {args.EventTarget}, Argument: {args.EventArgument}";
+            else if (args.EventArgument == "navigate")
+                _hyperlinkMessage = $"Hyperlink PostBack! Target: {args.EventTarget}, Argument: {args.EventArgument}";
+            StateHasChanged();
+        };
+    }
+
+    protected override void OnAfterRender(bool firstRender)
+    {
+        if (firstRender)
+        {
+            var sm = ScriptManagerShim.GetCurrent(this);
+            sm.RegisterStartupScript(GetType(), "smDemo",
+                "document.getElementById('scriptmanager-target').innerText = " +
+                "'ScriptManager startup script executed!';",
+                true);
+        }
+    }
+}</code></pre>
+
+@code {
+    private string _postBackScript = "";
+    private string _postBackMessage = "No postback received yet.";
+    private string _postBackHyperlink = "";
+    private string _hyperlinkMessage = "No hyperlink postback received yet.";
+
+    protected override void OnInitialized()
+    {
+        base.OnInitialized();
+
+        _postBackScript = ClientScript.GetPostBackEventReference(this, "save");
+        _postBackHyperlink = ClientScript.GetPostBackClientHyperlink(this, "navigate");
+
+        PostBack += (sender, args) =>
+        {
+            if (args.EventArgument == "save")
+                _postBackMessage = $"PostBack received! Target: {args.EventTarget}, Argument: {args.EventArgument}";
+            else if (args.EventArgument == "navigate")
+                _hyperlinkMessage = $"Hyperlink PostBack! Target: {args.EventTarget}, Argument: {args.EventArgument}";
+
+            StateHasChanged();
+        };
+    }
+
+    protected override void OnAfterRender(bool firstRender)
+    {
+        if (firstRender)
+        {
+            var sm = ScriptManagerShim.GetCurrent(this);
+            sm.RegisterStartupScript(GetType(), "smDemo",
+                "document.getElementById('scriptmanager-target').innerText = 'ScriptManager startup script executed!';",
+                true);
+        }
+    }
+}
diff --git a/src/BlazorWebFormsComponents.Cli/Transforms/CodeBehind/ClientScriptTransform.cs b/src/BlazorWebFormsComponents.Cli/Transforms/CodeBehind/ClientScriptTransform.cs
index 83017ca1..10a2f4d3 100644
--- a/src/BlazorWebFormsComponents.Cli/Transforms/CodeBehind/ClientScriptTransform.cs
+++ b/src/BlazorWebFormsComponents.Cli/Transforms/CodeBehind/ClientScriptTransform.cs
@@ -12,11 +12,9 @@ namespace BlazorWebFormsComponents.Cli.Transforms.CodeBehind;
 ///   - RegisterStartupScript() → strip Page./this. prefix
 ///   - RegisterClientScriptInclude() → strip Page./this. prefix
 ///   - RegisterClientScriptBlock() → strip Page./this. prefix
+///   - GetPostBackEventReference() → strip Page./this. prefix
 ///   - ScriptManager.RegisterStartupScript() → convert to ClientScript.RegisterStartupScript()
-///
-/// Non-automatable (TODO markers):
-///   - GetPostBackEventReference() → TODO: replace with @onclick / EventCallback
-///   - ScriptManager.GetCurrent() → TODO: use IJSRuntime directly
+///   - ScriptManager.GetCurrent(Page) → ScriptManager.GetCurrent(this)
 /// </summary>
 public class ClientScriptTransform : ICodeBehindTransform
 {
@@ -27,7 +25,7 @@ public class ClientScriptTransform : ICodeBehindTransform
 
     // Strips "Page." or "this." prefix before ClientScript method calls that the shim supports
     private static readonly Regex PageOrThisPrefixRegex = new(
-        @"(?:Page\.|this\.)(?=ClientScript\.(?:RegisterStartupScript|RegisterClientScriptInclude|RegisterClientScriptBlock)\s*\()",
+        @"(?:Page\.|this\.)(?=ClientScript\.(?:RegisterStartupScript|RegisterClientScriptInclude|RegisterClientScriptBlock|GetPostBackEventReference)\s*\()",
         RegexOptions.Compiled);
 
     // Pattern 1b: ScriptManager.RegisterStartupScript(control, type, key, script, bool)
@@ -36,17 +34,9 @@ public class ClientScriptTransform : ICodeBehindTransform
         @"ScriptManager\.RegisterStartupScript\s*\(\s*[^,]*,\s*",
         RegexOptions.Compiled);
 
-    // --- Non-automatable patterns ---
-
-    // Pattern 3: Page.ClientScript.GetPostBackEventReference(...)
-    //   Uses alternation of quoted-strings and non-quote chars to handle complex args
-    private static readonly Regex GetPostBackEventRefRegex = new(
-        @"([ \t]*)(.*(?:Page\.ClientScript|(?:this\.)?ClientScript)\.GetPostBackEventReference\s*\((?:""[^""]*""|[^""])*?\)\s*;)",
-        RegexOptions.Compiled);
-
-    // Pattern 5: ScriptManager.GetCurrent(...) — handles nested parens
-    private static readonly Regex ScriptManagerGetCurrentRegex = new(
-        @"([ \t]*)(?:var\s+\w+\s*=\s*)?ScriptManager\.GetCurrent\s*\((?:""[^""]*""|[^""])*?\)\s*;",
+    // Pattern 5: ScriptManager.GetCurrent(Page) or ScriptManager.GetCurrent(this.Page) → ScriptManager.GetCurrent(this)
+    private static readonly Regex ScriptManagerGetCurrentPageRegex = new(
+        @"ScriptManager\.GetCurrent\s*\(\s*(?:this\.)?Page\s*\)",
         RegexOptions.Compiled);
 
     // For injecting ClientScriptShim dependency comment
@@ -57,8 +47,9 @@ public class ClientScriptTransform : ICodeBehindTransform
     public string Apply(string content, FileMetadata metadata)
     {
         var hasShimCall = false;
+        var hasScriptManagerCall = false;
 
-        // Patterns 1, 2, 4: Strip Page./this. prefix — calls become shim-compatible
+        // Patterns 1, 2, 3, 4: Strip Page./this. prefix — calls become shim-compatible
         if (PageOrThisPrefixRegex.IsMatch(content))
         {
             content = PageOrThisPrefixRegex.Replace(content, "");
@@ -75,37 +66,34 @@ public string Apply(string content, FileMetadata metadata)
         // Detect calls that were already "ClientScript.XXX(...)" without prefix — still shim-compatible
         if (!hasShimCall && (content.Contains("ClientScript.RegisterStartupScript") ||
             content.Contains("ClientScript.RegisterClientScriptInclude") ||
-            content.Contains("ClientScript.RegisterClientScriptBlock")))
+            content.Contains("ClientScript.RegisterClientScriptBlock") ||
+            content.Contains("ClientScript.GetPostBackEventReference")))
         {
             hasShimCall = true;
         }
 
-        // Pattern 3: GetPostBackEventReference → TODO (shim throws NotSupportedException)
-        if (GetPostBackEventRefRegex.IsMatch(content))
+        // Pattern 5: ScriptManager.GetCurrent(Page) → ScriptManager.GetCurrent(this)
+        if (ScriptManagerGetCurrentPageRegex.IsMatch(content))
         {
-            content = GetPostBackEventRefRegex.Replace(content, m =>
-            {
-                var indent = m.Groups[1].Value;
-                var originalLine = m.Groups[2].Value;
-                return $"{indent}// TODO(bwfc-general): Replace __doPostBack with @onclick or EventCallback. See ClientScriptMigrationGuide.md\n{indent}// Original: {originalLine.Trim()}";
-            });
+            content = ScriptManagerGetCurrentPageRegex.Replace(content, "ScriptManager.GetCurrent(this)");
+            hasShimCall = true;
+            hasScriptManagerCall = true;
         }
 
-        // Pattern 5: ScriptManager.GetCurrent → TODO
-        if (ScriptManagerGetCurrentRegex.IsMatch(content))
+        // Detect ScriptManager.GetCurrent(this) already in correct form
+        if (!hasScriptManagerCall && content.Contains("ScriptManager.GetCurrent(this)"))
         {
-            content = ScriptManagerGetCurrentRegex.Replace(content, m =>
-            {
-                var indent = m.Groups[1].Value;
-                return $"{indent}// TODO(bwfc-general): ScriptManager.GetCurrent() has no Blazor equivalent. Use IJSRuntime directly.";
-            });
+            hasShimCall = true;
+            hasScriptManagerCall = true;
         }
 
-        // Add ClientScriptShim dependency comment when shim-preserving transforms were made
+        // Add shim dependency comment when shim-preserving transforms were made
         if (hasShimCall && ClassOpenRegex.IsMatch(content) &&
             !content.Contains("// TODO(bwfc-general): ClientScript calls preserved"))
         {
-            var shimComment = "\n    // TODO(bwfc-general): ClientScript calls preserved — uses ClientScriptShim. Inject @inject ClientScriptShim ClientScript if not using BaseWebFormsComponent.\n";
+            var shimComment = hasScriptManagerCall
+                ? "\n    // TODO(bwfc-general): ClientScript calls preserved — uses ClientScriptShim + ScriptManagerShim. Inject @inject ClientScriptShim ClientScript and @inject ScriptManagerShim ScriptManager if not using BaseWebFormsComponent.\n"
+                : "\n    // TODO(bwfc-general): ClientScript calls preserved — uses ClientScriptShim. Inject @inject ClientScriptShim ClientScript if not using BaseWebFormsComponent.\n";
             content = ClassOpenRegex.Replace(content, "$1" + shimComment, 1);
         }
 
diff --git a/src/BlazorWebFormsComponents.Test/ClientScriptShimTests.cs b/src/BlazorWebFormsComponents.Test/ClientScriptShimTests.cs
index b50887a9..1572e611 100644
--- a/src/BlazorWebFormsComponents.Test/ClientScriptShimTests.cs
+++ b/src/BlazorWebFormsComponents.Test/ClientScriptShimTests.cs
@@ -350,43 +350,235 @@ public async Task FlushAsync_ReRegistering_AfterFlush_Works()
 
 	#endregion
 
-	#region Unsupported Methods
+	#region PostBack / Callback Methods
 
-	// NOTE: Exact method signatures depend on Cyclops's implementation.
-	// These tests verify the throw behavior — signatures may need adjustment
-	// once the shim is finalized.
+	// These methods now return working JavaScript strings instead of throwing.
 
 	[Fact]
-	public void GetPostBackEventReference_ThrowsNotSupported()
+	public void GetPostBackEventReference_ReturnsDoPostBackJs()
 	{
 		var shim = CreateShim();
 
-		var ex = Should.Throw<NotSupportedException>(() =>
-			shim.GetPostBackEventReference(null!, "arg"));
+		var result = shim.GetPostBackEventReference(new object(), "arg");
 
-		ex.Message.ShouldNotBeNullOrWhiteSpace();
+		result.ShouldContain("__doPostBack");
+		result.ShouldContain("arg");
 	}
 
 	[Fact]
-	public void GetPostBackClientHyperlink_ThrowsNotSupported()
+	public void GetPostBackEventReference_NullControl_ReturnsUnknownTarget()
 	{
 		var shim = CreateShim();
 
-		var ex = Should.Throw<NotSupportedException>(() =>
-			shim.GetPostBackClientHyperlink(null!, "arg"));
+		var result = shim.GetPostBackEventReference(null!, "arg");
 
-		ex.Message.ShouldNotBeNullOrWhiteSpace();
+		result.ShouldContain("__doPostBack('unknown',");
 	}
 
 	[Fact]
-	public void GetCallbackEventReference_ThrowsNotSupported()
+	public void GetPostBackEventReference_NullArgument_DefaultsToEmpty()
 	{
 		var shim = CreateShim();
 
-		var ex = Should.Throw<NotSupportedException>(() =>
-			shim.GetCallbackEventReference(null!, "arg", "callback", "ctx", "errorCb", false));
+		var result = shim.GetPostBackEventReference(new object(), null!);
 
-		ex.Message.ShouldNotBeNullOrWhiteSpace();
+		result.ShouldContain("__doPostBack(");
+		result.ShouldContain("''");
+	}
+
+	[Fact]
+	public void GetPostBackClientHyperlink_ReturnsJavascriptUrl()
+	{
+		var shim = CreateShim();
+
+		var result = shim.GetPostBackClientHyperlink(new object(), "arg");
+
+		result.ShouldStartWith("javascript:");
+		result.ShouldContain("__doPostBack");
+	}
+
+	[Fact]
+	public void GetCallbackEventReference_ReturnsCallbackJs()
+	{
+		var shim = CreateShim();
+
+		var result = shim.GetCallbackEventReference(
+			new object(), "arg", "onSuccess", "ctx", "onError", false);
+
+		result.ShouldContain("__bwfc_callback");
+		result.ShouldContain("arg");
+		result.ShouldContain("onSuccess");
+		result.ShouldContain("onError");
+	}
+
+	[Fact]
+	public void GetCallbackEventReference_NullCallbacks_UsesNull()
+	{
+		var shim = CreateShim();
+
+		var result = shim.GetCallbackEventReference(
+			new object(), "arg", null!, null, null!, false);
+
+		result.ShouldContain("null");
+	}
+
+	#endregion
+
+	#region Phase 2 — PostBack Deep Tests
+
+	[Fact]
+	public void GetPostBackEventReference_EscapesSingleQuotesInArgument()
+	{
+		var shim = CreateShim();
+
+		var result = shim.GetPostBackEventReference(new object(), "it's a test");
+
+		result.ShouldContain("it\\'s a test");
+	}
+
+	[Fact]
+	public void GetPostBackEventReference_EscapesBackslashesInArgument()
+	{
+		var shim = CreateShim();
+
+		var result = shim.GetPostBackEventReference(new object(), "path\\to\\file");
+
+		result.ShouldContain("path\\\\to\\\\file");
+	}
+
+	[Fact]
+	public void GetPostBackEventReference_EmptyArgument_ProducesEmptyQuotes()
+	{
+		var shim = CreateShim();
+
+		var result = shim.GetPostBackEventReference(new object(), "");
+
+		result.ShouldContain("''");
+	}
+
+	[Fact]
+	public void GetPostBackEventReference_ControlType_ResolvesToTypeName()
+	{
+		var shim = CreateShim();
+
+		var result = shim.GetPostBackEventReference(new object(), "arg");
+
+		// Plain object resolves to its type name
+		result.ShouldContain("Object");
+	}
+
+	[Fact]
+	public void GetPostBackEventReference_OutputFormat_IsDoPostBackCall()
+	{
+		var shim = CreateShim();
+
+		var result = shim.GetPostBackEventReference(new object(), "myarg");
+
+		// Should match the format: __doPostBack('id', 'arg')
+		result.ShouldStartWith("__doPostBack(");
+		result.ShouldEndWith(")");
+		result.ShouldContain("myarg");
+	}
+
+	[Fact]
+	public void GetPostBackClientHyperlink_ContainsSameContentAsEventReference()
+	{
+		var shim = CreateShim();
+		var control = new object();
+		var argument = "test";
+
+		var reference = shim.GetPostBackEventReference(control, argument);
+		var hyperlink = shim.GetPostBackClientHyperlink(control, argument);
+
+		hyperlink.ShouldBe($"javascript:{reference}");
+	}
+
+	[Fact]
+	public void GetPostBackClientHyperlink_NullControl_ContainsUnknown()
+	{
+		var shim = CreateShim();
+
+		var result = shim.GetPostBackClientHyperlink(null!, "arg");
+
+		result.ShouldStartWith("javascript:");
+		result.ShouldContain("unknown");
+	}
+
+	[Fact]
+	public void GetPostBackClientHyperlink_EscapesSpecialChars()
+	{
+		var shim = CreateShim();
+
+		var result = shim.GetPostBackClientHyperlink(new object(), "it's");
+
+		result.ShouldStartWith("javascript:");
+		result.ShouldContain("\\'");
+	}
+
+	#endregion
+
+	#region Phase 2 — Callback Deep Tests
+
+	[Fact]
+	public void GetCallbackEventReference_EscapesSingleQuotesInArgument()
+	{
+		var shim = CreateShim();
+
+		var result = shim.GetCallbackEventReference(
+			new object(), "it's", "onSuccess", "ctx", "onError", false);
+
+		result.ShouldContain("it\\'s");
+	}
+
+	[Fact]
+	public void GetCallbackEventReference_EscapesBackslashesInContext()
+	{
+		var shim = CreateShim();
+
+		var result = shim.GetCallbackEventReference(
+			new object(), "arg", "onSuccess", "path\\ctx", "onError", false);
+
+		result.ShouldContain("path\\\\ctx");
+	}
+
+	[Fact]
+	public void GetCallbackEventReference_NullContext_DefaultsToEmpty()
+	{
+		var shim = CreateShim();
+
+		var result = shim.GetCallbackEventReference(
+			new object(), "arg", "onSuccess", null!, "onError", false);
+
+		// null context → empty string between quotes
+		result.ShouldContain("__bwfc_callback");
+	}
+
+	[Fact]
+	public void GetCallbackEventReference_NullArgument_DefaultsToEmpty()
+	{
+		var shim = CreateShim();
+
+		var result = shim.GetCallbackEventReference(
+			new object(), null!, "onSuccess", "ctx", "onError", false);
+
+		result.ShouldContain("__bwfc_callback");
+		result.ShouldContain("''");
+	}
+
+	[Fact]
+	public void GetCallbackEventReference_OutputFormat_ContainsAllParams()
+	{
+		var shim = CreateShim();
+
+		var result = shim.GetCallbackEventReference(
+			new object(), "myarg", "successFn", "myctx", "errorFn", true);
+
+		result.ShouldStartWith("__bwfc_callback(");
+		result.ShouldEndWith(")");
+		result.ShouldContain("myarg");
+		result.ShouldContain("successFn");
+		result.ShouldContain("myctx");
+		result.ShouldContain("errorFn");
 	}
 
 	#endregion
diff --git a/src/BlazorWebFormsComponents.Test/PostBackEventArgsTests.cs b/src/BlazorWebFormsComponents.Test/PostBackEventArgsTests.cs
new file mode 100644
index 00000000..9606f541
--- /dev/null
+++ b/src/BlazorWebFormsComponents.Test/PostBackEventArgsTests.cs
@@ -0,0 +1,134 @@
+using System;
+using Shouldly;
+using Xunit;
+
+namespace BlazorWebFormsComponents.Test;
+
+/// <summary>
+/// Unit tests for <see cref="PostBackEventArgs"/>.
+/// Covers construction, property values, immutability, and inheritance.
+/// </summary>
+public class PostBackEventArgsTests
+{
+	#region Construction
+
+	[Fact]
+	public void Constructor_SetsEventTarget()
+	{
+		var args = new PostBackEventArgs("Button1", "click");
+
+		args.EventTarget.ShouldBe("Button1");
+	}
+
+	[Fact]
+	public void Constructor_SetsEventArgument()
+	{
+		var args = new PostBackEventArgs("Button1", "submit");
+
+		args.EventArgument.ShouldBe("submit");
+	}
+
+	[Fact]
+	public void Constructor_NullTarget_Allowed()
+	{
+		var args = new PostBackEventArgs(null!, "arg");
+
+		args.EventTarget.ShouldBeNull();
+	}
+
+	[Fact]
+	public void Constructor_NullArgument_Allowed()
+	{
+		var args = new PostBackEventArgs("target", null!);
+
+		args.EventArgument.ShouldBeNull();
+	}
+
+	[Fact]
+	public void Constructor_BothNull_Allowed()
+	{
+		var args = new PostBackEventArgs(null!, null!);
+
+		args.EventTarget.ShouldBeNull();
+		args.EventArgument.ShouldBeNull();
+	}
+
+	[Fact]
+	public void Constructor_EmptyStrings_Allowed()
+	{
+		var args = new PostBackEventArgs("", "");
+
+		args.EventTarget.ShouldBe("");
+		args.EventArgument.ShouldBe("");
+	}
+
+	#endregion
+
+	#region Immutability
+
+	[Fact]
+	public void EventTarget_IsReadOnly()
+	{
+		var prop = typeof(PostBackEventArgs).GetProperty("EventTarget");
+
+		prop.ShouldNotBeNull();
+		prop!.CanWrite.ShouldBeFalse("EventTarget should be read-only");
+	}
+
+	[Fact]
+	public void EventArgument_IsReadOnly()
+	{
+		var prop = typeof(PostBackEventArgs).GetProperty("EventArgument");
+
+		prop.ShouldNotBeNull();
+		prop!.CanWrite.ShouldBeFalse("EventArgument should be read-only");
+	}
+
+	#endregion
+
+	#region Inheritance
+
+	[Fact]
+	public void InheritsFromEventArgs()
+	{
+		var args = new PostBackEventArgs("t", "a");
+
+		args.ShouldBeAssignableTo<System.EventArgs>();
+	}
+
+	#endregion
+
+	#region Round-Trip Values
+
+	[Fact]
+	public void PreservesSpecialCharacters()
+	{
+		var args = new PostBackEventArgs("btn'1", "arg\\with'special");
+
+		args.EventTarget.ShouldBe("btn'1");
+		args.EventArgument.ShouldBe("arg\\with'special");
+	}
+
+	[Fact]
+	public void PreservesUnicodeCharacters()
+	{
+		var args = new PostBackEventArgs("按钮", "提交数据");
+
+		args.EventTarget.ShouldBe("按钮");
+		args.EventArgument.ShouldBe("提交数据");
+	}
+
+	[Fact]
+	public void PreservesLongStrings()
+	{
+		var longTarget = new string('x', 10000);
+		var longArg = new string('y', 10000);
+
+		var args = new PostBackEventArgs(longTarget, longArg);
+
+		args.EventTarget.ShouldBe(longTarget);
+		args.EventArgument.ShouldBe(longArg);
+	}
+
+	#endregion
+}
diff --git a/src/BlazorWebFormsComponents.Test/ScriptManagerShimTests.cs b/src/BlazorWebFormsComponents.Test/ScriptManagerShimTests.cs
new file mode 100644
index 00000000..f115c503
--- /dev/null
+++ b/src/BlazorWebFormsComponents.Test/ScriptManagerShimTests.cs
@@ -0,0 +1,176 @@
+using System;
+using System.Reflection;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Shouldly;
+using Xunit;
+
+namespace BlazorWebFormsComponents.Test;
+
+/// <summary>
+/// Unit tests for <see cref="ScriptManagerShim"/>.
+/// Covers the static GetCurrent factory, constructor validation,
+/// and delegation of RegisterXxx methods to ClientScriptShim.
+/// </summary>
+public class ScriptManagerShimTests
+{
+	private static ClientScriptShim CreateClientScriptShim()
+	{
+		return new ClientScriptShim(NullLogger<ClientScriptShim>.Instance);
+	}
+
+	#region Constructor
+
+	[Fact]
+	public void Constructor_WithNullClientScript_ThrowsArgumentNull()
+	{
+		Should.Throw<ArgumentNullException>(() => new ScriptManagerShim(null!));
+	}
+
+	[Fact]
+	public void Constructor_WithValidClientScript_DoesNotThrow()
+	{
+		var shim = CreateClientScriptShim();
+
+		var sm = new ScriptManagerShim(shim);
+
+		sm.ShouldNotBeNull();
+	}
+
+	#endregion
+
+	#region GetCurrent — Error Cases
+
+	[Fact]
+	public void GetCurrent_WithPlainObject_ThrowsInvalidOperation()
+	{
+		Should.Throw<InvalidOperationException>(
+			() => ScriptManagerShim.GetCurrent("not a component"));
+	}
+
+	[Fact]
+	public void GetCurrent_WithNull_ThrowsInvalidOperation()
+	{
+		Should.Throw<InvalidOperationException>(
+			() => ScriptManagerShim.GetCurrent(null!));
+	}
+
+	[Fact]
+	public void GetCurrent_WithIntegerArg_ThrowsInvalidOperation()
+	{
+		Should.Throw<InvalidOperationException>(
+			() => ScriptManagerShim.GetCurrent(42));
+	}
+
+	[Fact]
+	public void GetCurrent_ErrorMessage_MentionsBaseWebFormsComponent()
+	{
+		var ex = Should.Throw<InvalidOperationException>(
+			() => ScriptManagerShim.GetCurrent(new object()));
+
+		ex.Message.ShouldContain("BaseWebFormsComponent");
+	}
+
+	#endregion
+
+	#region GetCurrent — Success via Reflection
+
+	[Fact]
+	public void GetCurrent_WithComponentHavingClientScript_ReturnsShim()
+	{
+		var clientScript = CreateClientScriptShim();
+		var mockComponent = new Mock<BlazorWebFormsComponents.BaseWebFormsComponent>() { CallBase = true };
+
+		// Use reflection to inject the ClientScriptShim into the private field
+		var clientScriptField = typeof(BlazorWebFormsComponents.BaseWebFormsComponent)
+			.GetField("_clientScript", BindingFlags.NonPublic | BindingFlags.Instance);
+		var resolvedField = typeof(BlazorWebFormsComponents.BaseWebFormsComponent)
+			.GetField("_clientScriptResolved", BindingFlags.NonPublic | BindingFlags.Instance);
+
+		clientScriptField!.SetValue(mockComponent.Object, clientScript);
+		resolvedField!.SetValue(mockComponent.Object, true);
+
+		var result = ScriptManagerShim.GetCurrent(mockComponent.Object);
+
+		result.ShouldNotBeNull();
+	}
+
+	[Fact]
+	public void GetCurrent_WithComponentWithoutClientScript_Throws()
+	{
+		// Component with ClientScript == null (no service provider set)
+		var mockComponent = new Mock<BlazorWebFormsComponents.BaseWebFormsComponent>() { CallBase = true };
+
+		Should.Throw<InvalidOperationException>(
+			() => ScriptManagerShim.GetCurrent(mockComponent.Object));
+	}
+
+	#endregion
+
+	#region Delegation — RegisterStartupScript
+
+	[Fact]
+	public void RegisterStartupScript_DelegatesToClientScript()
+	{
+		var clientScript = CreateClientScriptShim();
+		var sm = new ScriptManagerShim(clientScript);
+
+		sm.RegisterStartupScript(typeof(ScriptManagerShimTests), "key1", "alert('hi');", false);
+
+		clientScript.IsStartupScriptRegistered(typeof(ScriptManagerShimTests), "key1").ShouldBeTrue();
+	}
+
+	[Fact]
+	public void RegisterStartupScript_WithControl_DelegatesToClientScript()
+	{
+		var clientScript = CreateClientScriptShim();
+		var sm = new ScriptManagerShim(clientScript);
+
+		sm.RegisterStartupScript(new object(), typeof(ScriptManagerShimTests), "key2", "alert('x');", false);
+
+		clientScript.IsStartupScriptRegistered(typeof(ScriptManagerShimTests), "key2").ShouldBeTrue();
+	}
+
+	[Fact]
+	public void RegisterStartupScript_WithAddScriptTags_DelegatesToClientScript()
+	{
+		var clientScript = CreateClientScriptShim();
+		var sm = new ScriptManagerShim(clientScript);
+
+		sm.RegisterStartupScript(typeof(ScriptManagerShimTests), "tagged", "<script>x();</script>", true);
+
+		clientScript.IsStartupScriptRegistered(typeof(ScriptManagerShimTests), "tagged").ShouldBeTrue();
+	}
+
+	#endregion
+
+	#region Delegation — RegisterClientScriptBlock
+
+	[Fact]
+	public void RegisterClientScriptBlock_DelegatesToClientScript()
+	{
+		var clientScript = CreateClientScriptShim();
+		var sm = new ScriptManagerShim(clientScript);
+
+		sm.RegisterClientScriptBlock(typeof(ScriptManagerShimTests), "block1", "var x = 1;", false);
+
+		clientScript.IsClientScriptBlockRegistered(typeof(ScriptManagerShimTests), "block1").ShouldBeTrue();
+	}
+
+	#endregion
+
+	#region Delegation — RegisterClientScriptInclude
+
+	[Fact]
+	public void RegisterClientScriptInclude_DelegatesToClientScript()
+	{
+		var clientScript = CreateClientScriptShim();
+		var sm = new ScriptManagerShim(clientScript);
+
+		sm.RegisterClientScriptInclude(typeof(ScriptManagerShimTests), "inc1", "https://cdn.example.com/lib.js");
+
+		clientScript.IsClientScriptIncludeRegistered("inc1").ShouldBeTrue();
+	}
+
+	#endregion
+}
diff --git a/src/BlazorWebFormsComponents/ClientScriptShim.cs b/src/BlazorWebFormsComponents/ClientScriptShim.cs
index df05bead..da4530b6 100644
--- a/src/BlazorWebFormsComponents/ClientScriptShim.cs
+++ b/src/BlazorWebFormsComponents/ClientScriptShim.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Components;
 using Microsoft.Extensions.Logging;
 using Microsoft.JSInterop;
 
@@ -192,45 +193,46 @@ public async Task FlushAsync(IJSRuntime jsRuntime)
 		_scriptIncludes.Clear();
 	}
 
-	// ─── Unsupported Methods ───────────────────────────────────────────
+	// ─── PostBack / Callback Methods ──────────────────────────────────
 
 	/// <summary>
-	/// Not supported in Blazor. Throws <see cref="NotSupportedException"/>
-	/// with migration guidance.
+	/// Returns a JavaScript string that triggers a postback, mirroring the
+	/// Web Forms <c>ClientScriptManager.GetPostBackEventReference</c> behavior.
+	/// The returned string calls <c>__doPostBack(eventTarget, eventArgument)</c>,
+	/// which is defined in <c>bwfc-postback.js</c>.
 	/// </summary>
-	/// <exception cref="NotSupportedException">Always thrown.</exception>
+	/// <param name="control">The control initiating the postback (used to resolve an ID).</param>
+	/// <param name="argument">The event argument string.</param>
+	/// <returns>A JavaScript expression string, e.g. <c>__doPostBack('Button1', '')</c>.</returns>
 	public string GetPostBackEventReference(object control, string argument)
 	{
-		throw new NotSupportedException(
-			"GetPostBackEventReference is not supported in Blazor. " +
-			"Use @onclick / EventCallback<T> instead. " +
-			"See: docs/Migration/ClientScriptMigrationGuide.md");
+		var id = ResolveControlId(control);
+		return $"__doPostBack('{EscapeJsString(id)}', '{EscapeJsString(argument ?? string.Empty)}')";
 	}
 
 	/// <summary>
-	/// Not supported in Blazor. Throws <see cref="NotSupportedException"/>
-	/// with migration guidance.
+	/// Returns a <c>javascript:</c> URL that triggers a postback, mirroring
+	/// <c>ClientScriptManager.GetPostBackClientHyperlink</c>.
 	/// </summary>
-	/// <exception cref="NotSupportedException">Always thrown.</exception>
+	/// <param name="control">The control initiating the postback.</param>
+	/// <param name="argument">The event argument string.</param>
+	/// <returns>A <c>javascript:__doPostBack(...)</c> URL string.</returns>
 	public string GetPostBackClientHyperlink(object control, string argument)
 	{
-		throw new NotSupportedException(
-			"GetPostBackClientHyperlink is not supported in Blazor. " +
-			"Use NavigationManager or <a href=\"...\"> instead. " +
-			"See: docs/Migration/ClientScriptMigrationGuide.md");
+		return $"javascript:{GetPostBackEventReference(control, argument)}";
 	}
 
 	/// <summary>
-	/// Not supported in Blazor. Throws <see cref="NotSupportedException"/>
-	/// with migration guidance.
+	/// Returns a JavaScript expression that invokes the BWFC callback bridge,
+	/// mirroring <c>ClientScriptManager.GetCallbackEventReference</c>.
+	/// The returned expression calls <c>__bwfc_callback</c> defined in
+	/// <c>bwfc-postback.js</c>.
 	/// </summary>
-	/// <exception cref="NotSupportedException">Always thrown.</exception>
-	public string GetCallbackEventReference(object control, string argument, string clientCallback, string context, string clientErrorCallback, bool useAsync)
+	public string GetCallbackEventReference(object control, string argument,
+		string clientCallback, string context, string clientErrorCallback, bool useAsync)
 	{
-		throw new NotSupportedException(
-			"GetCallbackEventReference is not supported in Blazor. " +
-			"Use IJSRuntime / EventCallback<T> for JS-to-.NET interop. " +
-			"See: docs/Migration/ClientScriptMigrationGuide.md");
+		var id = ResolveControlId(control);
+		return $"__bwfc_callback('{EscapeJsString(id)}', '{EscapeJsString(argument ?? string.Empty)}', {clientCallback ?? "null"}, '{EscapeJsString(context ?? string.Empty)}', {clientErrorCallback ?? "null"})";
 	}
 
 	// ─── Helpers ───────────────────────────────────────────────────────
@@ -250,4 +252,18 @@ private static string EscapeJsString(string value)
 	{
 		return value.Replace("\\", "\\\\").Replace("'", "\\'");
 	}
+
+	/// <summary>
+	/// Resolves a control reference to an ID string suitable for use in
+	/// JavaScript postback/callback expressions.
+	/// Prefers <see cref="BaseWebFormsComponent.ID"/> when available.
+	/// </summary>
+	private static string ResolveControlId(object control)
+	{
+		if (control is BaseWebFormsComponent bwfc && !string.IsNullOrEmpty(bwfc.ID))
+			return bwfc.ID;
+		if (control is ComponentBase)
+			return control.GetType().Name;
+		return control?.GetType().Name ?? "unknown";
+	}
 }
diff --git a/src/BlazorWebFormsComponents/PostBackEventArgs.cs b/src/BlazorWebFormsComponents/PostBackEventArgs.cs
new file mode 100644
index 00000000..44e06056
--- /dev/null
+++ b/src/BlazorWebFormsComponents/PostBackEventArgs.cs
@@ -0,0 +1,23 @@
+using System;
+
+namespace BlazorWebFormsComponents;
+
+/// <summary>
+/// Event arguments for postback events, mirroring the Web Forms postback model.
+/// Contains the <see cref="EventTarget"/> (control ID) and <see cref="EventArgument"/>
+/// that were passed to <c>__doPostBack(eventTarget, eventArgument)</c>.
+/// </summary>
+public class PostBackEventArgs : EventArgs
+{
+	/// <summary>The ID of the control that initiated the postback.</summary>
+	public string EventTarget { get; }
+
+	/// <summary>The argument string associated with the postback.</summary>
+	public string EventArgument { get; }
+
+	public PostBackEventArgs(string eventTarget, string eventArgument)
+	{
+		EventTarget = eventTarget;
+		EventArgument = eventArgument;
+	}
+}
diff --git a/src/BlazorWebFormsComponents/ScriptManagerShim.cs b/src/BlazorWebFormsComponents/ScriptManagerShim.cs
new file mode 100644
index 00000000..2b1bea41
--- /dev/null
+++ b/src/BlazorWebFormsComponents/ScriptManagerShim.cs
@@ -0,0 +1,66 @@
+using System;
+
+namespace BlazorWebFormsComponents;
+
+/// <summary>
+/// Compatibility shim for <c>System.Web.UI.ScriptManager</c>.
+/// Provides the static <see cref="GetCurrent"/> factory method that Web Forms
+/// code uses to obtain a <c>ScriptManager</c> instance from the page, and
+/// delegates all <c>RegisterXxx</c> calls to <see cref="ClientScriptShim"/>.
+/// </summary>
+public class ScriptManagerShim
+{
+	private readonly ClientScriptShim _clientScript;
+
+	/// <summary>
+	/// Initializes a new instance backed by the specified <see cref="ClientScriptShim"/>.
+	/// </summary>
+	public ScriptManagerShim(ClientScriptShim clientScript)
+	{
+		_clientScript = clientScript ?? throw new ArgumentNullException(nameof(clientScript));
+	}
+
+	/// <summary>
+	/// Static factory matching the Web Forms <c>ScriptManager.GetCurrent(Page)</c> pattern.
+	/// Resolves the <see cref="ClientScriptShim"/> from the page/component instance.
+	/// </summary>
+	/// <param name="page">
+	/// A <see cref="BaseWebFormsComponent"/> or <see cref="WebFormsPageBase"/> instance.
+	/// </param>
+	/// <returns>A <see cref="ScriptManagerShim"/> wrapping the component's ClientScript.</returns>
+	/// <exception cref="InvalidOperationException">
+	/// Thrown when <paramref name="page"/> is not a recognized BWFC type or has no ClientScript.
+	/// </exception>
+	public static ScriptManagerShim GetCurrent(object page)
+	{
+		if (page is BaseWebFormsComponent component && component.ClientScript != null)
+			return new ScriptManagerShim(component.ClientScript);
+		if (page is WebFormsPageBase pageBase && pageBase.ClientScript != null)
+			return new ScriptManagerShim(pageBase.ClientScript);
+
+		throw new InvalidOperationException(
+			"ScriptManager.GetCurrent() requires a component derived from " +
+			"BaseWebFormsComponent or WebFormsPageBase with a registered ClientScriptShim.");
+	}
+
+	// ─── Delegated Registration Methods ───────────────────────────────
+
+	/// <inheritdoc cref="ClientScriptShim.RegisterStartupScript(Type, string, string, bool)"/>
+	public void RegisterStartupScript(Type type, string key, string script, bool addScriptTags)
+		=> _clientScript.RegisterStartupScript(type, key, script, addScriptTags);
+
+	/// <summary>
+	/// Overload accepting a control reference (ignored) to match the Web Forms
+	/// <c>ScriptManager.RegisterStartupScript(Control, Type, String, String, Boolean)</c> signature.
+	/// </summary>
+	public void RegisterStartupScript(object control, Type type, string key, string script, bool addScriptTags)
+		=> _clientScript.RegisterStartupScript(type, key, script, addScriptTags);
+
+	/// <inheritdoc cref="ClientScriptShim.RegisterClientScriptBlock(Type, string, string, bool)"/>
+	public void RegisterClientScriptBlock(Type type, string key, string script, bool addScriptTags)
+		=> _clientScript.RegisterClientScriptBlock(type, key, script, addScriptTags);
+
+	/// <inheritdoc cref="ClientScriptShim.RegisterClientScriptInclude(Type, string, string)"/>
+	public void RegisterClientScriptInclude(Type type, string key, string url)
+		=> _clientScript.RegisterClientScriptInclude(type, key, url);
+}
diff --git a/src/BlazorWebFormsComponents/ServiceCollectionExtensions.cs b/src/BlazorWebFormsComponents/ServiceCollectionExtensions.cs
index 32c760f3..fe57087f 100644
--- a/src/BlazorWebFormsComponents/ServiceCollectionExtensions.cs
+++ b/src/BlazorWebFormsComponents/ServiceCollectionExtensions.cs
@@ -43,6 +43,7 @@ public static IServiceCollection AddBlazorWebFormsComponents(this IServiceCollec
         services.AddScoped<ServerShim>();
         services.AddScoped<CacheShim>();
         services.AddScoped<ClientScriptShim>();
+        services.AddScoped(sp => new ScriptManagerShim(sp.GetRequiredService<ClientScriptShim>()));
 
         var options = new BlazorWebFormsComponentsOptions();
         configure?.Invoke(options);
diff --git a/src/BlazorWebFormsComponents/WebFormsPageBase.cs b/src/BlazorWebFormsComponents/WebFormsPageBase.cs
index 1cbd00e7..894555e9 100644
--- a/src/BlazorWebFormsComponents/WebFormsPageBase.cs
+++ b/src/BlazorWebFormsComponents/WebFormsPageBase.cs
@@ -1,10 +1,12 @@
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Routing;
 using Microsoft.Extensions.Logging;
+using Microsoft.JSInterop;
 
 namespace BlazorWebFormsComponents;
 
@@ -12,10 +14,10 @@ namespace BlazorWebFormsComponents;
 /// Base class for converted ASP.NET Web Forms pages. Provides Page.Title,
 /// Page.MetaDescription, Page.MetaKeywords, IsPostBack, Response.Redirect,
 /// Response.Cookies, Request.Cookies, Request.QueryString, Request.Url,
-/// ViewState, and GetRouteUrl compatibility so that Web Forms code-behind
-/// patterns survive migration with minimal changes.
+/// ViewState, GetRouteUrl, ClientScript, and PostBack compatibility so that
+/// Web Forms code-behind patterns survive migration with minimal changes.
 /// </summary>
-public abstract class WebFormsPageBase : ComponentBase
+public abstract class WebFormsPageBase : ComponentBase, IAsyncDisposable
 {
 [Inject] private IPageService _pageService { get; set; } = null!;
 [Inject] private NavigationManager _navigationManager { get; set; } = null!;
@@ -25,6 +27,25 @@ public abstract class WebFormsPageBase : ComponentBase
 [Inject] private SessionShim _sessionShim { get; set; } = null!;
 [Inject] private IWebHostEnvironment _webHostEnvironment { get; set; } = null!;
 [Inject] private CacheShim _cacheShim { get; set; } = null!;
+[Inject] private IJSRuntime _jsRuntime { get; set; } = null!;
+[Inject] private ClientScriptShim _clientScriptShim { get; set; } = null!;
+
+/// <summary>
+/// Provides access to client script registration methods, emulating
+/// <c>Page.ClientScript</c> from ASP.NET Web Forms.
+/// </summary>
+public ClientScriptShim ClientScript => _clientScriptShim;
+
+// ─── PostBack Support ─────────────────────────────────────────────
+
+private DotNetObjectReference<WebFormsPageBase>? _postBackRef;
+private string? _postBackTargetId;
+
+/// <summary>
+/// Raised when a postback is triggered from JavaScript via <c>__doPostBack()</c>.
+/// Subscribe to this event in derived pages to handle postback actions.
+/// </summary>
+public event EventHandler<PostBackEventArgs>? PostBack;
 
 /// <summary>
 /// Provides dictionary-style <c>Session["key"]</c> access, emulating
@@ -237,4 +258,105 @@ private void RequireHttpContext(string memberName)
 $"rendering (WebSocket mode). Use {nameof(IsHttpContextAvailable)} to guard " +
 $"calls to this member, or ensure the page runs in SSR mode.");
 }
+
+// ─── PostBack JS Interop ──────────────────────────────────────────
+
+// Inline bootstrap ensures __doPostBack and registration functions exist
+// before any postback target is registered. The standalone bwfc-postback.js
+// file is also available for manual <script> inclusion.
+private const string PostBackBootstrapJs = @"
+window.__bwfc = window.__bwfc || {};
+window.__bwfc.postBackTargets = window.__bwfc.postBackTargets || {};
+if (!window.__doPostBack) {
+    window.__doPostBack = function(t, a) {
+        var h = window.__bwfc.postBackTargets[t];
+        if (h) h.invokeMethodAsync('HandlePostBackFromJs', t, a);
+        else console.warn('[BWFC] No postback handler for:', t);
+    };
+}
+if (!window.__bwfc.registerPostBackTarget) {
+    window.__bwfc.registerPostBackTarget = function(id, dotNetRef) {
+        window.__bwfc.postBackTargets[id] = dotNetRef;
+    };
+}
+if (!window.__bwfc.unregisterPostBackTarget) {
+    window.__bwfc.unregisterPostBackTarget = function(id) {
+        delete window.__bwfc.postBackTargets[id];
+    };
+}
+if (!window.__bwfc_callback) {
+    window.__bwfc_callback = function(id, arg, successCb, ctx, errorCb) {
+        var h = window.__bwfc.postBackTargets[id];
+        if (h) {
+            h.invokeMethodAsync('HandleCallbackFromJs', id, arg)
+                .then(function(r) { if (successCb) successCb(r, ctx); })
+                .catch(function(e) { if (errorCb) errorCb(e.message, ctx); });
+        }
+    };
+}
+";
+
+/// <summary>
+/// Called from JavaScript when <c>__doPostBack(eventTarget, eventArgument)</c> fires.
+/// Raises the <see cref="PostBack"/> event and triggers a re-render.
+/// </summary>
+[JSInvokable]
+public Task HandlePostBackFromJs(string eventTarget, string eventArgument)
+{
+    PostBack?.Invoke(this, new PostBackEventArgs(eventTarget, eventArgument));
+    StateHasChanged();
+    return Task.CompletedTask;
+}
+
+/// <summary>
+/// Called from JavaScript when <c>__bwfc_callback</c> fires.
+/// Override in derived pages to return callback data.
+/// </summary>
+[JSInvokable]
+public virtual Task<string> HandleCallbackFromJs(string eventTarget, string eventArgument)
+{
+    return Task.FromResult(string.Empty);
+}
+
+/// <inheritdoc />
+protected override async Task OnAfterRenderAsync(bool firstRender)
+{
+    await base.OnAfterRenderAsync(firstRender);
+
+    if (firstRender)
+    {
+        _postBackTargetId = $"{GetType().Name}_{GetHashCode()}";
+        _postBackRef = DotNetObjectReference.Create(this);
+
+        // Bootstrap __doPostBack and registration functions
+        await _jsRuntime.InvokeVoidAsync("eval", PostBackBootstrapJs);
+        await _jsRuntime.InvokeVoidAsync("__bwfc.registerPostBackTarget",
+            _postBackTargetId, _postBackRef);
+    }
+
+    // Flush any queued ClientScript registrations
+    if (_clientScriptShim != null)
+    {
+        await _clientScriptShim.FlushAsync(_jsRuntime);
+    }
+}
+
+/// <inheritdoc />
+public virtual async ValueTask DisposeAsync()
+{
+    if (_postBackTargetId != null && _postBackRef != null)
+    {
+        try
+        {
+            await _jsRuntime.InvokeVoidAsync(
+                "__bwfc.unregisterPostBackTarget", _postBackTargetId);
+        }
+        catch (JSDisconnectedException) { }
+        catch (ObjectDisposedException) { }
+        catch (InvalidOperationException) { }
+
+        _postBackRef.Dispose();
+        _postBackRef = null;
+    }
+}
 }
\ No newline at end of file
diff --git a/src/BlazorWebFormsComponents/wwwroot/js/bwfc-postback.js b/src/BlazorWebFormsComponents/wwwroot/js/bwfc-postback.js
new file mode 100644
index 00000000..8ca6ab29
--- /dev/null
+++ b/src/BlazorWebFormsComponents/wwwroot/js/bwfc-postback.js
@@ -0,0 +1,41 @@
+// bwfc-postback.js — PostBack interop for BlazorWebFormsComponents
+// Provides __doPostBack and callback bridge functions that mirror Web Forms behavior.
+// Loaded automatically by WebFormsPageBase; may also be included via <script> tag.
+
+(function () {
+    'use strict';
+
+    window.__bwfc = window.__bwfc || {};
+    window.__bwfc.postBackTargets = window.__bwfc.postBackTargets || {};
+
+    // Classic __doPostBack — same signature as Web Forms
+    window.__doPostBack = function (eventTarget, eventArgument) {
+        var target = window.__bwfc.postBackTargets[eventTarget];
+        if (target) {
+            target.invokeMethodAsync('HandlePostBackFromJs', eventTarget, eventArgument);
+        } else {
+            console.warn('[BWFC] No postback handler for:', eventTarget);
+        }
+    };
+
+    // Register a .NET component as a postback target
+    window.__bwfc.registerPostBackTarget = function (id, dotNetRef) {
+        window.__bwfc.postBackTargets[id] = dotNetRef;
+    };
+
+    // Unregister a postback target (called on dispose)
+    window.__bwfc.unregisterPostBackTarget = function (id) {
+        delete window.__bwfc.postBackTargets[id];
+    };
+
+    // Callback bridge — mirrors Web Forms ICallbackEventHandler pattern
+    window.__bwfc_callback = function (id, arg, successCallback, context, errorCallback) {
+        var target = window.__bwfc.postBackTargets[id];
+        if (target) {
+            target.invokeMethodAsync('HandleCallbackFromJs', id, arg)
+                .then(function (result) { if (successCallback) successCallback(result, context); })
+                .catch(function (err) { if (errorCallback) errorCallback(err.message, context); });
+        }
+    };
+
+})();
diff --git a/tests/BlazorWebFormsComponents.Cli.Tests/TestData/expected/TC33-ClientScript.razor.cs b/tests/BlazorWebFormsComponents.Cli.Tests/TestData/expected/TC33-ClientScript.razor.cs
index d3d2d78f..def06bbf 100644
--- a/tests/BlazorWebFormsComponents.Cli.Tests/TestData/expected/TC33-ClientScript.razor.cs
+++ b/tests/BlazorWebFormsComponents.Cli.Tests/TestData/expected/TC33-ClientScript.razor.cs
@@ -20,7 +20,7 @@ namespace MyApp
 {
     public partial class TC33_ClientScript
     {
-    // TODO(bwfc-general): ClientScript calls preserved — uses ClientScriptShim. Inject @inject ClientScriptShim ClientScript if not using BaseWebFormsComponent.
+    // TODO(bwfc-general): ClientScript calls preserved — uses ClientScriptShim + ScriptManagerShim. Inject @inject ClientScriptShim ClientScript and @inject ScriptManagerShim ScriptManager if not using BaseWebFormsComponent.
 
         protected override async Task OnInitializedAsync()
         {
@@ -40,8 +40,7 @@ protected override async Task OnInitializedAsync()
                 ResolveUrl("~/Scripts/jquery-ui.min.js"));
 
             // Pattern 3: GetPostBackEventReference
-            // TODO(bwfc-general): Replace __doPostBack with @onclick or EventCallback. See ClientScriptMigrationGuide.md
-            // Original: var postbackRef = Page.ClientScript.GetPostBackEventReference(btnSubmit, "validate");
+            var postbackRef = ClientScript.GetPostBackEventReference(btnSubmit, "validate");
 
             // Pattern 4: RegisterClientScriptBlock
             ClientScript.RegisterClientScriptBlock(this.GetType(), "block1", "<script>var x = 1;</script>");
@@ -50,7 +49,7 @@ protected override async Task OnInitializedAsync()
             ClientScript.RegisterStartupScript(this.GetType(), "smScript", "alert('hello');", true);
 
             // Pattern 6: ScriptManager.GetCurrent
-            // TODO(bwfc-general): ScriptManager.GetCurrent() has no Blazor equivalent. Use IJSRuntime directly.
+            var sm = ScriptManager.GetCurrent(this);
         }
     }
 }
diff --git a/tests/BlazorWebFormsComponents.Cli.Tests/TransformUnit/ClientScriptTransformTests.cs b/tests/BlazorWebFormsComponents.Cli.Tests/TransformUnit/ClientScriptTransformTests.cs
index 2809dd47..cb3ac137 100644
--- a/tests/BlazorWebFormsComponents.Cli.Tests/TransformUnit/ClientScriptTransformTests.cs
+++ b/tests/BlazorWebFormsComponents.Cli.Tests/TransformUnit/ClientScriptTransformTests.cs
@@ -229,10 +229,10 @@ void Page_Load()
 
     #endregion
 
-    #region TC38 — GetPostBackEventReference and ScriptManager.GetCurrent
+    #region TC38 — GetPostBackEventReference and ScriptManager.GetCurrent (Phase 2: shim-preserving)
 
     [Fact]
-    public void TC38_GetPostBackEventReference_EmitsTodoWithEventCallbackGuidance()
+    public void TC38_GetPostBackEventReference_StripsPagePrefix()
     {
         var input = @"namespace MyApp
 {
@@ -246,13 +246,14 @@ void DoWork()
 }";
         var result = _transform.Apply(input, TestMetadata(input));
 
-        Assert.Contains("TODO(bwfc-general)", result);
-        Assert.Contains("@onclick", result);
-        Assert.Contains("EventCallback", result);
+        Assert.Contains("ClientScript.GetPostBackEventReference(btnSubmit", result);
+        Assert.DoesNotContain("Page.ClientScript", result);
+        Assert.DoesNotContain("// TODO(bwfc-general): Replace __doPostBack", result);
+        Assert.DoesNotContain("// Original:", result);
     }
 
     [Fact]
-    public void TC38_GetPostBackEventReference_PreservesOriginalAsComment()
+    public void TC38_GetPostBackEventReference_StripsThisPrefix()
     {
         var input = @"namespace MyApp
 {
@@ -260,18 +261,38 @@ public partial class MyPage
     {
         void DoWork()
         {
-            var postbackRef = Page.ClientScript.GetPostBackEventReference(btnSubmit, ""validate"");
+            var postbackRef = this.ClientScript.GetPostBackEventReference(btnSubmit, ""validate"");
         }
     }
 }";
         var result = _transform.Apply(input, TestMetadata(input));
 
-        Assert.Contains("// Original:", result);
-        Assert.Contains("GetPostBackEventReference", result);
+        Assert.Contains("ClientScript.GetPostBackEventReference(btnSubmit", result);
+        Assert.DoesNotContain("this.ClientScript", result);
+        Assert.DoesNotContain("// Original:", result);
     }
 
     [Fact]
-    public void TC38_ScriptManagerGetCurrent_EmitsTodo()
+    public void TC38_GetPostBackEventReference_BareCall_SetsShimFlag()
+    {
+        var input = @"namespace MyApp
+{
+    public partial class MyPage
+    {
+        void DoWork()
+        {
+            var postbackRef = ClientScript.GetPostBackEventReference(btnSubmit, ""validate"");
+        }
+    }
+}";
+        var result = _transform.Apply(input, TestMetadata(input));
+
+        Assert.Contains("ClientScript.GetPostBackEventReference(btnSubmit", result);
+        Assert.Contains("ClientScriptShim", result);
+    }
+
+    [Fact]
+    public void TC38_ScriptManagerGetCurrent_ConvertsPageToThis()
     {
         var input = @"namespace MyApp
 {
@@ -285,13 +306,32 @@ void Page_Load()
 }";
         var result = _transform.Apply(input, TestMetadata(input));
 
-        Assert.Contains("TODO(bwfc-general)", result);
-        Assert.Contains("ScriptManager.GetCurrent()", result);
-        Assert.Contains("IJSRuntime", result);
+        Assert.Contains("ScriptManager.GetCurrent(this)", result);
+        Assert.DoesNotContain("ScriptManager.GetCurrent(Page)", result);
+        Assert.DoesNotContain("ScriptManager.GetCurrent() has no Blazor equivalent", result);
+    }
+
+    [Fact]
+    public void TC38_ScriptManagerGetCurrent_WithThisDotPage_ConvertsToThis()
+    {
+        var input = @"namespace MyApp
+{
+    public partial class MyPage
+    {
+        void Page_Load()
+        {
+            var sm = ScriptManager.GetCurrent(this.Page);
+        }
+    }
+}";
+        var result = _transform.Apply(input, TestMetadata(input));
+
+        Assert.Contains("ScriptManager.GetCurrent(this)", result);
+        Assert.DoesNotContain("this.Page", result);
     }
 
     [Fact]
-    public void TC38_ScriptManagerGetCurrent_WithThis_EmitsTodo()
+    public void TC38_ScriptManagerGetCurrent_PreservesThis()
     {
         var input = @"namespace MyApp
 {
@@ -305,8 +345,49 @@ void Page_Load()
 }";
         var result = _transform.Apply(input, TestMetadata(input));
 
-        Assert.Contains("TODO(bwfc-general)", result);
-        Assert.Contains("ScriptManager.GetCurrent()", result);
+        Assert.Contains("ScriptManager.GetCurrent(this)", result);
+        Assert.DoesNotContain("ScriptManager.GetCurrent() has no Blazor equivalent", result);
+        Assert.Contains("ScriptManagerShim", result);
+    }
+
+    [Fact]
+    public void TC38_ScriptManagerGetCurrent_AddsScriptManagerShimComment()
+    {
+        var input = @"namespace MyApp
+{
+    public partial class MyPage
+    {
+        void Page_Load()
+        {
+            var sm = ScriptManager.GetCurrent(Page);
+        }
+    }
+}";
+        var result = _transform.Apply(input, TestMetadata(input));
+
+        Assert.Contains("ScriptManagerShim", result);
+        Assert.Contains("ClientScriptShim", result);
+    }
+
+    [Fact]
+    public void TC38_ScriptManagerGetCurrent_FullPattern_Preserved()
+    {
+        var input = @"namespace MyApp
+{
+    public partial class MyPage
+    {
+        void Page_Load()
+        {
+            ScriptManager sm = ScriptManager.GetCurrent(Page);
+            sm.RegisterStartupScript(this.GetType(), ""key"", ""script"", true);
+        }
+    }
+}";
+        var result = _transform.Apply(input, TestMetadata(input));
+
+        Assert.Contains("ScriptManager sm = ScriptManager.GetCurrent(this)", result);
+        Assert.Contains("sm.RegisterStartupScript(this.GetType()", result);
+        Assert.Contains("ScriptManagerShim", result);
     }
 
     #endregion
@@ -342,10 +423,12 @@ void Page_Load()
         Assert.Contains("ClientScript.RegisterClientScriptBlock", result);
         // ScriptManager.RegisterStartupScript → ClientScript.RegisterStartupScript
         Assert.DoesNotContain("ScriptManager.RegisterStartupScript", result);
-        // Postback → TODO with EventCallback
-        Assert.Contains("@onclick", result);
-        // ScriptManager.GetCurrent → TODO
-        Assert.Contains("ScriptManager.GetCurrent() has no Blazor equivalent", result);
+        // Postback → preserved with prefix stripped
+        Assert.Contains("ClientScript.GetPostBackEventReference", result);
+        Assert.DoesNotContain("Page.ClientScript.GetPostBackEventReference", result);
+        // ScriptManager.GetCurrent → Page replaced with this
+        Assert.Contains("ScriptManager.GetCurrent(this)", result);
+        Assert.DoesNotContain("ScriptManager.GetCurrent(Page)", result);
         // ClientScriptShim comment injected (not IJSRuntime)
         Assert.Contains("ClientScriptShim", result);
         Assert.DoesNotContain("[Inject] private IJSRuntime JS", result);
@@ -367,7 +450,7 @@ public partial class MyPage
     }
 
     [Fact]
-    public void DoesNotAddShimComment_WhenOnlyPostbackRef()
+    public void AddsShimComment_WhenOnlyPostbackRef()
     {
         var input = @"namespace MyApp
 {
@@ -381,7 +464,7 @@ void DoWork()
 }";
         var result = _transform.Apply(input, TestMetadata(input));
 
-        Assert.DoesNotContain("ClientScriptShim", result);
+        Assert.Contains("ClientScriptShim", result);
     }
 
     [Fact]