@homie-rocks/studio 0.51.5 → 0.51.7

package/lib/app-needs.mjs

@@ -1,7 +1,8 @@
-import {waitInApp} from './app-ready.mjs';
+import {actInApp,waitInApp} from './app-ready.mjs';
 /** Opt-in acceptance evidence, sourced from the person's Codex, not starter labels. */
-import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, copyFileSync, realpathSync } from 'node:fs';
+import { join, resolve, relative, isAbsolute, basename } from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
 import { createHash } from 'node:crypto';
 
 export function readAppNeeds(root, id) {
@@ -22,30 +23,38 @@ export function readAppNeeds(root, id) {
 }
 
 /** Run real UI actions. A failed or absent flow stays visible; continue collecting other needs. */
-export async function proveAppNeeds({ plan, surfaces, shots, report, ready = async () => {} }) {
+export async function proveAppNeeds({ plan, surfaces, shots, report, ready = async () => {}, root, headless }) {
   const results = [];
   const appBarrier=ready;
-  ready=async s=>{await s.page.bringToFront?.();if(s.external){s.frame=s.page.mainFrame();return;}await appBarrier(s);};
+  ready=async (s,options)=>{await s.page.bringToFront?.();if(s.external){s.frame=s.page.mainFrame();return;}await appBarrier(s,options);};
   let activeRole;
   const surface = name => { const s = surfaces.find(s => s.name === name && (!activeRole || s.role === activeRole)) ?? surfaces.find(s => s.name === name); if (!s) throw new Error(`unknown surface ${name}`); return s; };
   for (const need of plan.needs) {
     activeRole = need.role;
-    const names = [...new Set([...(need.steps ?? []), ...(need.assertions ?? [])].map(s => s.surface))];
+    const names = [...new Set([...(need.steps ?? []), ...(need.assertions ?? [])].map(s => s.surface).filter(Boolean))];
+    const saved = new Map();
+    const run = async item => { if (!headless) throw new Error('headless MCP proof requires local dev and its test credential'); return headless(item,item.role ?? need.role); };
     let waiting = 'validating assertions';
     const result = { id: need.id, statement: need.statement, status: 'not', captures: [] };
     try {
-      if (!Array.isArray(need.assertions) || !need.assertions.length) throw new Error('need requires assertions on its named surfaces');
+      if (!Array.isArray(need.assertions) || !need.assertions.length) throw new Error('need requires at least one assertion (UI, result, records or file)');
       const popupNames=new Set((need.steps??[]).map(s=>s.popup).filter(Boolean));
       for (const name of names) { if(popupNames.has(name))continue; const s = surface(name); if (need.role && s.role !== need.role) throw new Error(`${name} requires role ${need.role}, got ${s.role ?? 'unspecified'}`); }
       for (const name of new Set(need.assertions.filter(a => a.effect).map(a => a.surface))) await surface(name).frame.evaluate(() => { window.__homieNeedsEffects = []; });
-      for (const step of need.steps ?? []) {
+      for (const rawStep of need.steps ?? []) {
+        const step=resolveNeedResults(rawStep,saved);
+        if (step.mcp || step.schedule) {
+          waiting = step.mcp ? `MCP ${step.mcp.tool ?? step.mcp.method} as ${step.role ?? need.role ?? 'unspecified'}` : `schedule ${step.schedule.name}`;
+          const value = await run(step);
+          if (step.save) { if(saved.has(step.save))throw new Error(`duplicate saved result ${step.save}`); saved.set(step.save,value); }
+          continue;
+        }
         const target=surface(step.surface);
         if(!step.reload)await ready(target);
         const { page } = target;
         waiting = `${step.surface}: ${step.reload ? 'reload and arrival readiness' : step.selector}`;
         if (step.reload) { await page.reload({ waitUntil: 'domcontentloaded' }); await ready(surface(step.surface)); continue; }
-        await waitInApp(target,step.selector,f=>f.waitForSelector(step.selector, { visible: true, timeout:10000 }),{ready});
-        const frame=target.frame;
+        const act = fn => actInApp(target,step.selector,fn,{ready});
         if (step.click && step.popup) {
           let listener,timer;
           const opened=new Promise((resolve,reject)=>{
@@ -53,17 +62,42 @@ export async function proveAppNeeds({ plan, surfaces, shots, report, ready = asy
             timer=setTimeout(()=>reject(new Error('payment popup did not open')),10000);
           });
           try {
-            const [popup]=await Promise.all([opened,frame.click(step.selector)]);
+            const [popup]=await Promise.all([opened,act(frame=>frame.click(step.selector))]);
             surfaces.push({name:step.popup,page:popup,frame:popup.mainFrame(),external:true,role:target.role});
             await page.bringToFront();
           } finally {clearTimeout(timer);page.off('popup',listener);}
         }
-        else if (step.click) {await frame.click(step.selector);await page.bringToFront?.();}
-        else if (step.fill !== undefined) { await frame.$eval(step.selector, el => { el.value = ''; el.dispatchEvent(new Event('input', { bubbles: true })); }); await frame.type(step.selector, String(step.fill)); }
-        else if (step.select !== undefined) await frame.select(step.selector, String(step.select));
+        else if (step.click) {await act(frame=>frame.click(step.selector));await page.bringToFront?.();}
+        else if (step.fill !== undefined) { await act(async frame=>{ await frame.$eval(step.selector, el => { el.value = ''; el.dispatchEvent(new Event('input', { bubbles: true })); }); await frame.type(step.selector, String(step.fill)); }); }
+        else if (step.select !== undefined) await act(frame=>frame.select(step.selector, String(step.select)));
         else throw new Error('step needs click, fill, select or reload');
       }
-      for (const assertion of need.assertions) {
+      for (const rawAssertion of need.assertions) {
+        const assertion=resolveNeedResults(rawAssertion,saved);
+        if (assertion.result || assertion.records || assertion.file || assertion.mcp) {
+          waiting = assertion.file ? `file ${assertion.file}` : assertion.result ? `result ${assertion.result}${assertion.path ? '.'+assertion.path : ''}` : assertion.records ? `records ${assertion.records.collection}` : `MCP ${assertion.mcp.tool ?? assertion.mcp.method}`;
+          let value;
+          if (assertion.file) {
+            if (!root) throw new Error('file proof requires the studio root');
+            const file=resolve(root,assertion.file), rel=relative(resolve(root),file);
+            if(rel.startsWith('..') || isAbsolute(rel))throw new Error('handover file must be inside the studio');
+            value=readFileSync(file,'utf8');
+          } else if (assertion.result) {
+            if(!saved.has(assertion.result))throw new Error(`no saved result ${assertion.result}; add save to its step`);
+            value=saved.get(assertion.result);
+          } else {
+            const waitMs=assertion.waitMs??0;
+            if(!Number.isInteger(waitMs)||waitMs<0||waitMs>10000)throw new Error('waitMs must be an integer from 0 to 10000');
+            const end=Date.now()+waitMs;
+            for(;;) {
+              value=await run(assertion);
+              try {assertNeedValue(value,assertion);break;}
+              catch(error){if(Date.now()>=end)throw error;await new Promise(resolve=>setTimeout(resolve,100));}
+            }
+          }
+          assertNeedValue(value,assertion);
+          continue;
+        }
         waiting = `${assertion.surface}: ${assertion.effect ? assertion.effect + ' ' + (assertion.name ?? '') : assertion.selector + (assertion.text === undefined ? '' : ' containing ' + JSON.stringify(assertion.text))}`;
         const target=surface(assertion.surface);
         await ready(target);
@@ -77,13 +111,14 @@ export async function proveAppNeeds({ plan, surfaces, shots, report, ready = asy
         if (assertion.text !== undefined) await frame.waitForFunction((selector, text) => document.querySelector(selector)?.textContent.includes(text), { timeout: 10000 }, assertion.selector, String(assertion.text));
         },{ready});
       }
-      result.status = shots ? 'met' : 'partly';
-      result.why = shots ? 'UI assertions passed; inspect captures against the pictured scene' : 'Assertions passed but no captures saved';
+      result.status = 'met';
+      result.why = 'Assertions passed';
     } catch (error) { result.why = `Waiting for ${waiting}: ${error.message}`; }
+    if (!shots) for (const name of names) result.why += `; ${name} capture not requested: rerun check with --shots .checks and inspect the scene`;
     if (shots) for (const name of names) {
       const file = join(shots, `${need.id}-${name}.jpg`);
-      try { await ready(surface(name)); await surface(name).page.screenshot({ path: file, type: 'jpeg', quality: 85 }); result.captures.push(file); }
-      catch (error) { if (result.status === 'met') result.status = 'partly'; result.why += `; capture failed: ${error.message}`; }
+      try { mkdirSync(shots,{recursive:true}); await ready(surface(name)); await surface(name).page.screenshot({ path: file, type: 'jpeg', quality: 85 }); result.captures.push(file); }
+      catch (error) { result.why += `; ${name} capture failed: ${error.message}. Resolve this capture error and rerun check with --shots .checks`;  }
     }
     report?.check?.(`need-${need.id}`, result.status === 'met' ? 'pass' : 'fail', { label: need.statement, note: result.why });
     results.push(result);
@@ -94,5 +129,44 @@ export async function proveAppNeeds({ plan, surfaces, shots, report, ready = asy
 export function saveAppNeeds(root, id, plan, needs) {
   if (!root) return;
   const dir = join(root, '.studio', 'checks'); mkdirSync(dir, { recursive: true });
+  needs=needs.map(need=>({...need,captures:(need.captures??[]).map(file=>{
+    const source=realpathSync(resolve(root,file)),rel=relative(realpathSync(root),source);
+    if(!rel.startsWith('..')&&!isAbsolute(rel))return rel;
+    const target=join(dir,`${id}-${createHash('sha256').update(source).digest('hex').slice(0,12)}-${basename(source)}`);
+    copyFileSync(source,target);return relative(root,target);
+  })}));
   writeFileSync(join(dir, `${id}-needs.json`), JSON.stringify({ at: new Date().toISOString(), codexHash: plan.hash, needs }, null, 2));
 }
+
+/** Partial structured matching: object keys must match; each expected array entry must occur. */
+export function containsValue(actual, expected) {
+  if (typeof expected === 'string') return typeof actual === 'string' && actual.includes(expected);
+  if (Array.isArray(expected)) return Array.isArray(actual) && expected.every(e=>actual.some(a=>containsValue(a,e)));
+  if (expected && typeof expected === 'object') return actual !== null && typeof actual === 'object' && Object.entries(expected).every(([k,v])=>Object.hasOwn(actual,k)&&containsValue(actual[k],v));
+  return isDeepStrictEqual(actual,expected);
+}
+export function assertNeedValue(value, assertion) {
+  if(assertion.path) for(const key of assertion.path.split('.')) value=value!=null&&Object.hasOwn(Object(value),key)?value[key]:undefined;
+  if(value === undefined)throw new Error('value does not exist');
+  if(Object.hasOwn(assertion,'equals')&&!isDeepStrictEqual(value,assertion.equals))throw new Error(`expected equals ${JSON.stringify(assertion.equals)}; got ${JSON.stringify(value)}`);
+  if(Object.hasOwn(assertion,'contains')&&!containsValue(value,assertion.contains))throw new Error(`expected contains ${JSON.stringify(assertion.contains)}; got ${JSON.stringify(value)}`);
+  if(assertion.text!==undefined)for(const text of [].concat(assertion.text))if(typeof value!=='string'||!value.includes(String(text)))throw new Error(`expected text ${JSON.stringify(text)}`);
+  if(!assertion.file&&!Object.hasOwn(assertion,'equals')&&!Object.hasOwn(assertion,'contains')&&assertion.text===undefined)throw new Error('result/records assertion requires equals, contains or text');
+}
+
+/** Explicit result references never evaluate code or interpolate arbitrary strings. */
+export function resolveNeedResults(value,saved) {
+  if(Array.isArray(value))return value.map(v=>resolveNeedResults(v,saved));
+  if(value && typeof value==='object') {
+    if(Object.keys(value).length===1 && typeof value.$result==='string') {
+      const [name,...path]=value.$result.split('.');
+      if(!saved.has(name))throw new Error(`no saved result ${name}`);
+      let result=saved.get(name);
+      for(const key of path)result=result!=null&&Object.hasOwn(Object(result),key)?result[key]:undefined;
+      if(result===undefined)throw new Error(`saved result path ${value.$result} does not exist`);
+      return result;
+    }
+    return Object.fromEntries(Object.entries(value).map(([key,v])=>[key,resolveNeedResults(v,saved)]));
+  }
+  return value;
+}

package/lib/app-ready.mjs

@@ -48,3 +48,24 @@ export function answerDialogs(page,surface,dialogs,report) {
   await dialog.accept().catch(()=>{});
  });
 }
+
+/** Retry only errors identifying a detached element, never an ambiguous navigation after dispatch. */
+export async function actInApp(surface, selector, action, {ready=appReady,timeout=10000}={}) {
+  const end=Date.now()+timeout;
+  let stale;
+  for (;;) {
+    try {
+      await waitInApp(surface,selector,frame=>frame.waitForSelector(selector,{visible:true,timeout:Math.max(1,end-Date.now())}),{ready,timeout:Math.max(1,end-Date.now())});
+      return await action(surface.frame);
+    } catch(error) {
+      if(!/node is detached|element.*(?:detach|stale)|stale.*element/i.test(error.message)) {
+        if(stale && Date.now()>=end)throw new Error(`${surface.name}: stale element ${selector} never settled within ${timeout}ms: ${error.message}`);
+        throw error;
+      }
+      stale=error;
+      if(Date.now()>=end)throw new Error(`${surface.name}: stale element ${selector} never settled within ${timeout}ms: ${error.message}`);
+      await new Promise(resolve=>setTimeout(resolve,Math.min(50,Math.max(1,end-Date.now()))));
+      await ready(surface,{timeout:Math.max(1,end-Date.now())});
+    }
+  }
+}

package/lib/check.mjs

@@ -1,5 +1,6 @@
+import {needsHeadless} from './needs-headless.mjs';
 import {randomBytes} from 'node:crypto';
-import {appReady,observeEffects,waitInApp,answerDialogs} from './app-ready.mjs';
+import {actInApp,appReady,observeEffects,waitInApp,answerDialogs} from './app-ready.mjs';
 import {localCredential,localCookie} from './local-test.mjs';
 import { readAppNeeds, proveAppNeeds, saveAppNeeds } from './app-needs.mjs';
 /**
@@ -148,6 +149,12 @@ export async function check({ isolate = true, root = null, url, game, roundTimeo
     if (meta?.rulesError) return { ok: false, command: 'check', why: meta.rulesError };
     if (meta?.kind === 'app') appMeta = meta;
   } catch { /* browser preflight below still names failures */ }
+  if(appMeta && !appMeta.check?.action) {
+    try {
+      const plan=readAppNeeds(root,game);
+      if(plan && !plan.needs.some(n=>[...(n.steps??[]),...(n.assertions??[])].some(i=>i.surface)))return checkApp({isolate,root,url:base,game,meta:appMeta,shots,log,report});
+    } catch(error) {return {ok:false,command:'check',kind:'app',why:error.message};}
+  }
   const chrome = findChrome();
   if (!chrome) return { ok: false, command: 'check', why: noChrome() };
   let puppeteer;
@@ -357,13 +364,13 @@ export async function checkApp({ isolate = true, root = null, url, game, meta, s
   const proof = meta.check??{};
   const baseline=typeof proof.action==='string'&&typeof proof.observe==='string';
   if (!baseline && !plan) return { ok: false, command: 'check', kind: 'app', why: 'app.json check needs action and observe CSS selectors for a real shared action' };
-  if (shots) mkdirSync(shots, { recursive: true });
+  const captureWarnings=[];
   const profile = mkdtempSync(join(tmpdir(), 'homie-app-check-'));
   let browser;
   const surfaces = [];
   const room = `check-${randomBytes(10).toString('hex')}`;
   try {
-    browser = await puppeteer.launch({ executablePath: chrome, headless: true, userDataDir: profile, timeout: LAUNCH_TIMEOUT_MS, args: chromeArgs() });
+    if(baseline || plan?.needs.some(n=>[...(n.steps??[]),...(n.assertions??[])].some(i=>i.surface))) browser = await puppeteer.launch({ executablePath: chrome, headless: true, userDataDir: profile, timeout: LAUNCH_TIMEOUT_MS, args: chromeArgs() });
     const openSurface = async (name, role) => {
       const dimensions={wall:[1280,720],phone:[390,844],'phone-two':[390,844],tablet:[1024,768],staff:[1024,768],kiosk:[1080,1920]};
       if(!dimensions[name])throw new Error(`Unknown needs surface ${name}`);
@@ -390,7 +397,7 @@ export async function checkApp({ isolate = true, root = null, url, game, meta, s
     await appReady(actor);
     await waitInApp(actor,proof.action,f=>f.waitForFunction((selector) => { const el = document.querySelector(selector); return el && !el.disabled && !el.hidden; }, {}, proof.action));
     before = await waitInApp(actor,proof.observe,textOf);
-    await actor.frame.click(proof.action);
+    await actInApp(actor,proof.action,f=>f.click(proof.action));
     await waitInApp(actor,proof.observe+' changes after action',f=>f.waitForFunction((selector, was) => document.querySelector(selector)?.textContent !== was, {}, proof.observe, before));
     after = await waitInApp(actor,proof.observe,textOf);
     for (const s of surfaces) await waitInApp(s,proof.observe+' equals '+after,f=>f.waitForFunction((selector, wanted) => document.querySelector(selector)?.textContent === wanted, {}, proof.observe, after));
@@ -402,19 +409,21 @@ export async function checkApp({ isolate = true, root = null, url, game, meta, s
     if (rooms.some((r) => r !== room)) throw new Error('surfaces did not retain the same room');
     for (const s of surfaces) {
       await appReady(s);
-      if (shots) await s.page.screenshot({ path: join(shots, `${s.name}.jpg`), type: 'jpeg', quality: 85 });
+      if (shots) try {mkdirSync(shots,{recursive:true});await s.page.screenshot({ path: join(shots, `${s.name}.jpg`), type: 'jpeg', quality: 85 });}
+      catch(error){const warning=`${s.name} capture failed: ${error.message}. Resolve this capture error and rerun check with --shots .checks`;captureWarnings.push(warning);log(warning);}
     }
     report?.check?.('app-action', 'pass', { note: 'action reached wall and both phones; reconnect retained it' });
     }
     for(const need of plan?.needs??[])for(const item of [...(need.steps??[]),...(need.assertions??[])]) {
+      if(!item.surface)continue;
       if(plan.needs.some(n=>(n.steps??[]).some(s=>s.popup===item.surface)))continue;
       const role=item.role??need.role??meta.surfaces?.[item.surface]??(item.surface==='staff'?'staff':undefined);
       if(!surfaces.some(s=>s.name===item.surface&&s.role===role))await openSurface(item.surface,role);
     }
-    const needs = plan ? await proveAppNeeds({ plan, surfaces, shots, report, ready:appReady }) : null;
+    const needs = plan ? await proveAppNeeds({ plan, surfaces, shots, report, ready:appReady, root, headless:needsHeadless({url,secret,app:game,meta,scope:isolate?room:null}) }) : null;
     if (plan) { saveAppNeeds(root, game, plan, needs); const { refreshCodexFile } = await import('./codex.mjs'); refreshCodexFile(root, game); }
     const ok = !needs || needs.every(n => n.status === 'met');
-    return { ok, ...(needs ? { needs, why: ok ? undefined : 'Some needs from the person’s Codex are not yet met; see needs and captures' } : {}), command: 'check', kind: 'app', isolatedRecords:isolate, dialogs, room, surfaces: surfaces.map((s) => s.name), action: proof.action, before, after, reconnect: baseline };
+    return { ok, ...(needs ? { needs, why: ok ? undefined : 'Some needs from the person’s Codex are not yet met; see needs and captures' } : {}), command: 'check', kind: 'app', isolatedRecords:isolate, captureWarnings, dialogs, room, surfaces: surfaces.map((s) => s.name), action: proof.action, before, after, reconnect: baseline };
   } catch (error) { return { ok: false, command: 'check', kind: 'app', dialogs, why: error.message }; }
   finally { await browser?.close().catch(() => {}); rmSync(profile, { recursive: true, force: true }); }
 }

package/lib/cloudflare.mjs

@@ -435,7 +435,7 @@ async function deployLocked(root, { log = () => {}, homie, fetchFn = null, ownRo
   if (url) {
     const read = await readLiveSite(url, fetchFn ? { fetchFn } : {});
     claim = read.claim;
-    if (claim) step('the site claimed itself in the directory');
+    if (claim) step(listedHere(root,{site:url})?'the site is listed':'the site is claimed, not listed');
     else if (read.state === 'other' && !isWorkersDev(url)) {
       // The studio's own domain answered as something else: say which route is needed (lib/routes.mjs). The deploy
       // itself went through; the zone's other routes are never touched.
@@ -486,7 +486,7 @@ async function deployLocked(root, { log = () => {}, homie, fetchFn = null, ownRo
     ...(reread ? { reread } : {}),
     songs: b.songs.map((slug) => ({ slug, page: url ? `${url}/music/${slug}/` : null })),
     videos: b.videos.map((slug) => ({ slug, page: url ? `${url}/videos/${slug}/` : null })),
-    claim: Boolean(claim), directory,
+    claim: Boolean(claim), listing: listedHere(root,{site:url}) ? 'listed' : claim ? 'claimed, not listed' : 'not listed', directory,
   };
 }
 
@@ -638,7 +638,7 @@ export async function ciDeploy(root, { log = () => {} } = {}) {
   let url = null;
   try { url = siteUrl(root) ?? workersDev; } catch { url = workersDev; }
   const claim = url ? await warmClaim(url) : null;
-  step(claim ? 'the site claimed itself in the directory' : 'no directory claim yet (the site claims itself when the directory first reads it)');
+  step(claim ? (listedHere(root,{site:url})?'the site is listed':'the site is claimed, not listed') : 'no directory claim yet (the site claims itself when the directory first reads it)');
   let games = [];
   try { games = JSON.parse(readFileSync(join(root, 'site', 'dist', 'games.json'), 'utf8')).games.map((g) => g.id); } catch { games = []; }
   const hashes = builtGames(root, games);
@@ -648,7 +648,7 @@ export async function ciDeploy(root, { log = () => {} } = {}) {
     commit: process.env.WORKERS_CI_COMMIT_SHA ?? null, branch: process.env.WORKERS_CI_BRANCH ?? null,
     // A CI checkout has no earlier deploy to compare with: each game's content hash only (lib/deploy-state.mjs).
     games: games.map((id) => ({ id, page: url ? `${url}/${id}/` : null, ...experienceAddresses(root, id, url), hash: hashes[id]?.hash ?? null })), songs: [], videos: [],
-    claim: Boolean(claim),
+    claim: Boolean(claim), listing: listedHere(root,{site:url}) ? 'listed' : claim ? 'claimed, not listed' : 'not listed',
   };
 }
 

package/lib/codex.mjs

@@ -318,7 +318,7 @@ function sectionHtml(section, emb, ctx) {
     if (block) {
       try {
         const needs = JSON.parse(block[1]);
-        if (Array.isArray(needs)) return `<section class="tab" id="${esc(section.id)}" data-key="needs"><h2>${esc(section.title)}</h2>${renderMarkdown(source.replace(block[0], '')).html}<div class="cards">${needs.map(n => `<article class="card"><h3>${esc(n.id)}</h3><p>${esc(n.statement)}</p><p class="meta">${Array.isArray(n.assertions) && n.assertions.length ? 'To demonstrate on the wall and phone' : 'Not yet demonstrable'}</p></article>`).join('')}</div></section>`;
+        if (Array.isArray(needs)) return `<section class="tab" id="${esc(section.id)}" data-key="needs"><h2>${esc(section.title)}</h2>${renderMarkdown(source.replace(block[0], '')).html}<div class="cards">${needs.map(n => `<article class="card"><h3>${esc(n.id)}</h3><p>${esc(n.statement)}</p><p class="meta">${Array.isArray(n.assertions) && n.assertions.length ? 'To demonstrate with check' : 'Not yet demonstrable'}</p></article>`).join('')}</div></section>`;
       } catch { /* Keep malformed source visible for correction. */ }
     }
   }
@@ -582,7 +582,7 @@ export function renderCodex(root, id, { mode = 'file', feed, now = new Date() }
       const r = JSON.parse(readFileSync(needReportFile, 'utf8'));
       const stale = r.codexHash !== createHash('sha256').update(readFileSync(file, 'utf8')).digest('hex');
       tabs.push('<a href="#needs-status">Needs status</a>');
-      needStatus = `<section class="tab" id="needs-status"><h2>Needs status</h2><p>${stale ? 'Plan changed: this evidence is stale; check again. ' : ''}Checked ${esc(r.at)}. Screen assertions are evidence; review the captures against Their words.</p>${r.needs.map(n => `<article><h3>${esc(n.statement)}</h3><p><strong>${stale ? 'not yet rechecked' : esc(n.status)}</strong> — ${esc(n.why ?? '')}</p>${(n.captures ?? []).map(p => figure(emb, n.statement, relative(root, resolve(root, p)), p)).join('')}</article>`).join('')}</section>`;
+      needStatus = `<section class="tab" id="needs-status"><h2>Needs status</h2><p>${stale ? 'Plan changed: this evidence is stale; check again. ' : ''}Checked ${esc(r.at)}. Assertions are evidence; review available captures against Their words.</p>${r.needs.map(n => `<article><h3>${esc(n.statement)}</h3><p><strong>${stale ? 'not yet rechecked' : esc(n.status)}</strong> — ${esc(n.why ?? '')}</p>${(n.captures ?? []).map(p => figure(emb, n.statement, relative(root, resolve(root, p)), p)).join('')}</article>`).join('')}</section>`;
     } catch { /* The next check repairs an incomplete receipt. */ }
   }
   const body = needStatus + sections.map((x) => sectionHtml(x, emb, ctx)).join('\n');
@@ -772,9 +772,11 @@ try: "Open the wall and phone. Follow a real request through the scene."
 <!-- What is sold or given, price and currency, once/monthly, and what payment fulfils. -->
 
 ## Needs
-<!-- Each statement is observable on a real screen. Fill this executable needs block.
-Each need: id, statement, steps (surface wall/phone/phone-two; click/fill/select and selector/value),
-assertions (surface, selector, optional text). Include wall and phone assertions and real flow steps.
+<!-- Each owner statement belongs in this executable needs block.
+Each need: id, statement, optional role, steps and assertions. UI: surface/selector with
+click/fill/select/reload; headless: mcp tool/arguments + save, or schedule name/at.
+Assert UI selectors, saved result/path/equals/contains, records, or file/text.
+See node_modules/@homie-rocks/studio/guides/app/NEEDS.md for complete examples.
 A missing flow is reported not met. Do not replace an unmet need with an easier one. -->
 \`\`\`needs
 []

package/lib/mcp-tools.mjs

@@ -1178,7 +1178,7 @@ export function toolDefs(ctx, avail = {}) {
     },
     {
       name: 'stripe_shop_plan', title: 'Plan or verify the Stripe shop',
-      description: 'Default setup with Stripe official MCP. Supply public API observations as {path,params,body}, account ID, mode, and complete booking slots. Returns the exact next read/write with metadata and idempotency. Execute via Stripe stripe_api_search/details/read/write, clear observations after writes, repeat until verified. verify:true saves the public config for stripe_webhook. Never pass webhook creation responses or secrets.',
+      description: 'Default setup with Stripe official MCP. Supply public API observations as {method,path,params,body}, account ID, mode, and complete booking slots. Returns every independent operation in a dependency-ordered batch, with metadata and idempotency. Execute via Stripe stripe_api_search/details/read/write, retain write responses as observations and replan until verified. verify:true saves compact public config for deploy and stripe_webhook. Never pass webhook creation responses or secrets.',
       inputSchema: {type:'object',properties:{...STUDIO_ARG,account:{type:'string'},mode:{enum:['test','live']},url:{type:'string'},slots:{type:'array',items:{type:'object'}},observations:{type:'array',items:{type:'object'}},verify:{type:'boolean'}}},
       annotations:{readOnlyHint:false,destructiveHint:false,openWorldHint:false},
       run:async a=>{

package/lib/needs-headless.mjs

@@ -0,0 +1,34 @@
+import {localCookie} from './local-test.mjs';
+
+/** Each action has an explicit local identity, using the real MCP transport and permissions. */
+export function needsHeadless({url,secret,app,meta,scope}) {
+  return async (item,role) => {
+    if(!secret)throw new Error('Headless role proof requires homie-studio dev in this studio and its localhost URL');
+    if(!role || (role!=='owner'&&!Object.hasOwn(meta.roles??{},role)))throw new Error(`Name a declared role (or owner) for headless proof; got ${role??'none'}`);
+    const {Client,StreamableHTTPClientTransport}=await import('mcp-studio-client');
+    const client=new Client({name:'Homie needs check',version:'1.0.0'});
+    const transport=new StreamableHTTPClientTransport(new URL('/mcp',url),{requestInit:{headers:{authorization:`Bearer ${secret}`,cookie:`homie_test=${localCookie(secret,{app,role,scope})}`}}});
+    try {
+      await client.connect(transport);
+      let call=item.mcp;
+      if(item.records)call={tool:'app_records',arguments:{...item.records,app,role,operation:'read'}};
+      if(item.schedule)call={tool:'studio_schedule_fire',arguments:item.schedule};
+      if(call?.method) {
+        if(call.method==='resources/read')return await client.readResource(call.params);
+        // The extension's JSON-RPC result is intentionally preserved for path assertions.
+        if(['events/list','events/poll'].includes(call.method)) {
+          const {z}=await import('zod');
+          return await client.request({method:call.method,params:call.params??{}},z.object({}).passthrough(),{timeout:10000});
+        }
+        throw new Error(`Unsupported MCP proof method ${call.method}; use tools, resources/read, events/list or events/poll`);
+      }
+      if(!call?.tool)throw new Error('MCP step requires tool and optional arguments');
+      const result=await client.callTool({name:call.tool,arguments:call.arguments??{}},undefined,{timeout:item.schedule?15000:10000});
+      if(result.isError)throw new Error(result.content?.filter(c=>c.type==='text').map(c=>c.text).join('; ')||'MCP tool failed');
+      if(result.structuredContent!==undefined)return result.structuredContent;
+      const content=result.content?.filter(c=>c.type==='text');
+      if(content?.length===1) {try {const parsed=JSON.parse(content[0].text);return parsed.kind==='untrusted-tool-data'?parsed.data:parsed;}catch{}}
+      return result;
+    } finally {await client.close();}
+  };
+}

package/lib/shop-links.mjs

@@ -7,7 +7,11 @@ import { HOOK_EVENTS, SHOP_HOOK_EVENTS } from './shop.mjs';
 const hash = (value) => createHash('sha256').update(JSON.stringify(value)).digest('hex');
 const same = (a, b) => Object.keys(a ?? {}).length === Object.keys(b).length && Object.entries(b).every(([k, v]) => a?.[k] === v);
 export const matchesFields = (actual, expected) => Array.isArray(expected) ? Array.isArray(actual) && actual.length === expected.length && expected.every((v,i)=>matchesFields(actual[i],v)) : expected && typeof expected === 'object' ? Object.entries(expected).every(([k,v]) => matchesFields(actual?.[k],v)) : actual === expected;
-export async function reconcilePaymentLinks({ api, shop, slug, site, mode, bookingSlots = [], verifyObjects = false }) {
+export async function reconcilePaymentLinks({ api, shop, slug, site, mode, bookingSlots = [], verifyObjects = false, scoped = false, knownLinks = [], knownPortal }) {
+  if(scoped) {
+    const transport=api;
+    api=(method,path,params={},idempotency)=>transport(method,path,method==='POST'&&path.startsWith('/v1/payment_links/')?{...params,expand:['line_items']}:params,idempotency);
+  }
   const list = async (path, params = {}) => {
     const all = []; let cursor;
     do {
@@ -20,13 +24,32 @@ export async function reconcilePaymentLinks({ api, shop, slug, site, mode, booki
     } while (cursor);
     return all;
   };
-  const products = await list('/v1/products');
-  const prices = await list('/v1/prices');
-  const links = await list('/v1/payment_links');
+  const parallel = async tasks => {
+    if(!scoped){const values=[];for(const task of tasks)values.push(await task());return values;}
+    const results = await Promise.allSettled(tasks.map(task=>task()));
+    const errors=results.filter(r=>r.status==='rejected').map(r=>r.reason);
+    const fatal=errors.find(e=>!e.next&&!e.operations);if(fatal)throw fatal;
+    if(errors.length)throw {operations:errors.flatMap(e=>e.operations??[e.next])};
+    return results.map(r=>r.value);
+  };
+  const search = async kind => {
+    const data=[];let page;
+    do {
+      const result=await api('GET',`/v1/${kind}/search`,{query:`metadata['homie']:'shop-links-v1' AND metadata['studio']:'${slug}' AND metadata['origin']:'${site}'`,limit:100,...(kind==='products'?{expand:['data.default_price']}:{}),...(page?{page}:{})});
+      if(!Array.isArray(result.data)||result.has_more&&!result.next_page||page&&result.next_page===page)throw new Error('Incomplete Stripe pagination');
+      data.push(...result.data);page=result.has_more?result.next_page:null;
+    }while(page);
+    return data;
+  };
+  const [products,prices,links]=await parallel([
+    ()=>scoped?search('products'):list('/v1/products'),
+    ()=>scoped?search('prices'):list('/v1/prices'),
+    ()=>scoped?parallel([...new Set(knownLinks)].map(id=>()=>api('GET',`/v1/payment_links/${id}`,{expand:['line_items']}))):list('/v1/payment_links'),
+  ]);
   const own = (o) => o.metadata?.homie === 'shop-links-v1' && o.metadata?.studio === slug && o.metadata?.origin === site;
   const verifyLink = async (link, params) => {
     if (!verifyObjects) return;
-    const actual=await api('GET',`/v1/payment_links/${link.id}`,{expand:['line_items']});
+    const actual=link.line_items?.data?link:await api('GET',`/v1/payment_links/${link.id}`,{expand:['line_items']});
     const normalized={...actual,line_items:actual.line_items?.data?.map(line=>({...line,price:line.price?.id??line.price}))};
     if(actual.id!==link.id || actual.active!==link.active || actual.url!==link.url || actual.line_items?.has_more===true || !matchesFields(actual.metadata,link.metadata) || !paymentLinkURL(actual.url) || !matchesFields(normalized,params)) throw new Error(`Stripe Payment Link ${link.id} differs from its planned fields. Restore its configuration through Stripe MCP before verifying.`);
   };
@@ -34,21 +57,26 @@ export async function reconcilePaymentLinks({ api, shop, slug, site, mode, booki
   const customText=shop.giving?.receiptText ? {custom_text:{submit:{message:shop.giving.receiptText}}} : {};
   const catalogPrices = new Map();
   const keepPrices = new Set(), keepLinks = new Set(), keepProducts = new Set();
-  for (const item of shop.items) {
+  await parallel(shop.items.map(item=>async()=>{
     const id = await productIdOf(slug, item.id);
     keepProducts.add(id);
     const metadata = { homie: 'shop-links-v1', studio: slug, origin: site };
     const fields = { name: item.name, description:item.blurb??'', tax_code: item.taxCode ?? defaultTaxCode(item), metadata, active: true };
-    let product = products.find((p) => p.id === id);
-    if (!product) product = await api('POST', '/v1/products', { id, ...fields }, `product-${hash(id)}`);
-    else if (!same(product.metadata, metadata) || product.name !== fields.name || (product.description ?? '') !== (fields.description ?? '') || (product.tax_code?.id ?? product.tax_code) !== fields.tax_code || !product.active) await api('POST', `/v1/products/${id}`, fields);
     // Omit an unset minimum: Stripe applies its settlement-currency floor itself.
     // https://docs.stripe.com/api/prices/create#create_price-custom_unit_amount-minimum
     const priceFields = { product: id, currency: shop.currency, ...(item.interval ? { recurring: { interval: item.interval } } : {}), tax_behavior: 'exclusive', ...(item.price === 'choose'
       ? { custom_unit_amount: { enabled: true, ...(item.min > 0 ? { minimum: item.min } : {}), ...(item.max !== null ? { maximum: item.max } : {}) } }
       : { unit_amount: item.price }) };
     const revision = hash(priceFields);
+    const createFields={...fields};if(!createFields.description)delete createFields.description;
+    let product = products.find(p=>p.id===id);
+    if(!product) {
+      const {product:_,...default_price_data}=priceFields;
+      product=await api('POST','/v1/products',{id,...createFields,...(scoped?{default_price_data:{...default_price_data,metadata:{...metadata,revision}},expand:['default_price']}:{})},`product-${hash(id)}`);
+    } else if (!same(product.metadata, metadata) || product.name !== fields.name || (product.description ?? '') !== fields.description || (product.tax_code?.id ?? product.tax_code) !== fields.tax_code || !product.active) await api('POST', `/v1/products/${id}`, fields);
+
     let price = prices.find((p) => own(p) && p.product === id && p.metadata?.revision === revision);
+    if(!price && product.default_price?.id && product.default_price.metadata?.revision===revision)price=product.default_price;
     if (!price) price = await api('POST', '/v1/prices', { ...priceFields, metadata: { ...metadata, revision } }, `price-${hash({ priceFields, metadata })}`);
     if (verifyObjects && ((price.recurring?.interval_count??1)!==1 || Boolean(price.recurring)!==Boolean(item.interval) || Boolean(price.custom_unit_amount)!==(item.price==='choose'))) throw new Error(`Stripe Price ${price.id} has a different payment type from shop.json`);
     if (verifyObjects && !matchesFields({...price, product:price.product?.id??price.product, ...(price.custom_unit_amount?{custom_unit_amount:{...price.custom_unit_amount,enabled:true}}:{})},priceFields)) throw new Error(`Stripe Price ${price.id} differs from shop.json; restore or archive it through Stripe MCP before planning again.`);
@@ -56,7 +84,7 @@ export async function reconcilePaymentLinks({ api, shop, slug, site, mode, booki
     keepPrices.add(price.id);
     catalogPrices.set(item.id, price.id);
     if ((product.default_price?.id ?? product.default_price) !== price.id) await api('POST', `/v1/products/${id}`, { default_price: price.id });
-    if (item.price === 0) continue; // Free orders never leave the studio.
+    if (item.price === 0) return; // Free orders never leave the studio.
     const params = { ...customText, line_items: [{ price: price.id, quantity: 1, ...(item.price !== 'choose' ? { adjustable_quantity: { enabled: shop.policy.repeatPurchases, minimum: 1, maximum: 999999 } } : {}) }],
       after_completion: { type: 'redirect', redirect: { url: `${site}/shop/thanks?session_id={CHECKOUT_SESSION_ID}` } },
       ...(shop.till === 'stripe-managed' ? { managed_payments: { enabled: true } } : { automatic_tax: { enabled: shop.automaticTax } }),
@@ -64,35 +92,68 @@ export async function reconcilePaymentLinks({ api, shop, slug, site, mode, booki
     };
     const linkRevision = hash({ params, item, policy: shop.policy });
     let link = links.find((p) => own(p) && p.metadata?.revision === linkRevision);
-    if (!link) link = await api('POST', '/v1/payment_links', { ...params, metadata: { ...metadata, revision: linkRevision } }, `link-${linkRevision}`);
+    if (!link) link = await api('POST', '/v1/payment_links', { ...params, ...(scoped?{expand:['line_items']}:{}), metadata: { ...metadata, revision: linkRevision } }, `link-${linkRevision}`);
     await verifyLink(link,params);
     if (!link.active) await api('POST', `/v1/payment_links/${link.id}`, { active: true });
     if (!paymentLinkURL(link.url) || !/^plink_\w+$/.test(link.id)) throw new Error('Invalid Payment Link');
     keepLinks.add(link.id);
     config.items.push({ item: item.id, id: link.id, url: link.url, price: price.id, revision: linkRevision });
-  }
+  }));
   // Menus use paid invoice snapshots: Checkout events omit their line items.
   // Stripe allows 20 Payment Link lines; invoice snapshots include only the first
   // 10. Split catalogues so keyless fulfillment needs no authenticated pagination.
   config.menus = [];
   const menuItems = shop.items.filter(i => typeof i.price === 'number' && i.price > 0 && !i.interval);
   const metadata = { homie: 'shop-links-v1', studio: slug, origin: site };
+  const tasks=[];
   const groups=Map.groupBy(menuItems,i=>i.game??'');
-  for(const group of groups.values()) for (let offset = 0; offset < group.length; offset += 10) {
-    const items = group.slice(offset, offset + 10);
-    if (items.length < 2) continue;
+  for(const group of (shop.basket ? [] : groups.values())) for (let offset = 0; offset < group.length; offset += 10) {
+    const groupOffset=offset;tasks.push(async()=>{
+    const items = group.slice(groupOffset, groupOffset + 10);
+    if (items.length < 2) return;
     const params = { ...customText, line_items: items.map(i => ({price:catalogPrices.get(i.id),quantity:1,adjustable_quantity:{enabled:true,minimum:0,maximum:shop.policy.repeatPurchases?999999:1}})),
       invoice_creation:{enabled:true,invoice_data:{metadata}},
       after_completion:{type:'redirect',redirect:{url:`${site}/shop/thanks?session_id={CHECKOUT_SESSION_ID}`}},
       automatic_tax:{enabled:shop.automaticTax}, payment_intent_data:{metadata} };
     const revision=hash(params);
     let link=links.find(p=>own(p)&&p.metadata?.revision===revision);
-    if(!link)link=await api('POST','/v1/payment_links',{...params,metadata:{...metadata,revision}},`menu-${revision}`);
+    if(!link)link=await api('POST','/v1/payment_links',{...params,...(scoped?{expand:['line_items']}:{}),metadata:{...metadata,revision}},`menu-${revision}`);
     await verifyLink(link,params);
     if(!link.active)await api('POST',`/v1/payment_links/${link.id}`,{active:true});
     keepLinks.add(link.id);
     config.menus.push({id:link.id,url:link.url,revision,items:items.map(i=>({item:i.id,price:catalogPrices.get(i.id)}))});
-  }
+  });}
+  // One aggregate payment represents a frozen local basket, including one-item baskets.
+  // Runtime uses prefilled_amount, never a shared Price mutation: concurrent
+  // guests must receive their own saved totals.
+  if(shop.basket) for(const [game,items] of groups) {tasks.push(async()=>{
+    const id=await productIdOf(slug,`basket-${game||'shop'}`);
+    keepProducts.add(id);
+    const fields={name:shop.basket.name,description:shop.basket.description,metadata,active:true};
+    const priceFields={product:id,currency:shop.currency,custom_unit_amount:{enabled:true},tax_behavior:'inclusive'};
+    const priceRevision=hash(priceFields);
+    let product=products.find(p=>p.id===id);
+    if(!product) {
+      const {product:_,...default_price_data}=priceFields;
+      const createFields={...fields};if(!createFields.description)delete createFields.description;
+      product=await api('POST','/v1/products',{id,...createFields,...(scoped?{default_price_data:{...default_price_data,metadata:{...metadata,revision:priceRevision}},expand:['default_price']}:{})},`product-${hash(id)}`);
+    } else if(product.name!==fields.name || product.description!==fields.description || !product.active)await api('POST',`/v1/products/${id}`,fields);
+    let price=prices.find(p=>own(p)&&p.product===id&&p.metadata?.revision===priceRevision);
+    if(!price&&product.default_price?.metadata?.revision===priceRevision)price=product.default_price;
+    if(!price)price=await api('POST','/v1/prices',{...priceFields,metadata:{...metadata,revision:priceRevision}},`price-${hash({priceFields,metadata})}`);
+    if(!price.active)await api('POST',`/v1/prices/${price.id}`,{active:true});
+    keepPrices.add(price.id);
+    const params={line_items:[{price:price.id,quantity:1}],automatic_tax:{enabled:false},payment_intent_data:{metadata},
+      after_completion:{type:'redirect',redirect:{url:`${site}/shop/thanks?session_id={CHECKOUT_SESSION_ID}`}}};
+    const revision=hash(params);
+    let link=links.find(p=>own(p)&&p.metadata?.revision===revision);
+    if(!link)link=await api('POST','/v1/payment_links',{...params,...(scoped?{expand:['line_items']}:{}),metadata:{...metadata,revision}},`basket-${revision}`);
+    if(!link.active)await api('POST',`/v1/payment_links/${link.id}`,{active:true});
+    await verifyLink(link,params);
+    if(!paymentLinkURL(link.url))throw new Error('Invalid basket Payment Link');
+    keepLinks.add(link.id);
+    config.menus.push({id:link.id,url:link.url,revision,price:price.id,basket:true,items:items.map(i=>({item:i.id,price:catalogPrices.get(i.id)}))});
+  });}
   config.slots=[];
   const pause=async link=>{
     if(link.active) await api('POST',`/v1/payment_links/${link.id}`,{active:false});
@@ -106,12 +167,13 @@ export async function reconcilePaymentLinks({ api, shop, slug, site, mode, booki
     const resource=JSON.stringify([slot.app,slot.slots,slot.slot]);
     if(slotKeys.has(resource))throw new Error('Publish only one service Payment Link per capacity slot');
     slotKeys.add(resource);
+    tasks.push(async()=>{
     const item=shop.items.find(i=>i.id===slot.item);
     if(!item || item.interval || item.price==='choose')throw new Error('Bookings require a fixed one-time service price');
-    if(!item.price)continue;
+    if(!item.price)return;
     const identity=hash({slug,site,app:slot.app,collection:slot.collection,slots:slot.slots,slot:slot.slot});
     let link=links.find(p=>own(p)&&p.metadata?.slot===identity);
-    if(!link && (!slot.capacity||slot.active===false))continue;
+    if(!link && (!slot.capacity||slot.active===false))return;
     if(link?.metadata?.price && link.metadata.price!==catalogPrices.get(item.id))throw new Error('Slot service price changed. Deactivate the old slot and publish a new slot ID after reviewing existing bookings.');
     const seatsRevision=hash({slot,capacity:slot.capacity,confirmed:slot.confirmed});
     const counted=slot.confirmed!==undefined && link?.metadata?.seats_revision===seatsRevision;
@@ -123,7 +185,7 @@ export async function reconcilePaymentLinks({ api, shop, slug, site, mode, booki
     const active=slot.active!==false && limit>count;
     const params={...customText,line_items:[{price:catalogPrices.get(item.id),quantity:1}],payment_method_types:['card'],
       restrictions:{completed_sessions:{limit:Math.max(1,limit)}},after_completion:{type:'redirect',redirect:{url:`${site}/shop/thanks?session_id={CHECKOUT_SESSION_ID}`}}};
-    if(!link)link=await api('POST','/v1/payment_links',{...params,metadata:{...metadata,slot:identity,revision:identity,price:catalogPrices.get(item.id)}},`slot-${identity}`);
+    if(!link)link=await api('POST','/v1/payment_links',{...params,...(scoped?{expand:['line_items']}:{}),metadata:{...metadata,slot:identity,revision:identity,price:catalogPrices.get(item.id)}},`slot-${identity}`);
     else {
       // Pause first whenever publishing a changed budget, so old sessions cannot
       // spend a previous capacity after staff moves or removes a slot.
@@ -133,17 +195,19 @@ export async function reconcilePaymentLinks({ api, shop, slug, site, mode, booki
     await verifyLink(link,params);
     keepLinks.add(link.id);
     config.slots.push({...slot,id:link.id,url:link.url,price:catalogPrices.get(item.id),revision:identity,active:link.active,count:link.restrictions?.completed_sessions?.count??0,limit,paused:slot.active===false});
+    });
   }
-  // Retired booking links must be closed before publishing a configuration which
-  // no longer names them; staff can then move into that local-only slot safely.
-  for(const link of links.filter(p=>own(p)&&p.metadata?.slot&&!keepLinks.has(p.id)))await pause(link);
-  if(shop.items.some(i=>i.interval)) {
-    const portals=await list('/v1/billing_portal/configurations');
+  if(shop.items.some(i=>i.interval)) tasks.push(async()=>{
+    const portals=scoped?(knownPortal?[await api('GET',`/v1/billing_portal/configurations/${knownPortal}`,{})]:[]):await list('/v1/billing_portal/configurations');
     let portal=portals.find(p=>own(p));
     const params={features:{subscription_cancel:{enabled:true},payment_method_update:{enabled:true},invoice_history:{enabled:true}},login_page:{enabled:true},business_profile:{headline:'Manage your membership or giving'},default_return_url:`${site}/shop/`,metadata};
     if (!portal || !matchesFields(portal, params)) portal=await api('POST',portal?`/v1/billing_portal/configurations/${portal.id}`:'/v1/billing_portal/configurations',params, portal?undefined:`portal-${hash({slug,site,params})}`);
-    config.portal=portal.login_page?.url;
-  }
+    config.portal=portal.login_page?.url;config.portalId=portal.id;
+  });
+  await parallel(tasks);
+  // Retired booking links must be closed before publishing a configuration which
+  // no longer names them; staff can then move into that local-only slot safely.
+  for(const link of links.filter(p=>own(p)&&p.metadata?.slot&&!keepLinks.has(p.id)))await pause(link);
   const retire = [
     ...links.filter(p=>own(p)&&p.active&&!keepLinks.has(p.id)).map(p=>({method:'POST',path:`/v1/payment_links/${p.id}`,params:{active:false}})),
     ...prices.filter(p=>own(p)&&p.active&&!keepPrices.has(p.id)).map(p=>({method:'POST',path:`/v1/prices/${p.id}`,params:{active:false}})),