@sanity-labs/client-fake-for-test 0.7.1 → 0.9.0

package/README.md

@@ -77,10 +77,10 @@ More patterns — passing the fake to code typed against `SanityClient`, asserti
 | Transaction | `transaction()` chain → `.commit()` | Mutations: `.create`, `.createOrReplace`, `.createIfNotExists`, `.delete`, `.patch(id, recipe)`. Atomic — any throw rolls back the whole batch. Default result is a `MultipleMutationResult` (`{ transactionId, documentIds, results }`) |
 | Actions | `action(action \| action[])` | Content Lake release / version actions, applied atomically |
 | Releases | `releases.*`, `createVersion`, `unpublishVersion` | Content Releases lifecycle — create / edit / schedule / publish / archive / delete, plus version create / replace / discard / unpublish |
-| Config | `config()` | Returns `{ projectId, dataset, perspective, token? }` |
-| Config | `withConfig({ projectId?, dataset?, perspective?, accessControl?, token? })` | Sibling handle into the same multi-dataset registry; `token` binds a registered identity (see the token→identity registry below), `accessControl` rebinds it inline — the two are mutually exclusive |
+| Config | `config()` | Returns `{ projectId, dataset, perspective, token?, useProjectHostname }` |
+| Config | `withConfig({ projectId?, dataset?, perspective?, accessControl?, token?, useProjectHostname? })` | Sibling handle into the same multi-dataset registry; `token` binds a registered identity (see the token→identity registry below), `accessControl` rebinds it inline — the two are mutually exclusive; `useProjectHostname: false` mints a global-hosted sibling |
 | Perspectives | `raw` / `published` / `drafts` / release stacks | Per-client default or per-`fetch` override; draft/version layering with `_originalId` projection |
-| HTTP | `request({ url? \| uri? })` | Present **only** when the handle has an acting identity (`accessControl`, or a bound `token`). Serves `/users/me` + the configured ACL path. Calling it without one throws a guidance error. |
+| HTTP | `request({ url? \| uri? })` | Present **only** when the handle has an acting identity (`accessControl`, or a bound `token`). Serves `/users/me` (host-aware: project-scoped record on the project host, `globalUser` on a global-hosted handle), the configured ACL path, and `/projects/<projectId>/users/<ids>` (project-user records with `id` + `sanityUserId`). Calling it without one throws a guidance error. |
 
 #### Mutation return shapes
 
@@ -117,6 +117,9 @@ await client.patch("article-1").set({ title: "ok" }).commit(); // allowed
 await expect(client.patch("article-1").set({ body: "no" }).commit()).rejects.toThrow();
 ```
 
+> [!NOTE]
+> Treat `before` / `after` as read-only — they are the live store images, not copies; mutating them corrupts the store.
+
 #### Identity is the token
 
 `identity` is the id of the handle's acting identity. To act as different users against the **same** store (e.g. to exercise `identity()`-based guards), register a token→identity registry and mint token-scoped siblings — the token determines identity, exactly like production:
@@ -137,8 +140,29 @@ const bob = alice.withConfig({ token: "t-bob" });
 
 Register more identities after creation with `client.addIdentity(token, { user, grants })` — an upsert into the family-shared registry; already-bound siblings resolve lazily and pick the change up immediately. For a one-off identity without a registry, `withConfig({ accessControl })` still works (mutually exclusive with `token` in the same call).
 
-> [!NOTE]
-> Treat `before` / `after` as read-only — they are the live store images, not copies; mutating them corrupts the store.
+#### Dual-namespace identities: global vs project user ids
+
+In production the same token resolves to a **different project-scoped user id in every project** (what lake `identity()` returns) and **one account-global id** (what the global API host's `/users/me` returns); robot tokens carry a single id on every host. An identity can model that split with `globalUser` (served by `/users/me` on a `useProjectHostname: false` handle) and `usersByProject` (per-project records; the handle's project falls back to `user`):
+
+```ts
+const client = createTestClient({
+  projectId: "alpha",
+  token: "t-snorre",
+  identities: {
+    "t-snorre": {
+      user: { id: "pDefault" },
+      globalUser: { id: "gSnorre" },
+      usersByProject: { alpha: { id: "pAlpha" }, beta: { id: "pBeta" } },
+      grants,
+    },
+  },
+});
+await client.request({ uri: "/users/me" }); // { id: "pAlpha", ... }
+await client.withConfig({ useProjectHostname: false }).request({ uri: "/users/me" }); // { id: "gSnorre", ... }
+await client.request({ uri: "/projects/alpha/users/pAlpha" }); // { id: "pAlpha", sanityUserId: "gSnorre", ... } (ProjectUserRecord)
+```
+
+Grant-filter and mutation-guard `identity()` stay bound to the **project-scoped** record, matching the lake. Identities without `globalUser` serve one record everywhere — the production robot-token shape.
 
 ### Test-only helpers (not on real `SanityClient`)
 

package/dist/index.cjs

@@ -61,69 +61,65 @@ async function enforceWriteAccess(args) {
 function defaultAclPath(projectId, dataset) {
   return `/projects/${projectId}/datasets/${dataset}/acl`;
 }
-function makeRequestImpl(getAccess, projectId, dataset) {
+function projectUserOf(identity, projectId) {
+  return identity.usersByProject?.[projectId] ?? identity.user;
+}
+function serveProjectUsers(args) {
+  const { requestedIds, pathProjectId, identities } = args, toRecord = (identity) => {
+    const projectUser = projectUserOf(identity, pathProjectId);
+    return {
+      id: projectUser.id,
+      sanityUserId: identity.globalUser?.id ?? projectUser.id,
+      displayName: projectUser.name ?? projectUser.id,
+      ...projectUser.email !== void 0 ? { email: projectUser.email } : {}
+    };
+  }, byId = /* @__PURE__ */ new Map();
+  for (const identity of identities) {
+    const resolvedId = projectUserOf(identity, pathProjectId).id, existing = byId.get(resolvedId);
+    if (existing !== void 0 && JSON.stringify(toRecord(existing)) !== JSON.stringify(toRecord(identity)))
+      throw fakeError(
+        `request(): two registered identities resolve to project user "${resolvedId}" in project "${pathProjectId}" with different records. The directory cannot answer unambiguously \u2014 fix the identity registrations so duplicate ids carry identical records.`
+      );
+    byId.set(resolvedId, identity);
+  }
+  const ids = requestedIds.split(","), [firstId] = ids;
+  if (ids.length === 1 && firstId !== void 0) {
+    const identity = byId.get(firstId);
+    if (identity === void 0)
+      throw Object.assign(
+        fakeError(
+          `request(): no registered identity resolves to project user "${firstId}" in project "${pathProjectId}". Register it via createTestClient({ identities }) or addIdentity().`
+        ),
+        { statusCode: 404 }
+      );
+    return toRecord(identity);
+  }
+  return ids.flatMap((id) => {
+    const identity = byId.get(id);
+    return identity === void 0 ? [] : [toRecord(identity)];
+  });
+}
+const PROJECT_USERS_PATH = /^\/projects\/([^/]+)\/users\/([^/]+)$/;
+function makeRequestImpl(ctx) {
+  const { getAccess, projectId, dataset, useProjectHostname, listIdentities } = ctx;
   return async (opts) => {
     const accessControl = getAccess(), aclPath = accessControl.aclPath ?? defaultAclPath(projectId, dataset), path = opts.uri ?? opts.url;
     if (path === "/users/me")
-      return accessControl.currentUser;
+      return useProjectHostname ? accessControl.currentUser : accessControl.globalUser ?? accessControl.currentUser;
     if (path === aclPath)
       return accessControl.grants;
+    const projectUsers = path?.match(PROJECT_USERS_PATH), [, pathProjectId, requestedIds] = projectUsers ?? [];
+    if (pathProjectId !== void 0 && requestedIds !== void 0)
+      return serveProjectUsers({
+        requestedIds,
+        pathProjectId,
+        identities: listIdentities()
+      });
     throw fakeError(
-      `request(): no handler for path "${path}". With access control configured, the fake only serves "/users/me" and "${aclPath}". For any other endpoint, register a stub (client.stub("request", fn)) or intercept the HTTP call with a tool like MSW.`
+      `request(): no handler for path "${path}". With access control configured, the fake serves "/users/me", "${aclPath}", and "/projects/<projectId>/users/<ids>". For any other endpoint, register a stub (client.stub("request", fn)) or intercept the HTTP call with a tool like MSW.`
     );
   };
 }
-function createTestStore(initial) {
-  const docs = /* @__PURE__ */ new Map(), promote2 = (doc) => {
-    if (typeof doc._id != "string" || doc._id.length === 0)
-      throw fakeError(
-        `Cannot seed/store a document without a non-empty string \`_id\` (got ${JSON.stringify(doc._id)}). This fake never auto-generates ids \u2014 give every document an explicit _id. Document: ${JSON.stringify(doc)}`
-      );
-    if (typeof doc._type != "string" || doc._type.length === 0)
-      throw fakeError(
-        `Document "${doc._id}" is missing a non-empty string \`_type\` (got ${JSON.stringify(doc._type)}). Every Sanity document needs a _type.`
-      );
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    return {
-      ...doc,
-      _id: doc._id,
-      _type: doc._type,
-      _rev: doc._rev ?? cryptoRandomKey(),
-      _createdAt: doc._createdAt ?? now,
-      _updatedAt: doc._updatedAt ?? now
-    };
-  }, seed = (documents) => {
-    docs.clear();
-    for (const d of documents) {
-      const promoted = promote2(d);
-      docs.set(promoted._id, promoted);
-    }
-  };
-  return initial && seed(initial), {
-    seed,
-    add: (documents) => {
-      for (const d of documents) {
-        const promoted = promote2(d);
-        docs.set(promoted._id, promoted);
-      }
-    },
-    reset: () => docs.clear(),
-    all: () => [...docs.values()],
-    get: (id) => docs.get(id),
-    put: (doc) => {
-      docs.set(doc._id, doc);
-    },
-    remove: (id) => {
-      const doc = docs.get(id);
-      return doc && docs.delete(id), doc;
-    },
-    snapshot: () => [...docs.values()]
-  };
-}
-function cryptoRandomKey(length = 12) {
-  const bytes = new Uint8Array(length);
-  return globalThis.crypto.getRandomValues(bytes), [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("").slice(0, length);
-}
 function describeType(value) {
   return value === null ? "null" : Array.isArray(value) ? "an array" : `a ${typeof value}`;
 }
@@ -326,13 +322,140 @@ function insertIntoArray(doc, position, anchor, items) {
   const idx = resolveSelector(arr, last.selector);
   position === "replace" ? arr.splice(idx, 1, ...items) : position === "before" ? arr.splice(idx, 0, ...items) : arr.splice(idx + 1, 0, ...items);
 }
-const RELEASE_DOC_PREFIX$1 = "_.releases.", VERSIONS_PREFIX$1 = "versions.", releaseDocId = (releaseId) => `${RELEASE_DOC_PREFIX$1}${releaseId}`, versionDocId = (releaseId, publishedId) => `${VERSIONS_PREFIX$1}${releaseId}.${publishedId}`;
+const DRAFTS_PREFIX = "drafts.", VERSIONS_PREFIX$1 = "versions.", RELEASE_DOC_PREFIX$1 = "_.releases.";
+function publishedIdOf(id) {
+  if (id.startsWith(DRAFTS_PREFIX)) return id.slice(DRAFTS_PREFIX.length);
+  if (id.startsWith(VERSIONS_PREFIX$1)) {
+    const rest = id.slice(VERSIONS_PREFIX$1.length), dot = rest.indexOf(".");
+    return dot === -1 ? rest : rest.slice(dot + 1);
+  }
+  return id;
+}
+function releaseNameOf(id) {
+  if (!id.startsWith(VERSIONS_PREFIX$1)) return;
+  const rest = id.slice(VERSIONS_PREFIX$1.length), dot = rest.indexOf(".");
+  if (dot !== -1)
+    return rest.slice(0, dot);
+}
+const isDraftId = (id) => id.startsWith(DRAFTS_PREFIX), isVersionId = (id) => id.startsWith(VERSIONS_PREFIX$1), isSystemId = (id) => id.startsWith("_."), isReleaseDocId = (id) => id.startsWith(RELEASE_DOC_PREFIX$1);
+function applyPerspective(docs, perspective) {
+  if (perspective === "raw") return [...docs];
+  if (perspective === "published")
+    return docs.filter((d) => !isDraftId(d._id) && !isVersionId(d._id) && !isSystemId(d._id));
+  if (perspective === "drafts")
+    return mergeStack(docs, [], { includeDrafts: !0, includeReleaseDocs: !1 });
+  const stack = [];
+  let includeDrafts = !1;
+  for (const entry of perspective)
+    entry === "drafts" ? includeDrafts = !0 : stack.push(entry);
+  return mergeStack(docs, stack, { includeDrafts, includeReleaseDocs: !0 });
+}
+function mergeStack(docs, releaseStack, options) {
+  const groups = /* @__PURE__ */ new Map(), systemReleases = [];
+  for (const doc of docs) {
+    if (isReleaseDocId(doc._id)) {
+      options.includeReleaseDocs && systemReleases.push(doc);
+      continue;
+    }
+    if (isSystemId(doc._id)) continue;
+    const pubId = publishedIdOf(doc._id);
+    let group = groups.get(pubId);
+    if (group === void 0 && (group = { versions: /* @__PURE__ */ new Map() }, groups.set(pubId, group)), isDraftId(doc._id))
+      group.draft = doc;
+    else if (isVersionId(doc._id)) {
+      const releaseName = releaseNameOf(doc._id);
+      releaseName !== void 0 && group.versions.set(releaseName, doc);
+    } else
+      group.published = doc;
+  }
+  const out = [];
+  for (const [pubId, group] of groups) {
+    let chosen;
+    for (const releaseName of releaseStack) {
+      const v = group.versions.get(releaseName);
+      if (v !== void 0) {
+        if (isUnpublishStub(v)) {
+          chosen = void 0;
+          break;
+        }
+        chosen = v;
+        break;
+      }
+    }
+    chosen === void 0 && options.includeDrafts && group.draft !== void 0 && (chosen = group.draft), chosen === void 0 && group.published !== void 0 && (releaseStack.some((name) => {
+      const v = group.versions.get(name);
+      return v !== void 0 && isUnpublishStub(v);
+    }) || (chosen = group.published)), chosen !== void 0 && out.push(projectToPublishedId(chosen, pubId));
+  }
+  return [...out, ...systemReleases];
+}
+function isUnpublishStub(doc) {
+  return doc._system?.delete === !0;
+}
+function projectToPublishedId(doc, pubId) {
+  return doc._id === pubId ? doc : { ...doc, _id: pubId, _originalId: doc._id };
+}
+function resolveDocument(docs, id, perspective) {
+  return perspective === "raw" ? docs.find((d) => d._id === id) : applyPerspective(docs, perspective).find((d) => d._id === id);
+}
+function createTestStore(initial) {
+  const docs = /* @__PURE__ */ new Map(), promote2 = (doc) => {
+    if (typeof doc._id != "string" || doc._id.length === 0)
+      throw fakeError(
+        `Cannot seed/store a document without a non-empty string \`_id\` (got ${JSON.stringify(doc._id)}). This fake never auto-generates ids \u2014 give every document an explicit _id. Document: ${JSON.stringify(doc)}`
+      );
+    if (typeof doc._type != "string" || doc._type.length === 0)
+      throw fakeError(
+        `Document "${doc._id}" is missing a non-empty string \`_type\` (got ${JSON.stringify(doc._type)}). Every Sanity document needs a _type.`
+      );
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      ...doc,
+      _id: doc._id,
+      _type: doc._type,
+      _rev: doc._rev ?? cryptoRandomKey(),
+      _createdAt: doc._createdAt ?? now,
+      _updatedAt: doc._updatedAt ?? now
+    };
+  }, seed = (documents) => {
+    docs.clear();
+    for (const d of documents) {
+      const promoted = promote2(d);
+      docs.set(promoted._id, promoted);
+    }
+  };
+  return initial && seed(initial), {
+    seed,
+    add: (documents) => {
+      for (const d of documents) {
+        const promoted = promote2(d);
+        docs.set(promoted._id, promoted);
+      }
+    },
+    reset: () => docs.clear(),
+    all: () => [...docs.values()],
+    get: (id) => docs.get(id),
+    put: (doc) => {
+      docs.set(doc._id, doc);
+    },
+    remove: (id) => {
+      const doc = docs.get(id);
+      return doc && docs.delete(id), doc;
+    },
+    snapshot: () => [...docs.values()]
+  };
+}
+function cryptoRandomKey(length = 12) {
+  const bytes = new Uint8Array(length);
+  return globalThis.crypto.getRandomValues(bytes), [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("").slice(0, length);
+}
+const RELEASE_DOC_PREFIX = "_.releases.", VERSIONS_PREFIX = "versions.", releaseDocId = (releaseId) => `${RELEASE_DOC_PREFIX}${releaseId}`, versionDocId = (releaseId, publishedId) => `${VERSIONS_PREFIX}${releaseId}.${publishedId}`;
 function parseVersionId(versionId) {
-  if (!versionId.startsWith(VERSIONS_PREFIX$1))
+  if (!versionId.startsWith(VERSIONS_PREFIX))
     throw fakeError(
       `"${versionId}" is not a version document id. Version ids look like "versions.<releaseId>.<publishedId>" (e.g. "versions.summer-drop.product-1").`
     );
-  const rest = versionId.slice(VERSIONS_PREFIX$1.length), dot = rest.indexOf(".");
+  const rest = versionId.slice(VERSIONS_PREFIX.length), dot = rest.indexOf(".");
   if (dot === -1)
     throw fakeError(
       `"${versionId}" is not a version document id. Version ids look like "versions.<releaseId>.<publishedId>" (e.g. "versions.summer-drop.product-1").`
@@ -378,7 +501,7 @@ function requireActive(release) {
       `Release "${release.name}" is "${release.state}", but only "active" releases accept version writes (create / replace / discard / unpublish). Unschedule or unarchive it back to "active" first, or target a different release.`
     );
 }
-function applyAction(store, action) {
+async function applyAction(store, action, hooks) {
   switch (action.actionType) {
     case "sanity.action.release.create": {
       if (maybeRelease(store, action.releaseId) !== void 0)
@@ -436,7 +559,7 @@ function applyAction(store, action) {
         throw fakeError(
           `Cannot publish release "${action.releaseId}": it is "${release.state}", and only "active" or "scheduled" releases can be published.`
         );
-      const prefix = `${VERSIONS_PREFIX$1}${action.releaseId}.`, sources = store.all().filter((d) => d._id.startsWith(prefix));
+      const prefix = `${VERSIONS_PREFIX}${action.releaseId}.`, sources = store.all().filter((d) => d._id.startsWith(prefix));
       for (const v of sources) {
         const pubId = v._id.slice(prefix.length);
         if (v._system?.delete === !0)
@@ -476,7 +599,7 @@ function applyAction(store, action) {
         throw fakeError(
           `Cannot delete release "${action.releaseId}": it is "${release.state}", and only "archived" or "published" releases can be deleted. Archive it first (sanity.action.release.archive) or publish it.`
         );
-      const prefix = `${VERSIONS_PREFIX$1}${action.releaseId}.`;
+      const prefix = `${VERSIONS_PREFIX}${action.releaseId}.`;
       for (const v of store.all())
         v._id.startsWith(prefix) && store.remove(v._id);
       return store.remove(release._id), { transactionId: cryptoRandomKey() };
@@ -520,9 +643,46 @@ function applyAction(store, action) {
       };
       return store.put(promote(doc)), { transactionId: cryptoRandomKey() };
     }
+    case "sanity.action.document.publish": {
+      requireDraftOf(action);
+      const draft = store.get(action.draftId);
+      if (draft === void 0)
+        throw fakeError(
+          `Cannot publish "${action.publishedId}": draft "${action.draftId}" not found. document.publish promotes an existing draft onto the published id \u2014 create the draft first (e.g. client.createOrReplace({ _id: "${action.draftId}", ... })).`
+        );
+      const published = store.get(action.publishedId);
+      requireRevisionMatch(action.draftId, draft._rev, action.ifDraftRevisionId), requireRevisionMatch(action.publishedId, published?._rev, action.ifPublishedRevisionId);
+      const promoted = promote({ ...draft, _id: action.publishedId });
+      return published !== void 0 && (promoted._createdAt = published._createdAt), await hooks?.gate?.(promoted, published === void 0 ? "create" : "update"), await hooks?.guard?.("publish", published ?? null, promoted), store.put(promoted), store.remove(action.draftId), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.document.unpublish": {
+      requireDraftOf(action);
+      const published = store.get(action.publishedId);
+      if (published === void 0)
+        throw fakeError(
+          `Cannot unpublish "${action.publishedId}": no published document with that _id exists. document.unpublish retracts a live published document into "${action.draftId}".`
+        );
+      if (await hooks?.gate?.(published, "update"), await hooks?.guard?.("unpublish", published, null), store.get(action.draftId) === void 0) {
+        const draft = promote({ ...published, _id: action.draftId });
+        draft._createdAt = published._createdAt, store.put(draft);
+      }
+      return store.remove(action.publishedId), { transactionId: cryptoRandomKey() };
+    }
   }
 }
-function applyActions(store, actions) {
+function requireDraftOf(action) {
+  if (!(publishedIdOf(action.draftId) === action.publishedId && action.draftId !== action.publishedId))
+    throw fakeError(
+      `${action.actionType}: draftId "${action.draftId}" is not the draft of publishedId "${action.publishedId}" \u2014 expected draftId "drafts.${action.publishedId}".`
+    );
+}
+function requireRevisionMatch(documentId, actualRev, expectedRev) {
+  if (!(expectedRev === void 0 || actualRev === expectedRev))
+    throw fakeError(
+      `Revision precondition failed for "${documentId}": expected _rev "${expectedRev}" but the document is at ${actualRev === void 0 ? "no revision (missing)" : `"${actualRev}"`}.`
+    );
+}
+async function applyActions(store, actions, hooks) {
   const list = Array.isArray(actions) ? actions : [actions], snapshot = /* @__PURE__ */ new Map(), remember = (id) => {
     snapshot.has(id) || snapshot.set(id, store.get(id));
   };
@@ -537,11 +697,11 @@ function applyActions(store, actions) {
         case "sanity.action.release.archive":
         case "sanity.action.release.unarchive":
         case "sanity.action.release.delete":
-          remember(`${RELEASE_DOC_PREFIX$1}${a.releaseId}`);
+          remember(`${RELEASE_DOC_PREFIX}${a.releaseId}`);
           break;
         case "sanity.action.release.publish": {
-          remember(`${RELEASE_DOC_PREFIX$1}${a.releaseId}`);
-          const prefix = `${VERSIONS_PREFIX$1}${a.releaseId}.`;
+          remember(`${RELEASE_DOC_PREFIX}${a.releaseId}`);
+          const prefix = `${VERSIONS_PREFIX}${a.releaseId}.`;
           for (const d of store.all())
             d._id.startsWith(prefix) && (remember(d._id), remember(d._id.slice(prefix.length)));
           break;
@@ -558,8 +718,12 @@ function applyActions(store, actions) {
         case "sanity.action.document.version.unpublish":
           remember(a.versionId);
           break;
+        case "sanity.action.document.publish":
+        case "sanity.action.document.unpublish":
+          remember(a.draftId), remember(a.publishedId);
+          break;
       }
-      last = applyAction(store, a);
+      last = await applyAction(store, a, hooks);
     }
     return last;
   } catch (err) {
@@ -568,82 +732,6 @@ function applyActions(store, actions) {
     throw err;
   }
 }
-const DRAFTS_PREFIX = "drafts.", VERSIONS_PREFIX = "versions.", RELEASE_DOC_PREFIX = "_.releases.";
-function publishedIdOf(id) {
-  if (id.startsWith(DRAFTS_PREFIX)) return id.slice(DRAFTS_PREFIX.length);
-  if (id.startsWith(VERSIONS_PREFIX)) {
-    const rest = id.slice(VERSIONS_PREFIX.length), dot = rest.indexOf(".");
-    return dot === -1 ? rest : rest.slice(dot + 1);
-  }
-  return id;
-}
-function releaseNameOf(id) {
-  if (!id.startsWith(VERSIONS_PREFIX)) return;
-  const rest = id.slice(VERSIONS_PREFIX.length), dot = rest.indexOf(".");
-  if (dot !== -1)
-    return rest.slice(0, dot);
-}
-const isDraftId = (id) => id.startsWith(DRAFTS_PREFIX), isVersionId = (id) => id.startsWith(VERSIONS_PREFIX), isSystemId = (id) => id.startsWith("_."), isReleaseDocId = (id) => id.startsWith(RELEASE_DOC_PREFIX);
-function applyPerspective(docs, perspective) {
-  if (perspective === "raw") return [...docs];
-  if (perspective === "published")
-    return docs.filter((d) => !isDraftId(d._id) && !isVersionId(d._id) && !isSystemId(d._id));
-  if (perspective === "drafts")
-    return mergeStack(docs, [], { includeDrafts: !0, includeReleaseDocs: !1 });
-  const stack = [];
-  let includeDrafts = !1;
-  for (const entry of perspective)
-    entry === "drafts" ? includeDrafts = !0 : stack.push(entry);
-  return mergeStack(docs, stack, { includeDrafts, includeReleaseDocs: !0 });
-}
-function mergeStack(docs, releaseStack, options) {
-  const groups = /* @__PURE__ */ new Map(), systemReleases = [];
-  for (const doc of docs) {
-    if (isReleaseDocId(doc._id)) {
-      options.includeReleaseDocs && systemReleases.push(doc);
-      continue;
-    }
-    if (isSystemId(doc._id)) continue;
-    const pubId = publishedIdOf(doc._id);
-    let group = groups.get(pubId);
-    if (group === void 0 && (group = { versions: /* @__PURE__ */ new Map() }, groups.set(pubId, group)), isDraftId(doc._id))
-      group.draft = doc;
-    else if (isVersionId(doc._id)) {
-      const releaseName = releaseNameOf(doc._id);
-      releaseName !== void 0 && group.versions.set(releaseName, doc);
-    } else
-      group.published = doc;
-  }
-  const out = [];
-  for (const [pubId, group] of groups) {
-    let chosen;
-    for (const releaseName of releaseStack) {
-      const v = group.versions.get(releaseName);
-      if (v !== void 0) {
-        if (isUnpublishStub(v)) {
-          chosen = void 0;
-          break;
-        }
-        chosen = v;
-        break;
-      }
-    }
-    chosen === void 0 && options.includeDrafts && group.draft !== void 0 && (chosen = group.draft), chosen === void 0 && group.published !== void 0 && (releaseStack.some((name) => {
-      const v = group.versions.get(name);
-      return v !== void 0 && isUnpublishStub(v);
-    }) || (chosen = group.published)), chosen !== void 0 && out.push(projectToPublishedId(chosen, pubId));
-  }
-  return [...out, ...systemReleases];
-}
-function isUnpublishStub(doc) {
-  return doc._system?.delete === !0;
-}
-function projectToPublishedId(doc, pubId) {
-  return doc._id === pubId ? doc : { ...doc, _id: pubId, _originalId: doc._id };
-}
-function resolveDocument(docs, id, perspective) {
-  return perspective === "raw" ? docs.find((d) => d._id === id) : applyPerspective(docs, perspective).find((d) => d._id === id);
-}
 function createTransaction(executor) {
   const mutations = [], handle = {
     create: (doc) => (mutations.push({ kind: "create", doc }), handle),
@@ -739,7 +827,7 @@ const ISSUES_URL = "https://github.com/sanity-labs/client-fake-for-test/issues",
   },
   request: {
     what: "generic HTTP request hook \u2014 only wired up when the handle has an acting identity",
-    workaround: "Create the client with `accessControl`, or bind a registered token (`identities` + `token` / `withConfig({ token })`), to enable request() (it serves /users/me + the ACL path). Or register a stub."
+    workaround: "Create the client with `accessControl`, or bind a registered token (`identities` + `token` / `withConfig({ token })`), to enable request() (it serves /users/me, the ACL path, and /projects/<projectId>/users/<ids>). Or register a stub."
   },
   dryRun: {
     what: "not a method \u2014 did you mean the `{ dryRun }` mutation option?",
@@ -922,15 +1010,16 @@ function createTestClient(options = {}) {
       const { projectId, dataset } = parseRegistryKey(key);
       ensureStore(projectId, dataset).seed(docs);
     }
-  return makeHandle(
+  return makeHandle({
     backend,
-    defaultProjectId,
-    defaultDataset,
-    options.accessControl,
-    options.perspective ?? "raw",
-    options.mutationGuard,
-    options.token
-  );
+    projectId: defaultProjectId,
+    dataset: defaultDataset,
+    accessControl: options.accessControl,
+    perspective: options.perspective ?? "raw",
+    mutationGuard: options.mutationGuard,
+    token: options.token,
+    useProjectHostname: options.useProjectHostname ?? !0
+  });
 }
 function dedupeIds(results) {
   const seen = /* @__PURE__ */ new Set(), out = [];
@@ -982,13 +1071,26 @@ function toTxnMutations(operations) {
     }
   ];
 }
-function makeHandle(backend, projectId, dataset, accessControl, perspective, mutationGuard, token) {
-  const { registry } = backend, activeAccess = () => {
+function makeHandle(handleArgs) {
+  const {
+    backend,
+    projectId,
+    dataset,
+    accessControl,
+    perspective,
+    mutationGuard,
+    token,
+    useProjectHostname
+  } = handleArgs, { registry } = backend, activeAccess = () => {
     if (token === void 0) return accessControl;
     const identity = backend.identities.get(token);
     if (identity === void 0)
       throw fakeError(`no identity is registered for token "${token}" (was it removed?).`);
-    return { currentUser: identity.user, grants: identity.grants };
+    return {
+      currentUser: projectUserOf(identity, projectId),
+      ...identity.globalUser !== void 0 ? { globalUser: identity.globalUser } : {},
+      grants: identity.grants
+    };
   }, requireActiveAccess = () => {
     const access = activeAccess();
     if (access === void 0)
@@ -1138,7 +1240,7 @@ function makeHandle(backend, projectId, dataset, accessControl, perspective, mut
       txnOptions?.returnDocuments ?? !1,
       txnOptions?.returnFirst ?? !1
     );
-  }, runAction = (actions) => serializeWrite(backend, async () => applyActions(store, actions)), accessVisibleDocs = async () => {
+  }, runAction = (actions) => serializeWrite(backend, async () => applyActions(store, actions, { gate, guard: guardGate })), accessVisibleDocs = async () => {
     const all = store.all();
     if (activeAccess() === void 0) return all;
     const out = [];
@@ -1309,20 +1411,35 @@ function makeHandle(backend, projectId, dataset, accessControl, perspective, mut
       versionId: `versions.${releaseId}.${publishedId}`,
       publishedId
     }),
-    ...token !== void 0 || accessControl !== void 0 ? { request: makeRequestImpl(requireActiveAccess, projectId, dataset) } : {},
-    config: () => ({ projectId, dataset, perspective, ...token !== void 0 ? { token } : {} }),
+    ...token !== void 0 || accessControl !== void 0 ? {
+      request: makeRequestImpl({
+        getAccess: requireActiveAccess,
+        projectId,
+        dataset,
+        useProjectHostname,
+        listIdentities: () => [...backend.identities.values()]
+      })
+    } : {},
+    config: () => ({
+      projectId,
+      dataset,
+      perspective,
+      ...token !== void 0 ? { token } : {},
+      useProjectHostname
+    }),
     withConfig: (config) => {
       rejectAmbiguousIdentity("withConfig()", config), config.token !== void 0 && requireIdentity(backend, config.token, "withConfig()");
       const rebinds = config.token !== void 0 || config.accessControl !== void 0;
-      return makeHandle(
+      return makeHandle({
         backend,
-        config.projectId ?? projectId,
-        config.dataset ?? dataset,
-        rebinds ? config.accessControl : accessControl,
-        config.perspective ?? perspective,
+        projectId: config.projectId ?? projectId,
+        dataset: config.dataset ?? dataset,
+        accessControl: rebinds ? config.accessControl : accessControl,
+        perspective: config.perspective ?? perspective,
         mutationGuard,
-        rebinds ? config.token : token
-      );
+        token: rebinds ? config.token : token,
+        useProjectHostname: config.useProjectHostname ?? useProjectHostname
+      });
     },
     seed: (documents) => store.seed(documents),
     add: (documents) => store.add(documents),