Play edits under a machine-wide per-package lock (parallel reads of one app no longer delete each other's edits; a read whose edit was deleted is redone once, writes are not); a store that failed to read is 'Couldn't read Google Play' and keeps its last good releases with 'couldn't refresh'; stores on different versions: neutral 'Current · Play x · App Store y' header and each lane its own state, 'Not on this store' only without a record; Play status decided from the public store page's live version (Live / In review / In review (live: x) / managed publishing / Rolling out / Halted / Draft; only a network failure says 'Couldn't check the store page', with the last known answer and its time); tests/play-edit-lock.test.ts, recorded page fixture, boot check auto-read cases (pitfall 58)

cli/play/client.ts

@@ -6,6 +6,10 @@ import { errorBody } from '../lib/http';
 import { noteGoogle } from '../lib/quota';
 import { AmbiguousWriteError, isAmbiguous, retrySafe } from '../lib/upsert';
 import * as rt from '../lib/rt';
+import { withMachineLock } from '../lib/lock';
+
+/** A read's edit is gone: replaced by a newer edit of the app, committed elsewhere or expired. */
+export const EDIT_GONE = /Edit has been deleted|editAlreadyCommitted|already been committed|edit.*(expired|not found)|outside of this Edit/i;
 
 export type PlayClient = Awaited<ReturnType<typeof playClient>>;
 
@@ -101,6 +105,11 @@ export async function playClient(root: string, packageName: string) {
     }
   }
 
+  /** Google keeps one open edit per app; every edit (read or write) of this package, in any storebound process on
+   *  this machine, runs under one lock (cli/lib/lock.ts), so parallel reads never delete each other's edits. */
+  const locked = <T>(what: string, fn: () => Promise<T>, timeoutMs: number): Promise<T> =>
+    withMachineLock(`play-edit-${packageName}`, `play ${what} ${packageName}`, fn, { timeoutMs, onWait: m => log('play', m) });
+
   return {
     API, UPLOAD, packageName, call,
     /**
@@ -108,8 +117,16 @@ export async function playClient(root: string, packageName: string) {
      * A failed delete is reported (Play drops an unused edit on its own after a while, but it should not linger).
      */
     async read<T>(fn: (id: string) => Promise<T>): Promise<T> {
-      const id = await openOne();
-      try { return await fn(id); } finally { await closeOne(id, 'read-only'); }
+      return locked('read', async () => {
+        for (let attempt = 0; ; attempt++) {
+          const id = await openOne();
+          try { return await fn(id); } catch (err) {
+            // the edit was replaced by another writer (Console, another tool) or expired: a read is safe to redo once
+            if (attempt === 0 && EDIT_GONE.test(String(err))) { log('play', `read edit ${id} was invalidated, reading again with a new edit`); continue; }
+            throw err;
+          } finally { await closeOne(id, 'read-only'); }
+        }
+      }, 90_000);
     },
     /**
      * Opens an edit, runs fn, then commits (or validates and discards when dry). Any Console save or other edit commit
@@ -117,6 +134,7 @@ export async function playClient(root: string, packageName: string) {
      * redone, up to `retries` times. Keep edits small (e.g. one per language for images) so a retry is cheap.
      */
     async edit<T>(fn: (id: string, ctl: EditCtl) => Promise<T>, o: { dry?: boolean; commitQuery?: string; retries?: number } = {}): Promise<T> {
+      return locked(o.dry ? 'dry edit' : 'edit', async () => {
       for (let left = o.retries ?? 3; ; left--) {
         try { return await editOnce(fn, o); } catch (err) {
           // redo only what never went live: an edit invalidated before or at its commit, or a request inside the edit
@@ -127,6 +145,7 @@ export async function playClient(root: string, packageName: string) {
           log('play', `${outside ? 'app changed outside the edit (Console?)' : 'a request got no clear answer; the edit was discarded'}, redoing it (${left} retries left)`);
         }
       }
+      }, 10 * 60_000);
     },
   };
 }