@@ -0,0 +1,15 @@
+---
+'@object-ui/app-shell': patch
+'@object-ui/data-objectstack': patch
+---
+
+Opening a Studio package no longer sends the same read several times at once (objectui#11797).
+
+Several readers mount together on Studio entry and each one used to send its own request for the same answer. A caller that arrives while an identical request is still pending now waits for that request instead of sending another:
+
+- **`@object-ui/app-shell`:** the package list (`GET /api/v1/packages`, read by the Studio package switcher, the read-only gate and the object-name namespace lookup) and the pending-drafts count (`GET /api/v1/meta/_drafts`, read by the Studio top bar and the chat bar).
+- **`@object-ui/data-objectstack`:** `MetadataClient.listTypes`, `list`, `listDrafts`, `get` and `getDraft`. Requests are shared between clients built on the same `fetch`, so the per-component clients the console creates share them too. Each caller, the first one included, still gets an answer object that no other caller holds.
+
+This is not a response cache. Once a request settles, the next call goes to the server again. A failed request is shared only by the callers already waiting, and the next call retries. A write the reader can see drops any read still pending, so a read made after the write never gets the answer of a request sent before it. For the metadata client that is any save, publish or reset through a client on the same `fetch`. For the app-shell reads it is a package duplicate, the `objectui:packages-changed` announcement and the publish refresh pulse.
+
+No exported function, method signature, option or type changes.
@@ -0,0 +1,209 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * objectui#11797 — the pending-drafts ledger is read once per question, not
+ * once per reader.
+ *
+ * Each surface that shows the count mounts `usePendingDrafts` (which reads on
+ * mount) AND calls the hook's `refresh()` from a mount effect of its own: the
+ * Studio topbar from its publish/draft-nonce effect, the chat bar from its
+ * idle-edge effect. `Surface` below is that shape. With two such surfaces
+ * open on one package, every one of those reads sent its own identical
+ * `GET /api/v1/meta/_drafts` request.
+ *
+ * Counted on the wire: the stubbed `fetch` holds every request open until the
+ * test answers it, so "at once" means the first request is genuinely pending
+ * when the next read is asked.
+ *
+ * The rules pinned besides the one-request count:
+ *   - a different scope is a different question;
+ *   - the entry goes when the request settles, so a later refresh asks again
+ *     (no reuse window);
+ *   - a failure reaches every reader that shared it and is not remembered;
+ *   - a publish pulse drops the pending request, so the reads it triggers are
+ *     never answered by a request sent before the publish — and they share
+ *     ONE new request between them.
+ */
+import React from 'react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { fetchPendingDrafts, usePendingDrafts } from './usePendingDrafts.js';
+import { emitMetadataRefresh } from '../assistant/assistantBus.js';
+
+interface HeldRequest {
+  url: string;
+  respond: (status: number, body: unknown) => void;
+}
+
+function heldFetch() {
+  const held: HeldRequest[] = [];
+  vi.stubGlobal(
+    'fetch',
+    vi.fn(
+      (input: RequestInfo | URL) =>
+        new Promise((resolve) => {
+          held.push({
+            url: String(input),
+            respond: (status, body) =>
+              resolve({ ok: status >= 200 && status < 300, status, json: async () => body }),
+          });
+        }),
+    ),
+  );
+  const reads = (url: string) => held.filter((r) => r.url === url);
+  return { held, reads };
+}
+
+const CRM = '/api/v1/meta/_drafts?packageId=app.crm';
+const draft = (name: string) => ({ type: 'object', name, packageId: 'app.crm' });
+
+/**
+ * A surface showing the count: the hook, plus its own mount refresh. The
+ * button is the surface-local trigger (a draft saved, a turn gone idle).
+ */
+function Surface({ id, packageId }: { id: string; packageId: string | null }) {
+  const { count, refresh } = usePendingDrafts({ packageId });
+  React.useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  return (
+    <>
+      <span data-testid={id}>{count === null ? 'unknown' : String(count)}</span>
+      <button type="button" data-testid={`${id}-refresh`} onClick={() => void refresh()} />
+    </>
+  );
+}
+
+async function drain() {
+  for (let i = 0; i < 5; i++) await new Promise((r) => setTimeout(r, 0));
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe('usePendingDrafts — one request per question, not per reader (objectui#11797)', () => {
+  it('two surfaces opening one package put one `_drafts` request on the wire, and both show its count', async () => {
+    const { held, reads } = heldFetch();
+    render(
+      <>
+        <Surface id="topbar" packageId="app.crm" />
+        <Surface id="chatbar" packageId="app.crm" />
+      </>,
+    );
+    await act(drain);
+    expect(reads(CRM)).toHaveLength(1);
+    expect(held).toHaveLength(1);
+
+    await act(async () => reads(CRM)[0].respond(200, { drafts: [draft('crm_account'), draft('crm_contact')] }));
+    await waitFor(() => expect(screen.getByTestId('topbar').textContent).toBe('2'));
+    expect(screen.getByTestId('chatbar').textContent).toBe('2');
+  });
+
+  it('a caller editing its entries in its own continuation leaves another caller untouched', async () => {
+    // Every caller maps the shared payload itself into new entries that hold
+    // only primitives, so no caller is handed anything that points into the
+    // payload or into another caller's list.
+    const { reads } = heldFetch();
+    const first = fetchPendingDrafts('app.crm').then((mine) => {
+      mine[0].name = 'edited-by-first';
+      mine.push({ type: 'view', name: 'extra', packageId: null });
+      return mine;
+    });
+    const second = fetchPendingDrafts('app.crm');
+    await drain();
+    expect(reads(CRM)).toHaveLength(1);
+    reads(CRM)[0].respond(200, { drafts: [draft('crm_account')] });
+
+    expect((await first).map((d) => d.name)).toEqual(['edited-by-first', 'extra']);
+    expect(await second).toEqual([{ type: 'object', name: 'crm_account', packageId: 'app.crm' }]);
+  });
+
+  it('keeps different scopes apart', async () => {
+    const { held, reads } = heldFetch();
+    render(
+      <>
+        <Surface id="pkg" packageId="app.crm" />
+        <Surface id="org" packageId={null} />
+      </>,
+    );
+    await act(drain);
+    expect(reads(CRM)).toHaveLength(1);
+    expect(reads('/api/v1/meta/_drafts')).toHaveLength(1);
+    expect(held).toHaveLength(2);
+  });
+
+  it('is not a response cache: a refresh after the answer asks the server again', async () => {
+    const { reads } = heldFetch();
+    render(<Surface id="topbar" packageId="app.crm" />);
+    await act(drain);
+    await act(async () => reads(CRM)[0].respond(200, [draft('crm_account')]));
+    await waitFor(() => expect(screen.getByTestId('topbar').textContent).toBe('1'));
+
+    await act(async () => {
+      fireEvent.click(screen.getByTestId('topbar-refresh'));
+      await drain();
+    });
+    expect(reads(CRM)).toHaveLength(2);
+    await act(async () => reads(CRM)[1].respond(200, []));
+    await waitFor(() => expect(screen.getByTestId('topbar').textContent).toBe('0'));
+  });
+
+  it('a failed request leaves every reader that shared it at "unknown", and is not remembered', async () => {
+    const { reads } = heldFetch();
+    render(
+      <>
+        <Surface id="topbar" packageId="app.crm" />
+        <Surface id="chatbar" packageId="app.crm" />
+      </>,
+    );
+    await act(drain);
+    expect(reads(CRM)).toHaveLength(1);
+    await act(async () => reads(CRM)[0].respond(503, { success: false }));
+    await act(drain);
+    expect(screen.getByTestId('topbar').textContent).toBe('unknown');
+    expect(screen.getByTestId('chatbar').textContent).toBe('unknown');
+
+    await act(async () => {
+      fireEvent.click(screen.getByTestId('topbar-refresh'));
+      fireEvent.click(screen.getByTestId('chatbar-refresh'));
+      await drain();
+    });
+    expect(reads(CRM)).toHaveLength(2);
+    await act(async () => reads(CRM)[1].respond(200, [draft('crm_account')]));
+    await waitFor(() => expect(screen.getByTestId('topbar').textContent).toBe('1'));
+    expect(screen.getByTestId('chatbar').textContent).toBe('1');
+  });
+
+  it('a publish pulse while a read is pending sends ONE new request, and its answer wins', async () => {
+    const { reads } = heldFetch();
+    render(
+      <>
+        <Surface id="topbar" packageId="app.crm" />
+        <Surface id="chatbar" packageId="app.crm" />
+      </>,
+    );
+    await act(drain);
+    expect(reads(CRM)).toHaveLength(1);
+
+    // Published while the mount read is still on the wire: the reads the pulse
+    // triggers must not join it, and must not each send their own either.
+    await act(async () => {
+      emitMetadataRefresh();
+      await drain();
+    });
+    expect(reads(CRM)).toHaveLength(2);
+
+    await act(async () => {
+      reads(CRM)[0].respond(200, [draft('crm_account'), draft('crm_contact')]);
+      reads(CRM)[1].respond(200, []);
+      await drain();
+    });
+    await waitFor(() => expect(screen.getByTestId('topbar').textContent).toBe('0'));
+    expect(screen.getByTestId('chatbar').textContent).toBe('0');
+  });
+});
@@ -41,17 +41,74 @@ export interface PendingDraftEntry {
   packageId: string | null;
 }
 
+/**
+ * The `_drafts` requests currently on the wire, per `fetch` and URL
+ * (objectui#11797).
+ *
+ * Opening a package asked the same ledger several times at once: this hook
+ * reads on mount, and the surfaces that mount it (the Studio topbar, the chat
+ * bar) also call `refresh()` from a mount effect of their own. A caller that
+ * arrives while a request for the same URL is pending now waits for that
+ * request instead of sending another.
+ *
+ * ⛔ Not a response cache, deliberately:
+ *  - the entry goes the moment the request settles, so a call made after an
+ *    answer always reaches the network. There is no reuse window because the
+ *    ledger changes on writes this module never sees (a draft save, an
+ *    agent's server-side staging), and a window would answer the read after
+ *    such a write with the count from before it;
+ *  - a failure reaches the callers already waiting and is then forgotten;
+ *  - the publish pulse (`emitMetadataRefresh`, the contract every publish path
+ *    keeps — see the module doc) drops the pending requests before the hooks
+ *    it wakes read again, so their read is never answered by a request sent
+ *    before the publish.
+ *
+ * Keyed by the `fetch` the request went through: a request only answers
+ * callers of the same transport. Each caller parses the shared payload itself,
+ * so every caller still gets its own entry list.
+ */
+const pendingDraftReads = new WeakMap<typeof fetch, Map<string, Promise<unknown>>>();
+let publishPulseObserved = false;
+
+function readDraftsPayload(url: string): Promise<unknown> {
+  // Registered on first use rather than at import, and so before the hook's
+  // own pulse subscription (the hook reads first, then subscribes): the drop
+  // runs before the refresh that pulse triggers.
+  if (!publishPulseObserved) {
+    publishPulseObserved = true;
+    subscribeMetadataRefresh(() => pendingDraftReads.get(globalThis.fetch)?.clear());
+  }
+  const transport = globalThis.fetch;
+  let reads = pendingDraftReads.get(transport);
+  if (!reads) {
+    reads = new Map();
+    pendingDraftReads.set(transport, reads);
+  }
+  const pending = reads.get(url);
+  if (pending) return pending;
+  const read = (async () => {
+    const res = await fetch(url, {
+      credentials: 'include',
+      headers: { Accept: 'application/json' },
+      cache: 'no-store',
+    });
+    if (!res.ok) throw new Error(`_drafts HTTP ${res.status}`);
+    return res.json() as Promise<unknown>;
+  })();
+  reads.set(url, read);
+  const owner = reads;
+  const settle = () => {
+    if (owner.get(url) === read) owner.delete(url);
+  };
+  read.then(settle, settle);
+  return read;
+}
+
 export async function fetchPendingDrafts(
   packageId?: string | null,
 ): Promise<PendingDraftEntry[]> {
   const qs = packageId ? `?packageId=${encodeURIComponent(packageId)}` : '';
-  const res = await fetch(`/api/v1/meta/_drafts${qs}`, {
-    credentials: 'include',
-    headers: { Accept: 'application/json' },
-    cache: 'no-store',
-  });
-  if (!res.ok) throw new Error(`_drafts HTTP ${res.status}`);
-  const data = (await res.json()) as
+  const data = (await readDraftsPayload(`/api/v1/meta/_drafts${qs}`)) as
     | Array<Record<string, unknown>>
     | { drafts?: Array<Record<string, unknown>>; data?: { drafts?: Array<Record<string, unknown>> } };
   const list = Array.isArray(data) ? data : (data?.drafts ?? data?.data?.drafts ?? []);