Merge branch 'codex/fix-browser-ci-duration'

# Conflicts:
#	AGENTS.md
#	Tests/ManagedCode.Storage.Tests/Storages/Browser/BrowserServerStorageIntegrationTests.cs
#	Tests/ManagedCode.Storage.Tests/Storages/Browser/BrowserWasmStorageIntegrationTests.cs
#	docs/Development/setup.md
#	docs/Testing/strategy.md

Author: KSemenenko

.github/workflows/ci.yml

@@ -13,6 +13,7 @@ jobs:
   build-and-test:
     name: build-and-test
     runs-on: ubuntu-latest
+    timeout-minutes: 15
 
     steps:
     - name: Checkout
@@ -47,3 +48,32 @@ jobs:
         token: ${{ secrets.CODECOV_TOKEN }}
         files: ./**/coverage.cobertura.xml
         fail_ci_if_error: false
+
+  browser-stress:
+    name: browser-stress
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v5
+
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: ${{ env.DOTNET_VERSION }}
+
+    - name: Restore dependencies
+      run: dotnet restore ManagedCode.Storage.slnx
+
+    - name: Restore .NET tools
+      run: dotnet tool restore
+
+    - name: Build
+      run: dotnet build ManagedCode.Storage.slnx --configuration Release --no-restore
+
+    - name: Install Playwright browser
+      run: dotnet playwright -p Tests/ManagedCode.Storage.Tests/ManagedCode.Storage.Tests.csproj install chromium
+
+    - name: Browser stress test
+      run: dotnet test Tests/ManagedCode.Storage.Tests/ManagedCode.Storage.Tests.csproj --configuration Release --no-build --verbosity normal --filter "Category=BrowserStress"

.github/workflows/release.yml

@@ -12,6 +12,7 @@ jobs:
   build:
     name: Build and Test
     runs-on: ubuntu-latest
+    timeout-minutes: 20
 
     outputs:
       version: ${{ steps.version.outputs.version }}
@@ -57,9 +58,40 @@ jobs:
         path: ./artifacts/*.nupkg
         retention-days: 5
 
+  browser-stress:
+    name: Browser Stress
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v5
+
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: ${{ env.DOTNET_VERSION }}
+
+    - name: Restore dependencies
+      run: dotnet restore ManagedCode.Storage.slnx
+
+    - name: Restore .NET tools
+      run: dotnet tool restore
+
+    - name: Build
+      run: dotnet build ManagedCode.Storage.slnx --configuration Release --no-restore
+
+    - name: Install Playwright browser
+      run: dotnet playwright -p Tests/ManagedCode.Storage.Tests/ManagedCode.Storage.Tests.csproj install chromium
+
+    - name: Browser stress test
+      run: dotnet test Tests/ManagedCode.Storage.Tests/ManagedCode.Storage.Tests.csproj --configuration Release --no-build --verbosity normal --filter "Category=BrowserStress"
+
   publish-nuget:
     name: Publish to NuGet
-    needs: build
+    needs:
+    - build
+    - browser-stress
     runs-on: ubuntu-latest
     if: github.ref == 'refs/heads/main'
 

AGENTS.md

@@ -136,8 +136,9 @@ If the stack is `.NET`, follow these skill-management rules explicitly:
 
 - `restore`: `dotnet restore ManagedCode.Storage.slnx`
 - `build`: `dotnet build ManagedCode.Storage.slnx`
-- `test`: `dotnet test Tests/ManagedCode.Storage.Tests/ManagedCode.Storage.Tests.csproj --configuration Release`
-- `coverage`: `dotnet test Tests/ManagedCode.Storage.Tests/ManagedCode.Storage.Tests.csproj --configuration Release /p:CollectCoverage=true /p:CoverletOutput=coverage /p:CoverletOutputFormat=opencover`
+- `test`: `dotnet test Tests/ManagedCode.Storage.Tests/ManagedCode.Storage.Tests.csproj --configuration Release --filter "Category!=BrowserStress"`
+- `browser-stress`: `dotnet test Tests/ManagedCode.Storage.Tests/ManagedCode.Storage.Tests.csproj --configuration Release --filter "Category=BrowserStress"`
+- `coverage`: `dotnet test Tests/ManagedCode.Storage.Tests/ManagedCode.Storage.Tests.csproj --configuration Release --filter "Category!=BrowserStress" /p:CollectCoverage=true /p:CoverletOutput=coverage /p:CoverletOutputFormat=opencover`
 - `format`: `dotnet format ManagedCode.Storage.slnx`
 
 Toolchain notes:
@@ -240,6 +241,7 @@ Toolchain notes:
 - Coverage uses the repo-defined `coverlet.msbuild` flow and must not regress without a written exception.
 - Place provider suites under `Tests/ManagedCode.Storage.Tests/Storages/` and reuse `Tests/ManagedCode.Storage.Tests/Common/` helpers for Testcontainers infrastructure such as Azurite, LocalStack, and FakeGcsServer.
 - For browser providers, put end-to-end Playwright coverage in `Tests/ManagedCode.Storage.Tests/Storages/Browser/` and keep the executable test hosts under `Tests/ManagedCode.Storage.BrowserServerHost/` and `Tests/ManagedCode.Storage.BrowserWasmHost/`.
+- Keep browser large-file verification tiered: the default `test` path keeps the fast browser large-file lane, while `browser-stress` runs the heavier explicit browser stress checks separately and must stay automated in CI and release.
 
 ### Storage Platform
 
@@ -323,9 +325,11 @@ Ask first:
 
 - Repository-facing docs, especially `README.md`, should stay in English and describe only the current supported behavior, not transitional legacy or fallback paths.
 - Temporary root-level `*.plan.md` files should be removed once a task is complete and their contents are no longer needed.
+- Browser large-file coverage should use tiered automation: a fast default CI lane plus an explicit stress lane, so merge confidence stays high without accepting 30+ minute default runs.
 
 ### Dislikes
 
 - Template-generated scaffolding in tests; keep test hosts and verification surfaces minimal, hand-written, and purpose-built.
 - CI regressions that inflate `build-and-test` far beyond the historical baseline; browser large-file coverage must stay meaningful without turning the default GitHub Actions path into a 30+ minute run.
+- Disabling meaningful regression tests in default CI or release flows just to hide performance or flakiness problems; fix the runtime cost, or move them into a separate explicit required lane instead of silently dropping coverage.
 - Unnecessary product-code fallbacks; prefer one clear production path unless backward compatibility is an explicit requirement for the task.

Directory.Build.props

@@ -29,8 +29,8 @@
         <RepositoryUrl>https://github.com/managedcode/Storage</RepositoryUrl>
         <PackageProjectUrl>https://github.com/managedcode/Storage</PackageProjectUrl>
         <Product>Managed Code - Storage</Product>
-        <Version>10.0.4</Version>
-        <PackageVersion>10.0.4</PackageVersion>
+        <Version>10.0.5</Version>
+        <PackageVersion>10.0.5</PackageVersion>
 
     </PropertyGroup>
 

README.md

@@ -106,7 +106,7 @@ Cloud storage vendors expose distinct SDKs, option models, and authentication pa
 - `ManagedCode.Storage.Client` brings streaming uploads/downloads, CRC32 helpers, and MIME discovery via `MimeHelper` to any .NET app.
 - Strongly typed option objects (`UploadOptions`, `DownloadOptions`, `DeleteOptions`, `MetadataOptions`, `LegalHoldOptions`, etc.) let you configure directories, metadata, and legal holds in one place.
 - Virtual File System package provides a file/directory API (`IVirtualFileSystem`) on top of the configured `IStorage` and can cache metadata for faster repeated operations, including browser storage verified through real Playwright flows in both Blazor WebAssembly and Interactive Server hosts.
-- Comprehensive automated test suite with cross-provider sync fixtures, multi-gigabyte streaming simulations (4 MB units per "GB"), ASP.NET controller harnesses, SFTP/local filesystem coverage, and Playwright browser verification for browser storage small-file overwrites, concurrent tabs, VFS flows, and `1 GiB` round-trips in both Interactive Server and Blazor WebAssembly hosts.
+- Comprehensive automated test suite with cross-provider sync fixtures, multi-gigabyte streaming simulations (4 MB units per "GB"), ASP.NET controller harnesses, SFTP/local filesystem coverage, and Playwright browser verification for browser storage small-file overwrites, concurrent tabs, VFS flows, a fast `128 MiB` browser large-file lane, and a separate `256 MiB` browser stress lane in both Interactive Server and Blazor WebAssembly hosts.
 - ManagedCode.Storage.TestFakes package plus Testcontainers-based fixtures make it easy to run offline or CI tests without touching real cloud accounts.
 
 ## Packages
@@ -979,7 +979,7 @@ If an MVC or Razor Pages application needs the packaged browser module path for
 
 > Browser payloads use the browser Origin Private File System (OPFS). IndexedDB stays in the design only for blob metadata and list or lookup operations. If OPFS is unavailable in the current browser, uploads fail fast instead of silently falling back to a second payload backend.
 
-> The real Playwright browser hosts in this repo verify small-file saves and overwrites, concurrent tabs, VFS flows, and `1 GiB` round-trips in both Blazor WebAssembly and Interactive Server. The large-file flows emit progress logs every `100 MiB`, and both the small-file and large-file paths assert that payload storage resolves to OPFS.
+> The real Playwright browser hosts in this repo verify small-file saves and overwrites, concurrent tabs, VFS flows, a default `128 MiB` large-file path, and a separate `256 MiB` browser stress lane in both Blazor WebAssembly and Interactive Server. The large-file flows emit progress logs every `100 MiB`, and both the small-file and large-file paths assert that payload storage resolves to OPFS.
 
 </details>
 

Storages/ManagedCode.Storage.Browser/wwwroot/browserStorage.js

@@ -3,6 +3,7 @@ import {
   appendPayloadChunksInternal,
   beginPayloadWriteInternal,
   completePayloadWriteInternal,
+  getPayloadDigestInternal,
   opfsFileExistsInternal,
   readPayloadRangeInternal,
   tryDeletePayloadFileInternal
@@ -209,6 +210,20 @@ export async function getPayloadStoreByFullName(databaseName, fullName) {
   return null;
 }
 
+export async function getPayloadDigestByFullName(databaseName, fullName) {
+  const blob = (await getAllBlobs(databaseName)).find((item) => item.fullName === fullName);
+  if (!blob) {
+    return null;
+  }
+
+  const payloadKey = resolvePayloadKey(blob);
+  if (!payloadKey) {
+    return null;
+  }
+
+  return await getPayloadDigestInternal(databaseName, payloadKey);
+}
+
 const browserStorageApi = {
   containerExists,
   createContainer,
@@ -224,7 +239,8 @@ const browserStorageApi = {
   completePayloadWrite,
   abortPayloadWrite,
   readPayloadRange,
-  getPayloadStoreByFullName
+  getPayloadStoreByFullName,
+  getPayloadDigestByFullName
 };
 
 if (typeof window !== "undefined") {

Storages/ManagedCode.Storage.Browser/wwwroot/browserStorage.opfs.js

@@ -100,6 +100,14 @@ export async function readPayloadRangeInternal(databaseName, blobKey, offset, co
   return result ? normalizeBytes(result) : null;
 }
 
+export async function getPayloadDigestInternal(databaseName, blobKey) {
+  if (!supportsOpfs()) {
+    return null;
+  }
+
+  return await postToOpfsWorker("getFileDigest", { databaseName, blobKey });
+}
+
 export async function opfsFileExistsInternal(databaseName, blobKey) {
   if (!supportsOpfs()) {
     return false;

Storages/ManagedCode.Storage.Browser/wwwroot/browserStorage.worker.js

@@ -1,5 +1,7 @@
 const sessions = new Map();
 const maxWriteBlockBytes = 1024 * 1024;
+const maxDigestReadBlockBytes = 4 * 1024 * 1024;
+const crc32Table = buildCrc32Table();
 
 self.onmessage = async (event) => {
   const { id, command, payload } = event.data ?? {};
@@ -31,6 +33,8 @@ async function dispatchAsync(command, payload) {
       return true;
     case "readRange":
       return await readRangeAsync(payload.databaseName, payload.blobKey, payload.offset, payload.count);
+    case "getFileDigest":
+      return await getFileDigestAsync(payload.databaseName, payload.blobKey);
     case "deleteFile":
       return await deleteFileAsync(payload.databaseName, payload.blobKey);
     case "fileExists":
@@ -126,6 +130,41 @@ async function deleteFileAsync(databaseName, blobKey) {
   }
 }
 
+async function getFileDigestAsync(databaseName, blobKey) {
+  const fileHandle = await getBlobFileHandleAsync(databaseName, blobKey, false);
+  const accessHandle = await fileHandle.createSyncAccessHandle();
+
+  try {
+    const size = accessHandle.getSize();
+    if (size <= 0) {
+      return { length: 0, crc: 0 };
+    }
+
+    const buffer = new Uint8Array(Math.min(maxDigestReadBlockBytes, size));
+    let offset = 0;
+    let crc = 0xffffffff;
+
+    while (offset < size) {
+      const bytesToRead = Math.min(buffer.byteLength, size - offset);
+      const bytesRead = normalizeBytesRead(
+        accessHandle.read(buffer.subarray(0, bytesToRead), { at: offset }),
+        bytesToRead,
+        blobKey,
+        offset);
+
+      crc = updateCrc32(crc, buffer, bytesRead);
+      offset += bytesRead;
+    }
+
+    return {
+      length: Number(size),
+      crc: completeCrc32(crc)
+    };
+  } finally {
+    accessHandle.close();
+  }
+}
+
 async function fileExistsAsync(databaseName, blobKey) {
   try {
     await getBlobFileHandleAsync(databaseName, blobKey, false);
@@ -183,6 +222,19 @@ function normalizeBytesWritten(value, expectedBytes, blobKey, position) {
   return written;
 }
 
+function normalizeBytesRead(value, expectedBytes, blobKey, position) {
+  if (!Number.isFinite(value)) {
+    throw new Error(`Invalid OPFS read result for ${blobKey} at ${position}: ${String(value)}.`);
+  }
+
+  const bytesRead = Math.trunc(value);
+  if (bytesRead <= 0 || bytesRead > expectedBytes) {
+    throw new Error(`Invalid OPFS read result for ${blobKey} at ${position}: read ${bytesRead} of ${expectedBytes} bytes.`);
+  }
+
+  return bytesRead;
+}
+
 async function getDatabaseDirectoryAsync(databaseName, create) {
   const root = await navigator.storage.getDirectory();
   return await root.getDirectoryHandle(getDatabaseDirectoryName(databaseName), { create });
@@ -200,3 +252,33 @@ function getDatabaseDirectoryName(databaseName) {
 function getBlobFileName(blobKey) {
   return encodeURIComponent(blobKey);
 }
+
+function buildCrc32Table() {
+  const table = new Uint32Array(256);
+
+  for (let index = 0; index < table.length; index++) {
+    let value = index;
+
+    for (let bit = 0; bit < 8; bit++) {
+      value = (value & 1) === 0 ? value >>> 1 : (value >>> 1) ^ 0xedb88320;
+    }
+
+    table[index] = value >>> 0;
+  }
+
+  return table;
+}
+
+function updateCrc32(crc, buffer, length) {
+  let current = crc >>> 0;
+
+  for (let index = 0; index < length; index++) {
+    current = (current >>> 8) ^ crc32Table[(current ^ buffer[index]) & 0xff];
+  }
+
+  return current >>> 0;
+}
+
+function completeCrc32(crc) {
+  return (crc ^ 0xffffffff) >>> 0;
+}

Tests/ManagedCode.Storage.Tests/AGENTS.md

@@ -25,8 +25,9 @@ Parent: `../../AGENTS.md`
 ## Project Commands
 
 - `build`: `dotnet build ManagedCode.Storage.Tests.csproj`
-- `test`: `dotnet test ManagedCode.Storage.Tests.csproj --configuration Release`
-- `coverage`: `dotnet test ManagedCode.Storage.Tests.csproj --configuration Release /p:CollectCoverage=true /p:CoverletOutput=coverage /p:CoverletOutputFormat=opencover`
+- `test`: `dotnet test ManagedCode.Storage.Tests.csproj --configuration Release --filter "Category!=BrowserStress"`
+- `browser-stress`: `dotnet test ManagedCode.Storage.Tests.csproj --configuration Release --filter "Category=BrowserStress"`
+- `coverage`: `dotnet test ManagedCode.Storage.Tests.csproj --configuration Release --filter "Category!=BrowserStress" /p:CollectCoverage=true /p:CoverletOutput=coverage /p:CoverletOutputFormat=opencover`
 - `format`: `dotnet format ../../ManagedCode.Storage.slnx`
 - Active test framework: `xUnit`
 - Runner model: `VSTest`
@@ -54,3 +55,4 @@ Parent: `../../AGENTS.md`
 - Every new public behavior needs integration coverage that asserts observable outcomes, not only successful method calls.
 - Keep architecture dependency rules in `Architecture/` focused on durable package boundaries so they stay stable as implementation details move.
 - Do not weaken assertions or skip suites to get a green run; fix the real regression or document an explicit exception.
+- Browser stress tests are an explicit lane, not hidden debt: keep them automated via the dedicated `browser-stress` command or workflow instead of folding them into the fast default test path.

Tests/ManagedCode.Storage.Tests/Storages/Browser/BrowserIntegrationCollection.cs

@@ -0,0 +1,9 @@
+using Xunit;
+
+namespace ManagedCode.Storage.Tests.Storages.Browser;
+
+[CollectionDefinition(Name, DisableParallelization = true)]
+public sealed class BrowserIntegrationCollection : ICollectionFixture<BrowserServerHostFixture>, ICollectionFixture<BrowserWasmHostFixture>
+{
+    public const string Name = nameof(BrowserIntegrationCollection);
+}