@sanity-labs/client-fake-for-test 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,4 +1,8 @@
 import { parse, evaluate } from "groq-js";
+const ERR_PREFIX = "[client-fake-for-test]";
+function fakeError(message) {
+  return new Error(`${ERR_PREFIX} ${message}`);
+}
 class WriteAccessDeniedError extends Error {
   documentId;
   permission;
@@ -63,11 +67,65 @@ function makeRequestImpl(accessControl, projectId, dataset) {
       return accessControl.currentUser;
     if (path === aclPath)
       return accessControl.grants;
-    throw new Error(
-      `TestClient.request: no handler for path "${path}". The TestClient only serves "/users/me" and "${aclPath}". Configure additional endpoints via createTestClient({ accessControl }).`
+    throw fakeError(
+      `request(): no handler for path "${path}". With accessControl 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.`
     );
   };
 }
+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}`;
+}
 function createPatch(documentId, executor) {
   const ops = [];
   let ifRev;
@@ -128,7 +186,10 @@ function parsePath(path) {
   const segments = [];
   for (const raw of path.split(".")) {
     const match = /^([A-Za-z_$][\w$]*)(?:\[(.+)\])?$/.exec(raw);
-    if (!match) throw new Error(`Unsupported patch path segment: ${raw}`);
+    if (!match)
+      throw fakeError(
+        `Unsupported patch path segment "${raw}" (in path "${path}"). This fake supports dotted field access ("a.b.c"), array index ("items[0]"), and keyed lookup (\`items[_key=="x"]\`). Recursive descent ("..") and GROQ filter expressions are not supported.`
+      );
     const key = match[1], selectorRaw = match[2];
     if (selectorRaw === void 0) {
       segments.push({ key });
@@ -147,7 +208,9 @@ function parsePath(path) {
       });
       continue;
     }
-    throw new Error(`Unsupported array selector in patch path: ${selectorRaw}`);
+    throw fakeError(
+      `Unsupported array selector "[${selectorRaw}]" in patch path "${path}". Supported selectors are a numeric index (e.g. "[0]") and a single keyed match (e.g. \`[_key=="abc"]\`). Multi-key matches and arbitrary GROQ filters are not supported.`
+    );
   }
   return segments;
 }
@@ -157,7 +220,9 @@ function resolveSelector(array, selector) {
     (entry) => typeof entry == "object" && entry !== null && entry[selector.field] === selector.value
   );
   if (idx === -1)
-    throw new Error(`No array entry matched ${selector.field}=="${selector.value}" in patch path`);
+    throw fakeError(
+      `Patch path matched no array entry where ${selector.field}=="${selector.value}". The array has ${array.length} item(s); check the key exists (and that you're patching the right document).`
+    );
   return idx;
 }
 function getAtPath(doc, path) {
@@ -175,14 +240,17 @@ function getAtPath(doc, path) {
 }
 function setAtPath(doc, path, value) {
   const segments = parsePath(path);
-  if (segments.length === 0) throw new Error("Empty patch path");
+  if (segments.length === 0)
+    throw fakeError("Empty patch path \u2014 a set/setIfMissing op needs a target field.");
   let cursor = doc;
   for (let i = 0; i < segments.length - 1; i++) {
     const seg = segments[i];
     let next = cursor[seg.key];
     if (next === void 0 && (next = seg.selector?.kind === "index" || seg.selector?.kind === "keyed" ? [] : {}, cursor[seg.key] = next), seg.selector !== void 0) {
       if (!Array.isArray(next))
-        throw new Error(`Patch path crosses non-array at segment ${seg.key}`);
+        throw fakeError(
+          `Patch path "${path}" applies an array selector to field "${seg.key}", but that field holds ${describeType(next)}, not an array.`
+        );
       const idx = resolveSelector(next, seg.selector);
       cursor = next[idx];
     } else
@@ -192,7 +260,9 @@ function setAtPath(doc, path, value) {
   if (last.selector !== void 0) {
     const arr = cursor[last.key];
     if (!Array.isArray(arr))
-      throw new Error(`Patch path crosses non-array at segment ${last.key}`);
+      throw fakeError(
+        `Patch path "${path}" applies an array selector to field "${last.key}", but that field holds ${describeType(arr)}, not an array.`
+      );
     const idx = resolveSelector(arr, last.selector);
     arr[idx] = value;
   } else
@@ -224,74 +294,354 @@ function unsetAtPath(doc, path) {
 }
 function insertIntoArray(doc, position, anchor, items) {
   const segments = parsePath(anchor);
-  if (segments.length === 0) throw new Error("Empty insert anchor");
+  if (segments.length === 0)
+    throw fakeError("Empty insert anchor \u2014 insert() needs an array path to anchor against.");
   const last = segments[segments.length - 1];
   if (last.selector === void 0)
-    throw new Error(`Insert anchor must end with an array selector: ${anchor}`);
+    throw fakeError(
+      `Insert anchor "${anchor}" must end with an array selector (an index like "[0]" or a keyed match like \`[_key=="x"]\`) so the fake knows where in the array to insert.`
+    );
   let cursor = doc;
   for (let i = 0; i < segments.length - 1; i++) {
     const seg = segments[i], next = cursor[seg.key];
     if (next == null)
-      throw new Error(`Insert anchor traverses missing field: ${seg.key}`);
+      throw fakeError(
+        `Insert anchor "${anchor}" traverses field "${seg.key}", which is missing on the document. setIfMissing the parent first, or anchor against an existing array.`
+      );
     if (seg.selector !== void 0) {
       if (!Array.isArray(next))
-        throw new Error(`Insert anchor traverses non-array at: ${seg.key}`);
+        throw fakeError(
+          `Insert anchor "${anchor}" applies an array selector to field "${seg.key}", but it holds ${describeType(next)}, not an array.`
+        );
       cursor = next[resolveSelector(next, seg.selector)];
     } else
       cursor = next;
   }
   const arr = cursor[last.key];
   if (!Array.isArray(arr))
-    throw new Error(`Insert anchor target is not an array: ${last.key}`);
+    throw fakeError(
+      `Insert anchor "${anchor}" targets field "${last.key}", but it holds ${describeType(arr)}, not an array.`
+    );
   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);
 }
-function createTestStore(initial) {
-  const docs = /* @__PURE__ */ new Map(), promote = (doc) => {
-    if (typeof doc._id != "string" || doc._id.length === 0)
-      throw new Error(`document is missing _id: ${JSON.stringify(doc)}`);
-    if (typeof doc._type != "string" || doc._type.length === 0)
-      throw new Error(`document ${doc._id} is missing _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 = promote(d);
-      docs.set(promoted._id, promoted);
-    }
+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}`;
+function parseVersionId(versionId) {
+  if (!versionId.startsWith(VERSIONS_PREFIX$1))
+    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(".");
+  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").`
+    );
+  return { releaseId: rest.slice(0, dot), publishedId: rest.slice(dot + 1) };
+}
+function getRelease(store, releaseId) {
+  const doc = store.get(releaseDocId(releaseId));
+  if (doc === void 0)
+    throw fakeError(
+      `Release "${releaseId}" not found. Create it first with client.releases.create({ releaseId: "${releaseId}" }) (or a "sanity.action.release.create" action) before editing, scheduling, or adding versions to it.`
+    );
+  return doc;
+}
+function maybeRelease(store, releaseId) {
+  return store.get(releaseDocId(releaseId));
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function promote(doc) {
+  const now = nowIso();
+  return {
+    ...doc,
+    _id: doc._id,
+    _type: doc._type,
+    _rev: cryptoRandomKey(),
+    _createdAt: doc._createdAt ?? now,
+    _updatedAt: now
   };
-  return initial && seed(initial), {
-    seed,
-    add: (documents) => {
-      for (const d of documents) {
-        const promoted = promote(d);
-        docs.set(promoted._id, promoted);
+}
+function bumpRev(doc, patch) {
+  return {
+    ...doc,
+    ...patch,
+    _rev: cryptoRandomKey(),
+    _updatedAt: nowIso()
+  };
+}
+function requireActive(release) {
+  if (release.state !== "active")
+    throw fakeError(
+      `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) {
+  switch (action.actionType) {
+    case "sanity.action.release.create": {
+      if (maybeRelease(store, action.releaseId) !== void 0)
+        throw fakeError(
+          `Release "${action.releaseId}" already exists. release.create expects a new releaseId; use release.edit to change its metadata, or pick a different releaseId.`
+        );
+      const now = nowIso(), metadata = {
+        releaseType: "undecided",
+        ...action.metadata
+      }, doc = {
+        _id: releaseDocId(action.releaseId),
+        _type: "system.release",
+        _rev: cryptoRandomKey(),
+        _createdAt: now,
+        _updatedAt: now,
+        name: action.releaseId,
+        state: "active",
+        metadata
+      };
+      return store.put(doc), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.release.edit": {
+      const release = getRelease(store, action.releaseId), patchOps = [];
+      action.patch.set !== void 0 && patchOps.push({ kind: "set", props: action.patch.set }), action.patch.unset !== void 0 && patchOps.push({ kind: "unset", paths: action.patch.unset });
+      const patched = applyPatchOps(release, patchOps);
+      return store.put(bumpRev(patched, {})), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.release.schedule": {
+      const release = getRelease(store, action.releaseId);
+      if (release.state !== "active")
+        throw fakeError(
+          `Cannot schedule release "${action.releaseId}": it is "${release.state}", and only "active" releases can be scheduled.`
+        );
+      return store.put(
+        bumpRev(release, {
+          state: "scheduled",
+          publishAt: action.publishAt
+        })
+      ), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.release.unschedule": {
+      const release = getRelease(store, action.releaseId);
+      if (release.state !== "scheduled")
+        throw fakeError(
+          `Cannot unschedule release "${action.releaseId}": it is "${release.state}", and only "scheduled" releases can be unscheduled.`
+        );
+      const next = { ...release, state: "active" };
+      return delete next.publishAt, store.put(bumpRev(next, {})), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.release.publish": {
+      const release = getRelease(store, action.releaseId);
+      if (release.state === "published")
+        return { transactionId: cryptoRandomKey() };
+      if (release.state !== "active" && release.state !== "scheduled")
+        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));
+      for (const v of sources) {
+        const pubId = v._id.slice(prefix.length);
+        if (v._system?.delete === !0)
+          store.remove(pubId);
+        else {
+          const body = {
+            ...v,
+            _id: pubId
+          };
+          delete body._originalId, delete body._system;
+          const promoted = promote(body), existing = store.get(pubId);
+          existing !== void 0 && (promoted._createdAt = existing._createdAt), store.put(promoted);
+        }
+        store.remove(v._id);
       }
-    },
-    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()]
+      return store.put(bumpRev(release, { state: "published" })), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.release.archive": {
+      const release = getRelease(store, action.releaseId);
+      if (release.state !== "active" && release.state !== "scheduled")
+        throw fakeError(
+          `Cannot archive release "${action.releaseId}": it is "${release.state}", and only "active" or "scheduled" releases can be archived.`
+        );
+      return store.put(bumpRev(release, { state: "archived" })), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.release.unarchive": {
+      const release = getRelease(store, action.releaseId);
+      if (release.state !== "archived")
+        throw fakeError(
+          `Cannot unarchive release "${action.releaseId}": it is "${release.state}", and only "archived" releases can be unarchived.`
+        );
+      return store.put(bumpRev(release, { state: "active" })), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.release.delete": {
+      const release = getRelease(store, action.releaseId);
+      if (release.state !== "archived" && release.state !== "published")
+        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}.`;
+      for (const v of store.all())
+        v._id.startsWith(prefix) && store.remove(v._id);
+      return store.remove(release._id), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.document.version.create": {
+      const releaseId = action.releaseId ?? (action.document._id !== void 0 ? parseVersionId(action.document._id).releaseId : void 0);
+      if (releaseId === void 0)
+        throw fakeError(
+          'version.create needs a release to attach to: pass `releaseId`, or a `document._id` shaped "versions.<releaseId>.<publishedId>" so the release can be inferred.'
+        );
+      const release = getRelease(store, releaseId);
+      requireActive(release);
+      const vid = versionDocId(releaseId, action.publishedId), doc = {
+        ...action.document,
+        _id: vid
+      }, existing = store.get(vid), promoted = promote(doc);
+      return existing !== void 0 && (promoted._createdAt = existing._createdAt), store.put(promoted), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.document.version.replace": {
+      const id = action.document._id;
+      if (typeof id != "string")
+        throw fakeError(
+          'version.replace needs `document._id` (a version id like "versions.<releaseId>.<publishedId>") to identify which version document to replace.'
+        );
+      const { releaseId } = parseVersionId(id), release = getRelease(store, releaseId);
+      requireActive(release);
+      const existing = store.get(id), promoted = promote(action.document);
+      return existing !== void 0 && (promoted._createdAt = existing._createdAt), store.put(promoted), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.document.version.discard": {
+      const { releaseId } = parseVersionId(action.versionId), release = getRelease(store, releaseId);
+      return requireActive(release), store.remove(action.versionId), { transactionId: cryptoRandomKey() };
+    }
+    case "sanity.action.document.version.unpublish": {
+      const { releaseId } = parseVersionId(action.versionId), release = getRelease(store, releaseId);
+      requireActive(release);
+      const doc = {
+        _id: action.versionId,
+        _type: "stub",
+        _system: { delete: !0 }
+      };
+      return store.put(promote(doc)), { transactionId: cryptoRandomKey() };
+    }
+  }
+}
+function applyActions(store, actions) {
+  const list = Array.isArray(actions) ? actions : [actions], snapshot = /* @__PURE__ */ new Map(), remember = (id) => {
+    snapshot.has(id) || snapshot.set(id, store.get(id));
   };
+  try {
+    let last = { transactionId: cryptoRandomKey() };
+    for (const a of list) {
+      switch (a.actionType) {
+        case "sanity.action.release.create":
+        case "sanity.action.release.edit":
+        case "sanity.action.release.schedule":
+        case "sanity.action.release.unschedule":
+        case "sanity.action.release.archive":
+        case "sanity.action.release.unarchive":
+        case "sanity.action.release.delete":
+          remember(`${RELEASE_DOC_PREFIX$1}${a.releaseId}`);
+          break;
+        case "sanity.action.release.publish": {
+          remember(`${RELEASE_DOC_PREFIX$1}${a.releaseId}`);
+          const prefix = `${VERSIONS_PREFIX$1}${a.releaseId}.`;
+          for (const d of store.all())
+            d._id.startsWith(prefix) && (remember(d._id), remember(d._id.slice(prefix.length)));
+          break;
+        }
+        case "sanity.action.document.version.create": {
+          const releaseId = a.releaseId ?? (typeof a.document._id == "string" ? parseVersionId(a.document._id).releaseId : void 0);
+          releaseId !== void 0 && remember(versionDocId(releaseId, a.publishedId));
+          break;
+        }
+        case "sanity.action.document.version.replace":
+          typeof a.document._id == "string" && remember(a.document._id);
+          break;
+        case "sanity.action.document.version.discard":
+        case "sanity.action.document.version.unpublish":
+          remember(a.versionId);
+          break;
+      }
+      last = applyAction(store, a);
+    }
+    return last;
+  } catch (err) {
+    for (const [id, doc] of snapshot)
+      doc === void 0 ? store.remove(id) : store.put(doc);
+    throw err;
+  }
 }
-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 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 = {
@@ -323,12 +673,193 @@ function createTransaction(executor) {
   };
   return handle;
 }
-const DEFAULT_PROJECT_ID = "test", DEFAULT_DATASET = "test", registryKey = (projectId, dataset) => `${projectId}:${dataset}`, parseRegistryKey = (key) => {
+const ISSUES_URL = "https://github.com/sanity-labs/client-fake-for-test/issues", SUPPORTED_SURFACE = [
+  "fetch",
+  "getDocument",
+  "getDocuments",
+  "create",
+  "createOrReplace",
+  "createIfNotExists",
+  "delete",
+  "patch",
+  "transaction",
+  "mutate",
+  "action",
+  "releases",
+  "createVersion",
+  "unpublishVersion",
+  "request (only with accessControl)",
+  "config",
+  "withConfig"
+], UNSUPPORTED_MEMBERS = {
+  listen: {
+    what: "real-time listener (returns an RxJS Observable of mutation events)",
+    workaround: 'Test your subscription logic in isolation, or register a fake: client.stub("listen", () => myFakeObservable).'
+  },
+  observable: {
+    what: "the RxJS-flavoured mirror of the client API",
+    workaround: "Use the Promise-based methods and wrap them with `from()` if you need an Observable."
+  },
+  clone: {
+    what: "clone the client with the same config",
+    workaround: "Use `withConfig({})` \u2014 it returns a sibling handle into the same store."
+  },
+  getUrl: {
+    what: "build an absolute API URL for a path",
+    workaround: "Hard-code the expected URL in your test, or stub it."
+  },
+  getDataUrl: {
+    what: "build an absolute data-API URL",
+    workaround: "Hard-code the expected URL in your test, or stub it."
+  },
+  assets: {
+    what: "asset upload / metadata namespace",
+    workaround: "Seed asset documents into the store directly with `seed()` / `add()`."
+  },
+  agent: {
+    what: "Agent Actions namespace (generate / transform / \u2026)",
+    workaround: 'Stub the call site: client.stub("agent", myFakeAgent).'
+  },
+  projects: {
+    what: "project-management namespace",
+    workaround: "Out of scope for a data-plane fake \u2014 stub the call site."
+  },
+  users: {
+    what: "user-management namespace",
+    workaround: "Out of scope for a data-plane fake \u2014 stub the call site."
+  },
+  live: {
+    what: "Live Content API namespace",
+    workaround: "Out of scope \u2014 stub the call site or test the consumer separately."
+  },
+  mediaLibrary: {
+    what: "Media Library namespace",
+    workaround: "Out of scope \u2014 seed documents directly or stub the call site."
+  },
+  request: {
+    what: "generic HTTP request hook \u2014 only wired up when accessControl is configured",
+    workaround: "Create the client with `accessControl` to enable request() (it serves /users/me + the ACL path), or register a stub."
+  },
+  dryRun: {
+    what: "not a method \u2014 did you mean the `{ dryRun }` mutation option?",
+    workaround: "Pass `{ dryRun: true }` as the second arg to create / mutate / delete."
+  }
+}, PROBE_NAMES = /* @__PURE__ */ new Set([
+  "then",
+  "catch",
+  "finally",
+  "toJSON",
+  "asymmetricMatch",
+  "$$typeof",
+  "nodeType",
+  "_isMockFunction"
+]);
+function guardMessage(path, detail, workaround) {
+  return [
+    `[client-fake-for-test] \`client.${path}\` ${detail}`,
+    "",
+    "This is an in-memory fake of @sanity/client. It implements:",
+    `  ${SUPPORTED_SURFACE.join(", ")}.`,
+    "",
+    `\u2192 ${workaround}`,
+    "",
+    `Register a stub to fill any gap:  client.stub(${JSON.stringify(path.split(".")[0])}, handler)`,
+    `If this should be supported, open an issue: ${ISSUES_URL}`
+  ].join(`
+`);
+}
+function makeGuard(path, message) {
+  const thrower = () => {
+    throw new Error(message);
+  };
+  return new Proxy(thrower, {
+    apply: () => thrower(),
+    get: (_t, prop) => {
+      if (typeof prop == "symbol" || PROBE_NAMES.has(prop)) return;
+      const childPath = `${path}.${String(prop)}`, top = path.split(".")[0], entry = UNSUPPORTED_MEMBERS[top], detail = entry ? `is not implemented (${entry.what}).` : "is not implemented.", workaround = entry?.workaround ?? "Register a stub or use a different test strategy.";
+      return makeGuard(childPath, guardMessage(childPath, detail, workaround));
+    }
+  });
+}
+function wrapRecorded(method, fn, onCall) {
+  return (...args) => {
+    const settle = onCall(method, args);
+    try {
+      const out = fn(...args);
+      return out !== null && typeof out == "object" && typeof out.then == "function" ? out.then(
+        (result) => (settle({ result }), result),
+        (error) => {
+          throw settle({ error }), error;
+        }
+      ) : (settle({ result: out }), out);
+    } catch (error) {
+      throw settle({ error }), error;
+    }
+  };
+}
+function wrapNamespace(ns, prefix, onCall) {
+  return new Proxy(ns, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      return typeof prop == "string" && typeof value == "function" ? wrapRecorded(`${prefix}.${prop}`, value, onCall) : value;
+    }
+  });
+}
+function wrapWithGuards(client, config) {
+  const { getStub, onCall, recorded } = config;
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      if (typeof prop == "symbol") return Reflect.get(target, prop, receiver);
+      if (prop in target) {
+        const value = Reflect.get(target, prop, receiver);
+        if (onCall !== void 0 && recorded?.has(prop) === !0) {
+          if (typeof value == "function")
+            return wrapRecorded(prop, value, onCall);
+          if (value !== null && typeof value == "object")
+            return wrapNamespace(value, prop, onCall);
+        }
+        return value;
+      }
+      if (PROBE_NAMES.has(prop)) return;
+      const stub = getStub(prop);
+      if (stub !== void 0) return stub;
+      const entry = UNSUPPORTED_MEMBERS[prop];
+      return entry !== void 0 ? makeGuard(
+        prop,
+        guardMessage(prop, `is not implemented (${entry.what}).`, entry.workaround)
+      ) : makeGuard(
+        prop,
+        guardMessage(
+          prop,
+          "is not a method on this fake (unknown member or unimplemented @sanity/client API).",
+          "Check for a typo, register a stub, or use a different test strategy."
+        )
+      );
+    }
+  });
+}
+const RECORDED_METHODS = /* @__PURE__ */ new Set([
+  "fetch",
+  "getDocument",
+  "getDocuments",
+  "create",
+  "createOrReplace",
+  "createIfNotExists",
+  "delete",
+  "patch",
+  "transaction",
+  "mutate",
+  "action",
+  "releases",
+  "createVersion",
+  "unpublishVersion",
+  "request"
+]), DEFAULT_PROJECT_ID = "test", DEFAULT_DATASET = "test", registryKey = (projectId, dataset) => `${projectId}:${dataset}`, parseRegistryKey = (key) => {
   const [projectId, dataset] = key.split(":");
   return { projectId, dataset };
 };
 function createTestClient(options = {}) {
-  const defaultProjectId = options.projectId ?? DEFAULT_PROJECT_ID, defaultDataset = options.dataset ?? DEFAULT_DATASET, registry = /* @__PURE__ */ new Map(), ensureStore = (projectId, dataset) => {
+  const defaultProjectId = options.projectId ?? DEFAULT_PROJECT_ID, defaultDataset = options.dataset ?? DEFAULT_DATASET, backend = { registry: /* @__PURE__ */ new Map(), log: [], stubs: /* @__PURE__ */ new Map(), calls: [] }, registry = backend.registry, ensureStore = (projectId, dataset) => {
     const key = registryKey(projectId, dataset);
     let store = registry.get(key);
     return store === void 0 && (store = createTestStore(), registry.set(key, store)), store;
@@ -338,19 +869,87 @@ function createTestClient(options = {}) {
       const { projectId, dataset } = parseRegistryKey(key);
       ensureStore(projectId, dataset).seed(docs);
     }
-  return makeHandle(registry, defaultProjectId, defaultDataset, options.accessControl);
+  return makeHandle(
+    backend,
+    defaultProjectId,
+    defaultDataset,
+    options.accessControl,
+    options.perspective ?? "raw"
+  );
+}
+function dedupeIds(results) {
+  const seen = /* @__PURE__ */ new Set(), out = [];
+  for (const r of results)
+    seen.has(r.id) || (seen.add(r.id), out.push(r.id));
+  return out;
 }
-function makeHandle(registry, projectId, dataset, accessControl) {
-  const store = (() => {
+function formatMutationResult(documents, results, transactionId, returnDocuments, returnFirst) {
+  return returnDocuments ? returnFirst ? documents[0] : documents : returnFirst ? {
+    transactionId,
+    documentId: results[0]?.id,
+    results
+  } : {
+    transactionId,
+    documentIds: dedupeIds(results),
+    results
+  };
+}
+function toSingleTxnMutation(op) {
+  if ("create" in op) return { kind: "create", doc: op.create };
+  if ("createOrReplace" in op) return { kind: "createOrReplace", doc: op.createOrReplace };
+  if ("createIfNotExists" in op) return { kind: "createIfNotExists", doc: op.createIfNotExists };
+  if ("delete" in op) return { kind: "delete", id: op.delete.id };
+  const p = op.patch, ops = [];
+  if (p.set !== void 0 && ops.push({ kind: "set", props: p.set }), p.setIfMissing !== void 0 && ops.push({ kind: "setIfMissing", props: p.setIfMissing }), p.unset !== void 0 && ops.push({ kind: "unset", paths: p.unset }), p.inc !== void 0 && ops.push({ kind: "inc", props: p.inc }), p.dec !== void 0 && ops.push({ kind: "dec", props: p.dec }), p.insert !== void 0) {
+    const { before, after, replace, items } = p.insert, position = before !== void 0 ? "before" : after !== void 0 ? "after" : "replace", anchor = before ?? after ?? replace;
+    if (anchor === void 0)
+      throw fakeError(
+        'mutate(): a `patch.insert` operation must name exactly one anchor \u2014 `before`, `after`, or `replace` \u2014 pointing at an array path (e.g. "tags[-1]" or `tags[_key=="x"]`), alongside `items`. None was set.'
+      );
+    ops.push({ kind: "insert", position, anchor, items });
+  }
+  return {
+    kind: "patch",
+    documentId: p.id,
+    ops,
+    ...p.ifRevisionID !== void 0 ? { ifRev: p.ifRevisionID } : {}
+  };
+}
+function toTxnMutations(operations) {
+  if (Array.isArray(operations)) return operations.map(toSingleTxnMutation);
+  const json = operations.toJSON();
+  return Array.isArray(json) ? json : [
+    {
+      kind: "patch",
+      documentId: json.id,
+      ops: json.ops,
+      ...json.ifRev !== void 0 ? { ifRev: json.ifRev } : {}
+    }
+  ];
+}
+function makeHandle(backend, projectId, dataset, accessControl, perspective) {
+  const { registry } = backend, store = (() => {
     const key = registryKey(projectId, dataset);
     let s = registry.get(key);
     return s === void 0 && (s = createTestStore(), registry.set(key, s)), s;
-  })(), promote = (doc) => {
+  })(), record = (transactionId, mutations) => {
+    backend.log.push({ transactionId, projectId, dataset, mutations });
+  }, writeResult = (documents, results, transactionId, opts) => formatMutationResult(
+    documents,
+    results,
+    transactionId,
+    opts?.returnDocuments ?? !0,
+    opts?.returnFirst ?? !0
+  ), promote2 = (doc) => {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     if (typeof doc._id != "string" || doc._id.length === 0)
-      throw new Error("document is missing _id");
+      throw fakeError(
+        `Cannot store a document without a non-empty string \`_id\` (got ${JSON.stringify(doc._id)}). Unlike @sanity/client, this fake never auto-generates ids \u2014 give every document an explicit _id.`
+      );
     if (typeof doc._type != "string" || doc._type.length === 0)
-      throw new Error(`document ${doc._id} is missing _type`);
+      throw fakeError(
+        `Document "${doc._id}" is missing a non-empty string \`_type\` (got ${JSON.stringify(doc._type)}). Every Sanity document needs a _type.`
+      );
     return {
       ...doc,
       _id: doc._id,
@@ -363,10 +962,12 @@ function makeHandle(registry, projectId, dataset, accessControl) {
     if (ifRevisionId === void 0) return;
     const existing = store.get(id);
     if (existing === void 0)
-      throw new Error(`ifRevisionId check failed: document ${id} does not exist`);
+      throw fakeError(
+        `ifRevisionId check failed: document "${id}" does not exist, so its revision cannot match the expected _rev="${ifRevisionId}". Drop ifRevisionId when creating a new document, or seed/create the document before guarding on its revision.`
+      );
     if (existing._rev !== ifRevisionId)
-      throw new Error(
-        `ifRevisionId check failed: document ${id} has _rev=${existing._rev}, expected ${ifRevisionId}`
+      throw fakeError(
+        `ifRevisionId check failed: document "${id}" is at _rev="${existing._rev}" but the mutation required _rev="${ifRevisionId}". The document changed since you read it \u2014 re-read it and retry. (This mirrors Sanity's optimistic-locking 409.)`
       );
   }, gate = async (document, permission) => {
     accessControl !== void 0 && await enforceWriteAccess({
@@ -383,7 +984,9 @@ function makeHandle(registry, projectId, dataset, accessControl) {
   }), applyPatch = async (documentId, ops, ifRev) => {
     const existing = store.get(documentId);
     if (existing === void 0)
-      throw new Error(`Cannot patch document ${documentId}: not found`);
+      throw fakeError(
+        `Cannot patch document "${documentId}": not found \u2014 no document with that _id exists in dataset "${projectId}:${dataset}". patch() requires the target to already exist; use createOrReplace() / createIfNotExists() to upsert, or seed the document first.`
+      );
     checkRevision(documentId, ifRev), await gate(existing, "update");
     const patched = applyPatchOps(existing, ops), now = (/* @__PURE__ */ new Date()).toISOString(), next = {
       ...patched,
@@ -392,7 +995,7 @@ function makeHandle(registry, projectId, dataset, accessControl) {
     };
     return store.put(next), next;
   }, applyTransaction = async (mutations, txnOptions) => {
-    const snapshot = /* @__PURE__ */ new Map(), touchedIds = [], operations = [], remember = (id) => {
+    const transactionId = txnOptions?.transactionId ?? cryptoRandomKey(), snapshot = /* @__PURE__ */ new Map(), touchedIds = [], operations = [], remember = (id) => {
       snapshot.has(id) || snapshot.set(id, store.get(id));
     };
     try {
@@ -400,15 +1003,17 @@ function makeHandle(registry, projectId, dataset, accessControl) {
         switch (mut.kind) {
           case "create": {
             remember(mut.doc._id);
-            const promoted = promote(mut.doc);
+            const promoted = promote2(mut.doc);
             if (store.get(promoted._id) !== void 0)
-              throw new Error(`create failed: document ${promoted._id} already exists`);
+              throw fakeError(
+                `create() failed: a document with _id "${promoted._id}" already exists in dataset "${projectId}:${dataset}". Use createOrReplace() to overwrite it, or createIfNotExists() to leave the existing one untouched.`
+              );
             await gate(promoted, "create"), store.put(promoted), touchedIds.push(promoted._id), operations.push({ id: promoted._id, operation: "create" });
             break;
           }
           case "createOrReplace": {
             remember(mut.doc._id);
-            const promoted = promote(mut.doc), existing = store.get(promoted._id);
+            const promoted = promote2(mut.doc), existing = store.get(promoted._id);
             await gate(existing ?? promoted, existing !== void 0 ? "update" : "create");
             const wasPresent = existing !== void 0;
             store.put(promoted), touchedIds.push(promoted._id), operations.push({ id: promoted._id, operation: wasPresent ? "update" : "create" });
@@ -416,7 +1021,7 @@ function makeHandle(registry, projectId, dataset, accessControl) {
           }
           case "createIfNotExists": {
             if (remember(mut.doc._id), store.get(mut.doc._id) === void 0) {
-              const promoted = promote(mut.doc);
+              const promoted = promote2(mut.doc);
               await gate(promoted, "create"), store.put(promoted), touchedIds.push(promoted._id), operations.push({ id: promoted._id, operation: "create" });
             }
             break;
@@ -437,86 +1042,233 @@ function makeHandle(registry, projectId, dataset, accessControl) {
         doc === void 0 ? store.remove(id) : store.put(doc);
       throw error;
     }
-    if (txnOptions?.returnDocuments) {
-      const docs = touchedIds.map((id) => store.get(id)).filter((d) => d !== void 0);
-      return txnOptions.returnFirst ? docs[0] : docs;
-    }
-    return {
-      transactionId: cryptoRandomKey(),
-      results: operations
-    };
-  }, visibleDocs = async () => {
+    record(transactionId, mutations);
+    const documents = touchedIds.map((id) => store.get(id)).filter((d) => d !== void 0);
+    return formatMutationResult(
+      documents,
+      operations,
+      transactionId,
+      txnOptions?.returnDocuments ?? !1,
+      txnOptions?.returnFirst ?? !1
+    );
+  }, accessVisibleDocs = async () => {
     const all = store.all();
     if (accessControl === void 0) return all;
     const out = [];
     for (const doc of all)
       await canRead(doc) && out.push(doc);
     return out;
-  };
-  return {
-    fetch: async (query, params) => {
-      const tree = parse(query, params ? { params } : void 0);
-      return await (await evaluate(tree, {
-        dataset: await visibleDocs(),
+  }, visibleDocs = async (override) => {
+    const accessible = await accessVisibleDocs();
+    return applyPerspective(accessible, override ?? perspective);
+  }, client = {
+    fetch: async (query, params, opts) => {
+      const start = Date.now(), tree = parse(query, params ? { params } : void 0), result = await (await evaluate(tree, {
+        dataset: await visibleDocs(opts?.perspective),
         ...params !== void 0 ? { params } : {}
       })).get();
+      if (opts?.filterResponse === !1) {
+        const ms = Date.now() - start;
+        return opts.returnQuery === !1 ? { ms, result } : { query, ms, result };
+      }
+      return result;
     },
-    getDocument: async (id) => {
-      const doc = store.get(id);
-      return doc === void 0 || !await canRead(doc) ? null : doc;
-    },
-    getDocuments: async (ids) => {
-      const result = [];
-      for (const id of ids) {
+    getDocument: async (id, opts) => {
+      const effective = opts?.perspective ?? perspective;
+      if (effective === "raw") {
         const doc = store.get(id);
-        doc === void 0 ? result.push(null) : await canRead(doc) ? result.push(doc) : result.push(null);
+        return doc === void 0 || !await canRead(doc) ? void 0 : doc;
       }
-      return result;
+      const view = await visibleDocs(effective);
+      return resolveDocument(view, id, effective) ?? void 0;
+    },
+    getDocuments: async (ids, opts) => {
+      const effective = opts?.perspective ?? perspective;
+      if (effective === "raw") {
+        const result = [];
+        for (const id of ids) {
+          const doc = store.get(id);
+          doc === void 0 ? result.push(null) : await canRead(doc) ? result.push(doc) : result.push(null);
+        }
+        return result;
+      }
+      const view = await visibleDocs(effective);
+      return ids.map((id) => resolveDocument(view, id, effective) ?? null);
     },
     create: async (doc, opts) => {
       if (checkRevision(doc._id, opts?.ifRevisionId), store.get(doc._id) !== void 0)
-        throw new Error(`create failed: document ${doc._id} already exists`);
-      const promoted = promote(doc);
-      return await gate(promoted, "create"), store.put(promoted), promoted;
+        throw fakeError(
+          `create() failed: a document with _id "${doc._id}" already exists in dataset "${projectId}:${dataset}". Use createOrReplace() to overwrite it, or createIfNotExists() to leave the existing one untouched.`
+        );
+      const promoted = promote2(doc);
+      await gate(promoted, "create");
+      const transactionId = opts?.transactionId ?? cryptoRandomKey();
+      return opts?.dryRun !== !0 && (store.put(promoted), record(transactionId, [{ kind: "create", doc }])), writeResult(
+        [promoted],
+        [{ id: promoted._id, operation: "create" }],
+        transactionId,
+        opts
+      );
     },
     createOrReplace: async (doc, opts) => {
       checkRevision(doc._id, opts?.ifRevisionId);
-      const promoted = promote(doc), existing = store.get(doc._id);
-      return await gate(existing ?? promoted, existing !== void 0 ? "update" : "create"), store.put(promoted), promoted;
+      const promoted = promote2(doc), existing = store.get(doc._id);
+      await gate(existing ?? promoted, existing !== void 0 ? "update" : "create");
+      const transactionId = opts?.transactionId ?? cryptoRandomKey();
+      opts?.dryRun !== !0 && (store.put(promoted), record(transactionId, [{ kind: "createOrReplace", doc }]));
+      const operation = existing !== void 0 ? "update" : "create";
+      return writeResult(
+        [promoted],
+        [{ id: promoted._id, operation }],
+        transactionId,
+        opts
+      );
     },
     createIfNotExists: async (doc, opts) => {
       checkRevision(doc._id, opts?.ifRevisionId);
-      const existing = store.get(doc._id);
-      if (existing !== void 0) return existing;
-      const promoted = promote(doc);
-      return await gate(promoted, "create"), store.put(promoted), promoted;
+      const existing = store.get(doc._id), transactionId = opts?.transactionId ?? cryptoRandomKey();
+      if (existing !== void 0)
+        return writeResult(
+          [existing],
+          [{ id: existing._id, operation: "none" }],
+          transactionId,
+          opts
+        );
+      const promoted = promote2(doc);
+      return await gate(promoted, "create"), opts?.dryRun !== !0 && (store.put(promoted), record(transactionId, [{ kind: "createIfNotExists", doc }])), writeResult(
+        [promoted],
+        [{ id: promoted._id, operation: "create" }],
+        transactionId,
+        opts
+      );
     },
     delete: async (id, opts) => {
       checkRevision(id, opts?.ifRevisionId);
       const existing = store.get(id);
-      return existing !== void 0 && await gate(existing, "update"), store.remove(id) ? { _id: id } : null;
+      existing !== void 0 && await gate(existing, "update");
+      const transactionId = opts?.transactionId ?? cryptoRandomKey();
+      let removed = existing;
+      return opts?.dryRun !== !0 && (removed = store.remove(id), removed !== void 0 && record(transactionId, [{ kind: "delete", id }])), opts?.returnDocuments === void 0 && opts?.returnFirst === void 0 ? removed !== void 0 ? { _id: id } : null : formatMutationResult(
+        removed !== void 0 ? [removed] : [],
+        removed !== void 0 ? [{ id, operation: "delete" }] : [],
+        transactionId,
+        opts.returnDocuments ?? !0,
+        opts.returnFirst ?? !0
+      );
     },
-    patch: (documentId) => createPatch(documentId, { apply: applyPatch }),
+    patch: (documentId) => createPatch(documentId, {
+      apply: async (docId, ops, ifRev) => {
+        const doc = await applyPatch(docId, ops, ifRev);
+        return record(cryptoRandomKey(), [
+          { kind: "patch", documentId: docId, ops, ...ifRev !== void 0 ? { ifRev } : {} }
+        ]), doc;
+      }
+    }),
     transaction: () => createTransaction({ apply: applyTransaction }),
+    mutate: async (operations, options) => applyTransaction(toTxnMutations(operations), options),
+    action: async (action) => applyActions(store, action),
+    releases: {
+      create: async ({ releaseId, metadata }) => {
+        const result = applyActions(store, {
+          actionType: "sanity.action.release.create",
+          releaseId,
+          ...metadata !== void 0 ? { metadata } : {}
+        }), doc = store.get(`_.releases.${releaseId}`);
+        return {
+          ...result,
+          releaseId,
+          metadata: doc?.metadata ?? { releaseType: "undecided" }
+        };
+      },
+      edit: async ({ releaseId, patch }) => applyActions(store, { actionType: "sanity.action.release.edit", releaseId, patch }),
+      get: async ({ releaseId }) => store.get(`_.releases.${releaseId}`),
+      fetchDocuments: async ({ releaseId }) => {
+        const prefix = `versions.${releaseId}.`;
+        return store.all().filter((d) => d._id.startsWith(prefix));
+      },
+      schedule: async ({ releaseId, publishAt }) => applyActions(store, {
+        actionType: "sanity.action.release.schedule",
+        releaseId,
+        publishAt
+      }),
+      unschedule: async ({ releaseId }) => applyActions(store, { actionType: "sanity.action.release.unschedule", releaseId }),
+      publish: async ({ releaseId }) => applyActions(store, { actionType: "sanity.action.release.publish", releaseId }),
+      archive: async ({ releaseId }) => applyActions(store, { actionType: "sanity.action.release.archive", releaseId }),
+      unarchive: async ({ releaseId }) => applyActions(store, { actionType: "sanity.action.release.unarchive", releaseId }),
+      delete: async ({ releaseId }) => applyActions(store, { actionType: "sanity.action.release.delete", releaseId })
+    },
+    createVersion: async ({ releaseId, publishedId, document }) => applyActions(store, {
+      actionType: "sanity.action.document.version.create",
+      releaseId,
+      publishedId,
+      document
+    }),
+    unpublishVersion: async ({ releaseId, publishedId }) => applyActions(store, {
+      actionType: "sanity.action.document.version.unpublish",
+      versionId: `versions.${releaseId}.${publishedId}`,
+      publishedId
+    }),
     ...accessControl !== void 0 ? { request: makeRequestImpl(accessControl, projectId, dataset) } : {},
-    config: () => ({ projectId, dataset }),
-    withConfig: (config) => makeHandle(registry, config.projectId ?? projectId, config.dataset ?? dataset, accessControl),
+    config: () => ({ projectId, dataset, perspective }),
+    withConfig: (config) => makeHandle(
+      backend,
+      config.projectId ?? projectId,
+      config.dataset ?? dataset,
+      accessControl,
+      config.perspective ?? perspective
+    ),
     seed: (documents) => store.seed(documents),
     add: (documents) => store.add(documents),
     reset: () => store.reset(),
     snapshot: () => store.snapshot(),
     store: () => store,
-    datasets: () => [...registry.keys()].map(parseRegistryKey)
+    datasets: () => [...registry.keys()].map(parseRegistryKey),
+    stub: (name, handler) => {
+      backend.stubs.set(name, handler);
+    },
+    stubs: () => Object.fromEntries(backend.stubs),
+    mutations: () => backend.log.flatMap((entry) => entry.mutations),
+    transactions: () => [...backend.log],
+    clearLog: () => {
+      backend.log.length = 0;
+    },
+    calls: (method) => method === void 0 ? [...backend.calls] : backend.calls.filter((c) => c.method === method),
+    callCount: (method) => method === void 0 ? backend.calls.length : backend.calls.filter((c) => c.method === method).length,
+    clearCalls: () => {
+      backend.calls.length = 0;
+    }
   };
+  return wrapWithGuards(client, {
+    getStub: (name) => backend.stubs.get(name),
+    onCall: (method, args) => {
+      const rec = { method, args, projectId, dataset };
+      return backend.calls.push(rec), (outcome) => {
+        "error" in outcome ? rec.error = outcome.error : rec.result = outcome.result;
+      };
+    },
+    recorded: RECORDED_METHODS
+  });
 }
 export {
+  ERR_PREFIX,
+  SUPPORTED_SURFACE,
+  UNSUPPORTED_MEMBERS,
   WriteAccessDeniedError,
   applyPatchOps,
+  applyPerspective,
   createPatch,
   createTestClient,
   createTestStore,
   createTransaction,
   defaultAclPath,
-  evaluateWriteAccess
+  evaluateWriteAccess,
+  fakeError,
+  isDraftId,
+  isReleaseDocId,
+  isSystemId,
+  isVersionId,
+  publishedIdOf,
+  releaseNameOf,
+  wrapWithGuards
 };
 //# sourceMappingURL=index.js.map