fix: postback target ID mismatch + wait for JS bootstrap in tests

- WebFormsPageBase: _postBackTargetId now uses GetType().Name to match
  ResolveControlId() (was appending _GetHashCode() causing lookup miss)
- PostBackTests: wait for __doPostBack function before clicking (race fix)
- PostBackTests: use Assertions.Expect().ToContainTextAsync() instead of
  fixed 2-second delays for more reliable CI assertions

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: csharpfritz

.ai-team/agents/bishop/history.md

@@ -214,3 +214,21 @@ Added `ClientScriptTransform.cs` (Order 850) to the code-behind pipeline. Handle
 - **Tests:** All 349 tests pass (same count as before), updated 20 unit test assertions + TC33 expected output file.
 - **Regex approach:** Single `PageOrThisPrefixRegex` with lookahead handles all three shim-compatible methods in one pass. Much simpler than the old per-pattern regexes with inline script extraction.
 
+### ClientScriptTransform: Phase 2 — PostBack + ScriptManager Shim-Preserving (Bishop)
+
+- **Date:** 2026-07-31
+- **What changed:** `ClientScriptTransform.cs` (Order 850) now preserves ALL ClientScript/ScriptManager patterns for shim use. No more TODO markers.
+- **Phase 2 patterns (newly shim-preserved):**
+  - `Page.ClientScript.GetPostBackEventReference(...)` → `ClientScript.GetPostBackEventReference(...)` (prefix stripped)
+  - `this.ClientScript.GetPostBackEventReference(...)` → `ClientScript.GetPostBackEventReference(...)` (prefix stripped)
+  - `ScriptManager.GetCurrent(Page)` → `ScriptManager.GetCurrent(this)` (Page→this substitution)
+  - `ScriptManager.GetCurrent(this.Page)` → `ScriptManager.GetCurrent(this)` (this.Page→this substitution)
+  - `ScriptManager.GetCurrent(this)` → preserved as-is (already correct)
+- **Regex changes:**
+  - `PageOrThisPrefixRegex` lookahead expanded to include `GetPostBackEventReference`
+  - Removed `GetPostBackEventRefRegex` and `ScriptManagerGetCurrentRegex` (TODO-emitting regexes)
+  - Added `ScriptManagerGetCurrentPageRegex` for Page→this substitution
+- **Shim comment:** Now conditionally mentions `ScriptManagerShim` when ScriptManager patterns detected (dual-shim comment)
+- **Tests:** 353 total (was 349) — 4 new test cases for Phase 2 patterns, updated 6 existing assertions
+- **Key design decision:** `hasScriptManagerCall` flag tracks ScriptManager presence separately from `hasShimCall` to conditionally generate the dual-shim comment
+

.squad/agents/beast/history.md

@@ -5,7 +5,7 @@
 - **Stack:** C#, Blazor, .NET, ASP.NET Web Forms, bUnit, xUnit, MkDocs, Playwright
 - **Created:** 2026-02-10
 
-
+
 📌 Team update (2026-08-XX): ClientScriptShim documentation delivery — Updated ClientScriptMigrationGuide.md with prominent new section positioning ClientScriptShim as zero-rewrite path (+2,100 lines total), including supported methods table, before/after example, "How It Works" technical explanation, and migration approach comparison (ClientScriptShim vs. manual IJSRuntime vs. JS modules). Updated BWFC022.md, BWFC023.md, BWFC024.md analyzer docs with cross-references to new ClientScriptShim guidance. mkdocs.yml verified (guide already in nav). Strategy: Lead with easiest path first (ClientScriptShim), then modern alternatives for teams ready to modernize. Enables rapid migration for large Web Forms codebases. — decided by Beast
 
 📌 Team update (2026-07-30): ClientScript Migration Support PRD delivered  9-section product requirements document (dev-docs/prd-clientscript-migration-support.md, 38K) covering analyzer improvements (BWFC022/023/024), CLI transforms (startup scripts, includes), safe automation boundaries, TODO guidance, documentation (ClientScriptMigrationGuide.md), testing (8 test cases), and 3-phase roadmap (P1: analyzers + transforms + docs, P2: samples, P3: runtime helpers). Based on Forge CLI Gap Analysis 1.2 (HIGH impact gap). Establishes BWFC position: prefer IJSRuntime over ClientScript shim; emit clear TODO for postback patterns; DO NOT emulate __doPostBack. Ready for implementation planning.  decided by Beast

.squad/agents/colossus/history.md

@@ -290,3 +290,13 @@ All 3 tests passing. Test suite now has 18 test cases (was 15). Pass rate 78% (1
   - Removal of : System.Web.UI.Page base class from partial classes
 - URL cleanup transform only applies to Response.Redirect() call arguments, not to arbitrary string literals containing URLs
 - To verify exact output: copy input files to temp directory, run bwfc-migrate.ps1 on directory (not individual file), examine generated .razor/.razor.cs files
+
+## PostBack Demo Integration Tests (Phase 2)
+
+**Date:** 2026-07-23
+**Task:** Write Playwright integration tests for `/postback-demo` page (Phase 2 of ClientScript migration).
+**File created:** `samples/AfterBlazorServerSide.Tests/Migration/PostBackTests.cs`
+**Tests:** 3 tests — PostBack button trigger, PostBack hyperlink click, ScriptManager startup script registration.
+**Status:** Compiles clean (0 errors). Demo page not yet created by Jubilee — tests will pass once the page exists.
+**Patterns used:** Same `[Collection(nameof(PlaywrightCollection))]` + `PlaywrightFixture` pattern as all other migration tests. 30s navigation timeout, 10s element wait, 2s post-action settle for CI reliability. `try/finally` with `page.CloseAsync()`.
+**Commit:** `0c75aba2` on `feature/clientscript-phase2`

.squad/agents/cyclops/history.md

@@ -941,3 +941,24 @@ foreach (var warning in warnings) {
 - Includes loaded via dynamic `<script>` element creation in eval
 - Auto-flush happens every render (not just firstRender) so scripts registered in event handlers work correctly
 - Build: 0 errors across net8.0/net9.0/net10.0
+
+### ClientScript Phase 2: PostBack + ScriptManager Runtime (2026-07-17)
+
+**Summary:** Replaced NotSupportedException stubs with working PostBack/Callback implementations. Created full JS interop bridge for __doPostBack and ScriptManager.GetCurrent() pattern.
+
+**Files Created:**
+- PostBackEventArgs.cs, ScriptManagerShim.cs, bwfc-postback.js
+
+**Files Modified:**
+- ClientScriptShim.cs: 3 methods now return working JS strings; added ResolveControlId
+- WebFormsPageBase.cs: IAsyncDisposable, ClientScript, PostBack event, JSInvokable handlers, OnAfterRenderAsync registration
+- ServiceCollectionExtensions.cs: ScriptManagerShim DI registration
+- ClientScriptShimTests.cs: Updated tests for new behavior + null edge cases
+
+**Technical Decisions:**
+- Inline JS bootstrap avoids race conditions with external script loading
+- ResolveControlId prefers BaseWebFormsComponent.ID, falls back to type name
+- ScriptManagerShim: both DI and static GetCurrent() factory
+- PostBack target ID: TypeName_HashCode for per-instance uniqueness
+
+**Build:** 0 errors, 32 tests pass x 3 TFMs

.squad/agents/rogue/history.md

@@ -490,3 +490,17 @@ Conventions discovered: SessionShim uses Shouldly assertions + xUnit `[Fact]` (m
 - System.CommandLine tests work by reconstructing the command tree locally rather than trying to invoke Program.Main — this decouples from Bishop's refactoring of Program.cs.
 - Test case count: 21 TC* cases (TC01-TC21), of which 8 have code-behind pairs (TC13-TC16, TC18-TC21). Total 29 input files + 29 expected files = 58 TestData files.
 
+### Phase 2 PostBack + ScriptManager Shim Tests (2026-07)
+
+**Wrote 35 new unit tests across 3 files for Phase 2 shims.** All 70 targeted tests pass (including pre-existing Phase 1 tests) across net8.0/net9.0/net10.0. Zero regressions (55 pre-existing failures in ViewState/RequestShim unrelated).
+
+**Files modified/created:**
+- `ClientScriptShimTests.cs` (modified) — 15 new tests: GetPostBackEventReference escaping (single quotes, backslashes), output format, null/empty args, control type resolution; GetPostBackClientHyperlink consistency with EventReference, null control, escaping; GetCallbackEventReference escaping (single quotes, backslashes in context), null context/argument defaults, output format with all params.
+- `ScriptManagerShimTests.cs` (created) — 12 tests: Constructor null throws ArgumentNull, valid construction; GetCurrent error cases (plain object, null, integer, error message content); GetCurrent success via reflection-injected ClientScriptShim on mock BaseWebFormsComponent; Delegation tests for RegisterStartupScript (3 overloads), RegisterClientScriptBlock, RegisterClientScriptInclude.
+- `PostBackEventArgsTests.cs` (created) — 11 tests: Constructor sets EventTarget/EventArgument, null target/argument allowed, both null, empty strings; Immutability via reflection (CanWrite=false); Inherits from System.EventArgs; Round-trip with special characters, Unicode, long strings.
+
+**Key patterns used:**
+- Reflection to inject `_clientScript`/`_clientScriptResolved` on `Mock<BaseWebFormsComponent>` for `GetCurrent` success test (ClientScript property is non-virtual, can't be mocked directly).
+- Fully-qualified `BlazorWebFormsComponents.BaseWebFormsComponent` required — test project has a `BaseWebFormsComponent/` folder creating namespace ambiguity. Same for `System.EventArgs` vs `EventArgs/` folder.
+- `dotnet test --filter` uses `|` for OR (not `OR` keyword) in vstest filter expressions.
+

.squad/decisions/inbox/bishop-phase2-transform.md

@@ -0,0 +1,23 @@
+# Decision: CLI Transform Preserves All ClientScript/ScriptManager Patterns (Phase 2)
+
+**Date:** 2026-07-31
+**Author:** Bishop (Migration Tooling Dev)
+**Status:** Implemented
+
+## Context
+
+ClientScriptTransform Phase 1 emitted TODO markers for `GetPostBackEventReference` and `ScriptManager.GetCurrent()` because no runtime shim existed. Phase 2 shims (ClientScriptShim + ScriptManagerShim) now handle these patterns.
+
+## Decision
+
+The CLI transform now preserves ALL six ClientScript/ScriptManager patterns instead of commenting out two of them. Zero TODO markers remain — shims handle everything at runtime.
+
+- `GetPostBackEventReference` → prefix-stripped, preserved for ClientScriptShim
+- `ScriptManager.GetCurrent(Page)` → converted to `ScriptManager.GetCurrent(this)` for ScriptManagerShim
+- Shim dependency comment conditionally mentions ScriptManagerShim when ScriptManager patterns detected
+
+## Impact
+
+- All agents: migrated code no longer has `// TODO: Replace __doPostBack` or `// TODO: ScriptManager.GetCurrent() has no Blazor equivalent` — these calls just work via shims
+- Layer 2 agents: less manual fixup needed for postback and ScriptManager patterns
+- Test count: 349 → 353

.squad/decisions/inbox/cyclops-postback-shim.md

@@ -0,0 +1,25 @@
+# Decision: PostBack Shim Runtime Strategy
+
+**Date:** 2026-07-17  
+**Author:** Cyclops  
+**Status:** Implemented  
+
+## Context
+
+ClientScriptShim Phase 1 left `GetPostBackEventReference()`, `GetPostBackClientHyperlink()`, and `GetCallbackEventReference()` as `NotSupportedException` stubs. Phase 2 needed to make these return working JavaScript strings — zero rewrite, same API.
+
+## Decision
+
+1. **Inline JS bootstrap** — WebFormsPageBase.OnAfterRenderAsync injects `__doPostBack` and registration functions via `eval()` on firstRender. This avoids race conditions with external script loading while keeping `bwfc-postback.js` available as an optional static asset.
+
+2. **ResolveControlId priority** — Checks `BaseWebFormsComponent.ID` first (the developer-assigned HTML ID), then falls back to `GetType().Name`. This matches Web Forms' ClientID behavior.
+
+3. **ScriptManagerShim dual-path** — Supports both DI injection (`services.AddScoped<ScriptManagerShim>`) and static `GetCurrent(page)` factory. Migrated code using `ScriptManager.GetCurrent(Page)` compiles unchanged.
+
+4. **PostBack target ID format** — `TypeName_HashCode` ensures per-instance uniqueness when multiple page components exist.
+
+## Impact
+
+- Tests updated: 3 tests changed from throw-verification to return-value-verification, plus 3 new null-handling tests
+- No breaking changes to existing consumers
+- WebFormsPageBase now implements IAsyncDisposable (new interface on the class)

samples/AfterBlazorServerSide.Tests/Migration/PostBackTests.cs

@@ -34,30 +34,17 @@ public async Task PostBack_Button_TriggersPostBackEvent()
                 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
-            });
+            // Wait for __doPostBack to be bootstrapped by OnAfterRenderAsync
+            await page.WaitForFunctionAsync("typeof window.__doPostBack === 'function'",
+                null, new PageWaitForFunctionOptions { Timeout = 10000 });
 
+            var button = page.Locator("#postback-button");
             await button.ClickAsync();
 
-            // Wait for the result to appear after the server round-trip
+            // Wait for Blazor to process the postback and re-render
             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!);
+            await Assertions.Expect(result).ToContainTextAsync("PostBack received!",
+                new LocatorAssertionsToContainTextOptions { Timeout = 10000 });
         }
         finally
         {
@@ -82,30 +69,17 @@ public async Task PostBackHyperlink_Click_TriggersPostBackEvent()
                 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
-            });
+            // Wait for __doPostBack to be bootstrapped by OnAfterRenderAsync
+            await page.WaitForFunctionAsync("typeof window.__doPostBack === 'function'",
+                null, new PageWaitForFunctionOptions { Timeout = 10000 });
 
+            var link = page.Locator("#postback-link");
             await link.ClickAsync();
 
-            // Wait for the result to appear after the server round-trip
+            // Wait for Blazor to process the postback and re-render
             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!);
+            await Assertions.Expect(result).ToContainTextAsync("PostBack received!",
+                new LocatorAssertionsToContainTextOptions { Timeout = 10000 });
         }
         finally
         {
@@ -132,14 +106,8 @@ public async Task ScriptManager_GetCurrent_RegistersStartupScript()
 
             // 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);
+            await Assertions.Expect(target).Not.ToHaveTextAsync(string.Empty,
+                new LocatorAssertionsToHaveTextOptions { Timeout = 10000 });
 
             var targetText = await target.TextContentAsync();
             Assert.NotNull(targetText);

src/BlazorWebFormsComponents/WebFormsPageBase.cs

@@ -325,7 +325,7 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
 
     if (firstRender)
     {
-        _postBackTargetId = $"{GetType().Name}_{GetHashCode()}";
+        _postBackTargetId = GetType().Name;
         _postBackRef = DotNetObjectReference.Create(this);
 
         // Bootstrap __doPostBack and registration functions