test(core): add getResponseMeta-paths integration test (non-GC angle) (#3929)

* test(core): replace getResponseMeta-countRef with getResponseMeta-paths

The previous integration test poked GCPolicy['entityCount'] directly to
prove the journey-mutation bug. Replace it with a test that asserts the
public-API consequence the bug creates outside of GC: every subscriber
to the same endpoint must observe the same expiresAt from
Controller.getResponseMeta().

This is the property the bug actually broke for non-GC users: with the
buggy paths.shift(), entityExpiresAt(paths, …) iterates a
progressively-shorter list, dropping the entity with the earliest
expiry first. Subscriber 2 observes a too-late expiresAt; subscriber 3+
observe Infinity and never refetch. Fires under ImmortalGCPolicy too,
since entityExpiresAt is unconditional whenever the endpoint has no
top-level meta.expiresAt — typical for state populated via
controller.set(Entity, …), SSR hydration, or useQuery.

Verified the assertion fails on the buggy paths.shift() (m3.expiresAt
returns FOO_2_EXPIRY instead of FOO_1_EXPIRY) and passes on the fix.

* test(core): keep existing countRef integration test alongside paths test

Restore the GC-side getResponseMeta-countRef.ts integration test that
the prior commit replaced. The two tests cover the journey-mutation
bug from complementary angles:

- getResponseMeta-countRef.ts: GC consumer of paths (entityCount
  under-counting → premature reaping under default GCPolicy).
- getResponseMeta-paths.ts: non-GC consumer of paths
  (entityExpiresAt → suppressed entity-expiry refetch; fires under
  ImmortalGCPolicy too).

Both pass on the fix; both fail on the buggy paths.shift().

Author: ntucker

packages/core/src/controller/__tests__/getResponseMeta-paths.ts

@@ -0,0 +1,88 @@
+import { Endpoint, Entity } from '@data-client/endpoint';
+
+import { initialState } from '../../state/reducer/createReducer';
+import Controller from '../Controller';
+
+/** Integration test: `Controller.getResponseMeta()` is the seam every read
+ * hook (`useSuspense`, `useCache`, `useFetch`, `useDLE`, `useLive`) calls.
+ * Multiple subscribers to the same endpoint + args + entities must observe
+ * the same `expiresAt`, otherwise late subscribers silently skip the
+ * entity-expiry refetch in `useSuspense`'s gate
+ * `if (Date.now() <= expiresAt && !forceFetch) return;`.
+ *
+ * The bug fixed by this PR was a `paths.shift()` mutation on the journey
+ * stored by reference on `WeakDependencyMap.Link.journey`. Each successive
+ * cache hit returned a journey one entry shorter than the last. The first
+ * entity dropped is the one with the *earliest* expiry, so subscriber 2's
+ * `entityExpiresAt(paths, …)` skipped it and computed a too-late
+ * `expiresAt`; subscriber 3 saw an empty array and got `Infinity`.
+ *
+ * The path is GC-independent: it fires under `ImmortalGCPolicy` too, since
+ * `entityExpiresAt` is unconditional whenever the endpoint has no
+ * top-level `meta.expiresAt` (the common case for state populated via
+ * `controller.set(Entity, …)`, SSR hydration, or `useQuery`).
+ */
+describe('Controller.getResponseMeta repeated calls', () => {
+  it('returns identical expiresAt across subscribers (journey is not consumed by reads)', () => {
+    class Foo extends Entity {
+      id = '';
+      pk() {
+        return this.id;
+      }
+    }
+    const ep = new Endpoint(() => Promise.resolve(), {
+      key: () => 'listFoo',
+      schema: [Foo],
+    });
+
+    const controller = new Controller({});
+
+    // Endpoint slot exists (so we hit the `denormalize` path) but the
+    // endpoint itself has no top-level `meta.expiresAt` yet — mirrors
+    // apps that hydrate from SSR or use `controller.set(Entity, …)`
+    // without going through an endpoint fetch. In that shape,
+    // `Controller.getResponseMeta()` falls back to walking per-entity
+    // meta via `entityExpiresAt(paths, …)`. Foo|'1' has the earliest
+    // expiry — the first journey entry the buggy `paths.shift()` would
+    // drop.
+    const FOO_1_EXPIRY = 100;
+    const FOO_2_EXPIRY = 1_000_000;
+    const state = {
+      ...initialState,
+      entities: {
+        Foo: {
+          '1': { id: '1' },
+          '2': { id: '2' },
+        },
+      },
+      entitiesMeta: {
+        Foo: {
+          '1': { date: 0, fetchedAt: 0, expiresAt: FOO_1_EXPIRY },
+          '2': { date: 0, fetchedAt: 0, expiresAt: FOO_2_EXPIRY },
+        },
+      },
+      endpoints: {
+        [ep.key()]: ['1', '2'],
+      },
+    };
+
+    // Three successive calls simulate three React components mounting
+    // with the same endpoint + args. Call 1 is a result-cache miss;
+    // calls 2 and 3 are hits.
+    const m1 = controller.getResponseMeta(ep, state);
+    const m2 = controller.getResponseMeta(ep, state);
+    const m3 = controller.getResponseMeta(ep, state);
+
+    // Subscriber 1 picks the earliest entity expiry. Subscribers 2+ must
+    // pick the same one — pre-fix they observed FOO_2_EXPIRY (m2) and
+    // Infinity (m3), silently suppressing entity-expiry refetch.
+    expect(m1.expiresAt).toBe(FOO_1_EXPIRY);
+    expect(m2.expiresAt).toBe(m1.expiresAt);
+    expect(m3.expiresAt).toBe(m1.expiresAt);
+
+    // Cached data must remain referentially equal across hits — the
+    // memo contract `useSuspense` etc. rely on for skip-rerender.
+    expect(m2.data).toBe(m1.data);
+    expect(m3.data).toBe(m1.data);
+  });
+});