perf: parallelize resource ACL and fallback ACL fetching

Fetch resource ACL and fallback ACL concurrently using Promise.all
instead of sequentially. This reduces latency when combined with
HTTP/2 multiplexing, as the speculative fallback fetch overlaps
with the resource ACL fetch at minimal cost.

- internal_fetchAcl now issues both fetches in parallel
- Fallback wrapped in .catch(() => null) to prevent regression
  when speculative fetch fails
- Updated tests for parallel fetch behavior

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: maxleonard

src/acl/acl.internal.ts

@@ -61,6 +61,11 @@ import { isAcr } from "../acp/acp.internal";
  * This (currently internal) function fetches the ACL indicated in the [[WithServerResourceInfo]]
  * attached to a resource.
  *
+ * The resource ACL and the fallback ACL are fetched **in parallel** to reduce
+ * latency, especially when HTTP/2 multiplexing is in use. If the resource has
+ * its own ACL, the fallback result is discarded. Errors from the speculative
+ * fallback fetch are silently caught so they do not affect the happy path.
+ *
  * @internal
  * @param resourceInfo The Resource info with the ACL URL
  * @param options Optional parameter `options.fetch`: An alternative `fetch` function to make the HTTP request, compatible with the browser-native [fetch API](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters).
@@ -76,15 +81,21 @@ export async function internal_fetchAcl(
     };
   }
   try {
-    const resourceAcl = await internal_fetchResourceAcl(resourceInfo, options);
+    // Fetch resource ACL and fallback ACL in parallel. If the resource has its
+    // own ACL the fallback result is discarded. This trades a potentially
+    // unnecessary fallback fetch for eliminating a serial round-trip, which is
+    // especially beneficial with HTTP/2 multiplexing.
+    // The fallback is wrapped in a catch so that a failing speculative fetch
+    // does not break the happy path when the resource ACL exists.
+    const [resourceAcl, fallbackAcl] = await Promise.all([
+      internal_fetchResourceAcl(resourceInfo, options),
+      internal_fetchFallbackAcl(resourceInfo, options).catch(() => null),
+    ]);
 
     const acl =
-      resourceAcl === null
-        ? {
-            resourceAcl: null,
-            fallbackAcl: await internal_fetchFallbackAcl(resourceInfo, options),
-          }
-        : { resourceAcl, fallbackAcl: null };
+      resourceAcl !== null
+        ? { resourceAcl, fallbackAcl: null }
+        : { resourceAcl: null, fallbackAcl };
 
     return acl;
   } catch (e: unknown) {

src/acl/acl.test.ts

@@ -712,9 +712,12 @@ describe("getSolidDatasetWithAcl", () => {
         .sourceIri,
     ).toBe("https://some.pod/resource.acl");
     expect(fetchedSolidDataset.internal_acl?.fallbackAcl).toBeNull();
-    expect(mockFetch.mock.calls).toHaveLength(2);
-    expect(mockFetch.mock.calls[0][0]).toBe("https://some.pod/resource");
-    expect(mockFetch.mock.calls[1][0]).toBe("https://some.pod/resource.acl");
+    // The resource ACL and fallback ACL are fetched in parallel, so more than
+    // 2 calls may be made, but the resource and its ACL are always fetched.
+    expect(mockFetch.mock.calls.length).toBeGreaterThanOrEqual(2);
+    const calledUrls = mockFetch.mock.calls.map((c) => c[0]);
+    expect(calledUrls).toContain("https://some.pod/resource");
+    expect(calledUrls).toContain("https://some.pod/resource.acl");
   });
 
   it("returns the Resource's Container's ACL if its own ACL is not available", async () => {
@@ -929,9 +932,12 @@ describe("getFileWithAcl", () => {
         .sourceIri,
     ).toBe("https://some.pod/resource.acl");
     expect(fetchedSolidDataset.internal_acl?.fallbackAcl).toBeNull();
-    expect(mockFetch.mock.calls).toHaveLength(2);
-    expect(mockFetch.mock.calls[0][0]).toBe("https://some.pod/resource");
-    expect(mockFetch.mock.calls[1][0]).toBe("https://some.pod/resource.acl");
+    // The resource ACL and fallback ACL are fetched in parallel, so more than
+    // 2 calls may be made, but the resource and its ACL are always fetched.
+    expect(mockFetch.mock.calls.length).toBeGreaterThanOrEqual(2);
+    const calledUrls = mockFetch.mock.calls.map((c) => c[0]);
+    expect(calledUrls).toContain("https://some.pod/resource");
+    expect(calledUrls).toContain("https://some.pod/resource.acl");
   });
 
   it("returns the Resource's Container's ACL if its own ACL is not available", async () => {
@@ -1113,9 +1119,12 @@ describe("getResourceInfoWithAcl", () => {
         .sourceIri,
     ).toBe("https://some.pod/resource.acl");
     expect(fetchedSolidDataset.internal_acl?.fallbackAcl).toBeNull();
-    expect(mockFetch.mock.calls).toHaveLength(2);
-    expect(mockFetch.mock.calls[0][0]).toBe("https://some.pod/resource");
-    expect(mockFetch.mock.calls[1][0]).toBe("https://some.pod/resource.acl");
+    // The resource ACL and fallback ACL are fetched in parallel, so more than
+    // 2 calls may be made, but the resource and its ACL are always fetched.
+    expect(mockFetch.mock.calls.length).toBeGreaterThanOrEqual(2);
+    const calledUrls = mockFetch.mock.calls.map((c) => c[0]);
+    expect(calledUrls).toContain("https://some.pod/resource");
+    expect(calledUrls).toContain("https://some.pod/resource.acl");
   });
 
   it("returns the Resource's Container's ACL if its own ACL is not available", async () => {