@homie-rocks/studio 0.51.8 → 0.53.0

package/guides/shop/SKILL.md

@@ -49,27 +49,34 @@ calling it; tool argument shapes can change. See https://docs.stripe.com/mcp.
 3. Append `{ "method": "POST", "path": "…", "params": {…}, "body": <Stripe response> }`
    for **writes as well as reads**. Keep this setup's observations across batches.
    Product creation includes its default Price; link creation expands line items.
-   Product and Price Search use studio/origin metadata. Existing links are fetched by
-   IDs from the verified configuration; Stripe has no Payment Link metadata search.
-   Keep `.studio/stripe-mcp.json` when moving the studio to another computer. Without
-   it, repeat creates use their idempotency keys; outside Stripe's idempotency retention
-   window, recover the studio's existing link IDs before setup to avoid duplicates.
-   Follow search `next_page` cursors. Search is eventually consistent: write responses
-   are the immediate evidence. On an uncertain write, retry its exact idempotency key;
-   never discard successful responses or invent IDs. Start a new read set when checking
-   later external edits, changing accounts, or changing mode.
+   Product and Price Search use studio/origin metadata. Payment Links use paginated
+   list reads with `expand[]=data.line_items`, then filter studio/origin metadata locally;
+   Stripe has no Payment Link metadata search. There is no per-link read loop.
+   The planner saves public observations in `.studio/stripe-mcp-observations.json` and
+   reuses them on the next call; send only new responses. Keep that file and
+   `.studio/stripe-mcp.json` when moving computers. Changed shop/slot settings refresh
+   mutable links while retaining product/price discovery. Account, mode and origin
+   changes start separate reads. Pass `refresh: true` for Dashboard changes or a fresh
+   verification before webhook installation (CLI: include it in `--have` input).
+   Follow search `next_page` and list `starting_after` cursors. On an uncertain write,
+   retry its exact idempotency key; never discard successful responses or invent IDs.
 4. Call `stripe_shop_plan` with `verify: true` using those observations (CLI
    `homie-studio shop verify --have plan-input.json`). Verification checks real fields,
    line items, menus, slot limits and portal settings. It saves compact public Worker
    configuration and provenance to `.studio/stripe-mcp.json`, never API response history.
-   Deploy installs those links. Checkout then reports only `webhook-secret` missing;
+   Build writes public links to `site/dist/_site/stripe-shop-links.json`; deploy ships
+   that asset, with only its path in Wrangler vars. Large catalogues never use a text
+   binding. Deploy after verifying, including when setup began on an already-live site. Checkout then reports only `webhook-secret` missing;
    it cannot open until signed payment events can confirm orders. Changing shop.json,
    the slot manifest or origin requires verification again. Local test configuration
    goes to `.dev.vars`.
 5. For a deployed HTTPS studio, run `stripe_webhook` (CLI `homie-studio shop webhook`).
    Follow `studio_job`. This uses Stripe CLI only for private webhook installation,
-   checks the same account as the MCP, and installs the signing secret and verified
-   links through Wrangler stdin. The CLI needs one separate browser approval if its
+   checks the same account as the MCP, and installs only the signing secret through
+   Wrangler stdin. If Stripe CLI is missing, the tool installs the official
+   `@stripe/cli@latest` npm package automatically, checks the executable, then continues.
+   An installation failure reports npm permissions/PATH and a retry command. The CLI
+   needs one separate browser approval if its
    studio profile is not already connected. MCP approval cannot be reused or exported.
    Cloudflare authorization and an existing deployment are prerequisites.
 6. After installation, perform the returned `retire` operations through Stripe MCP to
@@ -80,6 +87,14 @@ calling it; tool argument shapes can change. See https://docs.stripe.com/mcp.
    endpoint's delivery result and the app's verified records. Do not type a card into
    a page for an automated proof; use Stripe's documented test PaymentMethods/fixtures.
 
+Upgrades accept 0.51.6 verifications without a source fingerprint only when their
+saved content fingerprint still matches the current shop, slots, site and mode.
+Actual changes name the affected settings and require verification. An unfinished
+setup still builds and deploys with checkout closed and one next step: finish
+`stripe_shop_plan` with `verify: true`. Missing/unreadable assets also close checkout;
+old link secrets cannot reopen it. Cached observations never renew the verification
+time; use fresh reads if the private webhook tool requests them.
+
 Never create a webhook through model-visible Stripe MCP: its response exposes the signing secret.
 
 **Why the separate approval (checked 2026-10-14).** Stripe's

package/lib/app-needs.mjs

@@ -22,16 +22,24 @@ export function readAppNeeds(root, id) {
   return { needs, hash: createHash('sha256').update(source).digest('hex') };
 }
 
+/** An action names its actor; an observation-only need prefers its phone or a matching role. */
+export function primaryNeedSurface(need,roleFor=()=>undefined) {
+ const action=needSteps(need.steps).find(s=>s.surface)?.surface;
+ const assertions=(need.assertions??[]).filter(s=>s.surface);
+ return need.surface??action??assertions.find(s=>['phone','phone-two'].includes(s.surface))?.surface??assertions.find(s=>!need.role||roleFor(s.surface)===need.role)?.surface;
+}
+
 /** 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 () => {}, root, headless }) {
+export async function proveAppNeeds({ plan, surfaces, shots, report, ready = async () => {}, root, headless, restart }) {
   const results = [];
   const appBarrier=ready;
   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; };
+  let activeRole, primarySurface;
+  const surface = (name, explicitRole) => { const role=explicitRole??(name===primarySurface?activeRole:undefined); const s=surfaces.find(s=>s.name===name&&(!role||s.role===role)); if(!s)throw new Error(role?`${name} requires role ${role}`:`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).filter(Boolean))];
+    primarySurface = primaryNeedSurface(need,name=>surfaces.find(s=>s.name===name)?.role);
+    const names = [...new Set([...needSteps(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';
@@ -39,21 +47,36 @@ export async function proveAppNeeds({ plan, surfaces, shots, report, ready = asy
     try {
       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 rawStep of need.steps ?? []) {
+      for(const item of [...needSteps(need.steps),...need.assertions])if(item.surface&&!popupNames.has(item.surface))surface(item.surface,item.role);
+      for(const target of new Set(need.assertions.filter(a=>a.effect).map(a=>surface(a.surface,a.role))))await target.frame.evaluate(()=>{window.__homieNeedsEffects=[];});
+      const perform = async rawStep => {
         const step=resolveNeedResults(rawStep,saved);
+        if(step.concurrent){
+          if(!Array.isArray(step.concurrent)||step.concurrent.length<2)throw new Error('concurrent needs at least two steps');
+          if(needSteps(step.concurrent).some(s=>s.restart||s.capabilities))throw new Error('Restart and capabilities changes must be outside a race');
+          const results=await Promise.allSettled(step.concurrent.map(perform));
+          const failed=results.find(r=>r.status==='rejected');if(failed)throw failed.reason;return;
+        }
+        if(step.restart){if(!restart)throw new Error('Restart requires the local dev controller');await restart();for(const s of surfaces)await ready(s);return;}
+
         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;
+          return;
         }
-        const target=surface(step.surface);
+        const target=surface(step.surface,step.role);
         if(!step.reload)await ready(target);
         const { page } = target;
+        if(step.capabilities){
+          if(typeof step.capabilities.webgl!=='boolean')throw new Error('capabilities.webgl must be boolean');
+          await page.evaluateOnNewDocument(configureWebGL,step.capabilities.webgl);
+          await page.reload({waitUntil:'domcontentloaded'});await ready(target);return;
+        }
+        if(Object.hasOwn(step,'clock')){await page.evaluate(value=>window.homieApp.setTestClock(value),step.clock);return;}
+
         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; }
+        if (step.reload) { await page.reload({ waitUntil: 'domcontentloaded' }); await ready(surface(step.surface,step.role)); return; }
         const act = fn => actInApp(target,step.selector,fn,{ready});
         if (step.click && step.popup) {
           let listener,timer;
@@ -67,11 +90,15 @@ export async function proveAppNeeds({ plan, surfaces, shots, report, ready = asy
             await page.bringToFront();
           } finally {clearTimeout(timer);page.off('popup',listener);}
         }
+        else if(step.forceClick){await act(frame=>frame.$eval(step.selector,el=>{
+          const disabled=el.disabled;try{el.disabled=false;el.click();}finally{el.disabled=disabled;}
+        }));}
         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 step of need.steps??[])await perform(step);
       for (const rawAssertion of need.assertions) {
         const assertion=resolveNeedResults(rawAssertion,saved);
         if (assertion.result || assertion.records || assertion.file || assertion.mcp) {
@@ -99,7 +126,7 @@ export async function proveAppNeeds({ plan, surfaces, shots, report, ready = asy
           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);
+        const target=surface(assertion.surface,assertion.role);
         await ready(target);
         await waitInApp(target,waiting,async frame=>{
         if (assertion.effect) {
@@ -115,9 +142,10 @@ export async function proveAppNeeds({ plan, surfaces, shots, report, ready = asy
       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 { mkdirSync(shots,{recursive:true}); await ready(surface(name)); await surface(name).page.screenshot({ path: file, type: 'jpeg', quality: 85 }); result.captures.push(file); }
+    if (shots) for (const target of surfaces.filter(s=>names.includes(s.name))) {
+      const name=target.name, suffix=surfaces.filter(s=>s.name===name).length>1?'-'+target.role:'';
+      const file = join(shots, `${need.id}-${name}${suffix}.jpg`);
+      try { mkdirSync(shots,{recursive:true}); await ready(target); await target.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 });
@@ -170,3 +198,19 @@ export function resolveNeedResults(value,saved) {
   }
   return value;
 }
+
+/** Flatten only action groups; used for browser/role discovery before a race starts. */
+export function needSteps(steps = []) { return steps.flatMap(s => s.concurrent ? needSteps(s.concurrent) : [s]); }
+export function configureWebGL(enabled) {
+  window.__homieWebGLDisabled = !enabled;
+  if(window.__homieWebGLWrapped)return;
+  window.__homieWebGLWrapped = true;
+  for(const proto of [globalThis.HTMLCanvasElement?.prototype,globalThis.OffscreenCanvas?.prototype]) {
+    if(!proto)continue;
+    const original = proto.getContext;
+    proto.getContext = function(kind, ...args) {
+      if(window.__homieWebGLDisabled && /^(webgl2?|experimental-webgl)$/.test(kind))return null;
+      return Reflect.apply(original,this,[kind,...args]);
+    };
+  }
+}

package/lib/app-ready.mjs

@@ -9,7 +9,7 @@ export async function appReady(surface, {timeout=60000}={}) {
         const cover=document.querySelector('[data-arrive]');
         return window.__shell?.link?.state==='online' && window.__shell?.arrival?.phase==='done' && (!cover || (getComputedStyle(cover).opacity==='0' && getComputedStyle(cover).visibility==='hidden'));
       },{timeout:Math.max(1,end-Date.now())});
-      const frame=surface.page.frames().find(f=>/\/__game\//.test(f.url()));
+      const frame=surface.page.frames().find(f=>/\/(?:__game|__assets)\//.test(f.url()));
       if(!frame)throw new Error('app frame missing');
       await frame.evaluate(()=>new Promise(resolve=>requestAnimationFrame(()=>requestAnimationFrame(resolve))));
       surface.frame=frame;return;

package/lib/build.mjs

@@ -1,3 +1,4 @@
+import {verifiedMcpConfig,publicMcpSetup} from './shop-mcp.mjs';
 import { directoryUrl } from '../worker/directory-choice.mjs';
 import { domainOrigin } from './studio.mjs';
 import { appProblems } from '../worker/app-format.mjs';
@@ -634,7 +635,7 @@ async function buildInto(dist, { esbuild, studio, shop, live, games, before, typ
     const bundle = bundleOf(dir);
     builds[g.id] = { hash: gameDigest(dir), ...(bundle ? { bundle } : {}) };
     return {
-      ...(g.kind === 'app' ? { kind: 'app', roles: g.roles, surfaces: g.surfaces, words: g.words, records: g.records, parts: g.parts ?? [], check: g.check } : {}),
+      ...(g.kind === 'app' ? { kind: 'app', ...(g.web?{web:g.web}:{}), ...(g.timeZone?{timeZone:g.timeZone}:{}), roles: g.roles, surfaces: g.surfaces, words: g.words, records: g.records, parts: g.parts ?? [], check: g.check } : {}),
       id: g.id, name: g.name ?? g.id, blurb: g.blurb ?? '', players: { min, max },
       ...(ui ? { ui } : {}),
       // A rules game's round is its rules' own (`room.rounds`), and its movement a per-kind choice there: game.json's
@@ -686,6 +687,10 @@ async function buildInto(dist, { esbuild, studio, shop, live, games, before, typ
   // GAME PARTS: every packed version of every SHARED part into dist/parts/, and its index; a private part is never copied.
   const partsBuilt = buildParts(root, dist, { studio, log });
   mkdirSync(join(dist, '_site'), { recursive: true });
+  if(publicMcpSetup(root)) {
+    const verified=verifiedMcpConfig(root);
+    writeFileSync(join(dist,'_site','stripe-shop-links.json'),JSON.stringify({config:verified?.result.config??null,next:verified?null:'Ask your AI to finish stripe_shop_plan with verify:true.'}));
+  }
   writeFileSync(join(dist, '_site', 'posts.json'), `${JSON.stringify({ v: 1, posts })}\n`);
   const studioExtras = schemaExtras(s.schema, { where: 'studio.json site', types: 'Organization', log });
   // The Lounge (0.29.0): studio.json "lounge", checked; off when a game already has /lounge/.
@@ -693,6 +698,7 @@ async function buildInto(dist, { esbuild, studio, shop, live, games, before, typ
   const lounge = loungeConfig(studio, rows, { audience: audienceOf(studio) });
   const catalogue = {
     studio: {
+      ...(studio.concept===true?{concept:true}:{}),
       name: studio.name, slug: studio.slug, version: STUDIO_VERSION, ...(studio.kind ? { kind: studio.kind } : {}),
       ...(typeof studio.tagline === 'string' && studio.tagline.trim() ? { tagline: studio.tagline.trim().slice(0, 140) } : {}),
       theme,
@@ -711,7 +717,7 @@ async function buildInto(dist, { esbuild, studio, shop, live, games, before, typ
       ...(studio.rooms?.share === false ? { rooms: { share: false } } : {}),
       // The directory the live site claims itself in (0.10.0); studio.json `homie.directory: false` keeps it out.
       // HOMIE_DIRECTORY (a build variable) points one build at another directory, such as a staging one.
-      directory: directoryUrl(process.env.HOMIE_DIRECTORY ?? studio.homie?.directory),
+      directory: studio.concept===true?false:directoryUrl(process.env.HOMIE_DIRECTORY ?? studio.homie?.directory),
       canonical: domainOrigin(studio.cloudflare?.domain) ?? domainOrigin(studio.cloudflare?.url),
       // A copy of the public template that nobody has named yet shows the name typed in Cloudflare's form.
       ...(studio.template === true ? { template: true } : {}),

package/lib/check.mjs

@@ -2,7 +2,7 @@ import {needsHeadless} from './needs-headless.mjs';
 import {randomBytes} from 'node:crypto';
 import {actInApp,appReady,observeEffects,forceWebglFailure,waitInApp,answerDialogs} from './app-ready.mjs';
 import {localCredential,localCookie} from './local-test.mjs';
-import { readAppNeeds, proveAppNeeds, saveAppNeeds } from './app-needs.mjs';
+import { readAppNeeds, proveAppNeeds, saveAppNeeds, needSteps, primaryNeedSurface } from './app-needs.mjs';
 /**
  * `homie-studio check [<game>] [--url <site> | --live]` — the promise, measured (where it runs and on which games
  * when nobody says: lib/check-site.mjs; never the live site unless asked): two fresh
@@ -152,7 +152,7 @@ export async function check({ webglFailure = false, isolate = true, root = null,
   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({webglFailure,isolate,root,url:base,game,meta:appMeta,shots,log,report});
+      if(plan && !plan.needs.some(n=>[...needSteps(n.steps),...(n.assertions??[])].some(i=>i.surface)))return checkApp({webglFailure,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();
@@ -359,28 +359,43 @@ export async function checkApp({ webglFailure = false, isolate = true, root = nu
   let plan;
   try { plan = readAppNeeds(root, game); } catch (error) { return { ok: false, command: 'check', kind: 'app', why: error.message }; }
   const secret=localCredential(root,url);
-  if(isolate && !secret)return {ok:false,command:'check',why:'Fresh isolated records are on by default. Run dev in this studio and check its localhost URL, or explicitly use --no-isolate.'};
+
   log(isolate ? 'Fresh isolated records: on (this check only).' : 'Fresh isolated records: off; using existing records.');
   const dialogs=[];
   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(webglFailure&&!baseline&&!plan?.needs.some(n=>[...(n.steps??[]),...(n.assertions??[])].some(i=>i.surface)))return {ok:false,command:'check',why:'--webgl-failure requires UI steps or assertions'};
+  if(webglFailure&&!baseline&&!plan?.needs.some(n=>[...needSteps(n.steps),...(n.assertions??[])].some(i=>i.surface)))return {ok:false,command:'check',why:'--webgl-failure requires UI steps or assertions'};
   const captureWarnings=[];
   const profile = mkdtempSync(join(tmpdir(), 'homie-app-check-'));
-  let browser;
+  let browser, ownerClient;
   const surfaces = [];
-  const room = `check-${randomBytes(10).toString('hex')}`;
+  let room = `check-${randomBytes(10).toString('hex')}`;
   try {
-    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 remoteCookies=new Map();
+    const sessionFor=async role=>{
+      if(secret)return {name:'homie_test',value:localCookie(secret,{app:game,role,scope:isolate?room:null})};
+      if(!isolate)return null;
+      ownerClient??=await (await import('./tools-cli.mjs')).connectToolClient(root,url,{log});
+      const key=room+':'+role;
+      if(!remoteCookies.has(key)) {
+        const result=await ownerClient.callTool({name:'studio_check_session',arguments:{app:game,role,scope:room}});
+        if(result.isError)throw new Error(result.content?.[0]?.text??'Cannot create isolated check session');
+        const parsed=result.structuredContent??JSON.parse(result.content.find(c=>c.type==='text').text),data=parsed.data??parsed;
+        if(!data.token)throw new Error('Studio did not return its test-session token');
+        remoteCookies.set(key,{name:'homie_check',value:data.token});
+      }
+      return remoteCookies.get(key);
+    };
+    if(baseline || plan?.needs.some(n=>[...needSteps(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}`);
       role ??= meta.surfaces?.[name==='phone-two'?'phone':name] ?? (name==='staff'?'staff':undefined);
       if(!meta.roles?.[role])throw new Error(`${name}: unknown role ${role}`);
-      if(meta.roles[role].signIn && !secret)throw new Error(`${name}: local staff proof needs dev's test session`);
+      if(meta.roles[role].signIn && !secret && !isolate)throw new Error(`${name}: local staff proof needs dev's test session`);
       const context=await browser.createBrowserContext();
-      if(secret)await context.setCookie({name:'homie_test',value:localCookie(secret,{app:game,role,scope:isolate?room:null}),url,httpOnly:true,sameSite:'Strict'});
+      const cookie=await sessionFor(role);if(cookie)await context.setCookie({...cookie,url,httpOnly:true,sameSite:'Strict',secure:new URL(url).protocol==='https:'});
       const page=await context.newPage();
       answerDialogs(page,name,dialogs,report);
       await page.evaluateOnNewDocument(observeEffects);
@@ -417,16 +432,25 @@ export async function checkApp({ webglFailure = false, isolate = true, root = nu
     }
     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?[]:null;
+    for(const need of plan?.needs??[]) {
+      // Baseline and every need get separate contexts, rooms and record namespaces.
+      for(const context of new Set(surfaces.map(surface=>surface.page.browserContext())))await context.close();
+      surfaces.length=0;
+      room=`check-${randomBytes(10).toString('hex')}`;
+      const declaredRole=name=>meta.surfaces?.[name==='phone-two'?'phone':name]??(name==='staff'?'staff':undefined);
+      const primary=primaryNeedSurface(need,declaredRole);
+      log(`Need ${need.id}: fresh room ${room}; records ${isolate?'isolated':'shared (--no-isolate)'}.`);
+      for(const item of [...needSteps(need.steps),...(need.assertions??[])]) {
+        if(!item.surface || (need.steps??[]).some(s=>s.popup===item.surface))continue;
+        const role=item.role??(item.surface===primary?need.role:undefined)??declaredRole(item.surface);
+        if(!surfaces.some(s=>s.name===item.surface&&s.role===role))await openSurface(item.surface,role);
+      }
+      needs.push(...await proveAppNeeds({plan:{...plan,needs:[need]},surfaces,shots,report,ready:appReady,root,restart:()=>import('./dev-restart.mjs').then(m=>m.requestDevRestart(root,url)),headless:needsHeadless({url,secret,app:game,meta,scope:isolate?room:null,sessionFor})}));
     }
-    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', webglFailure, 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 }); }
+  finally { await ownerClient?.close().catch(()=>{}); await browser?.close().catch(() => {}); rmSync(profile, { recursive: true, force: true }); }
 }

package/lib/cloudflare.mjs

@@ -595,8 +595,8 @@ export function configNames(root) {
  * nothing back (a CI checkout is thrown away). On the very first deploy the database may not exist yet: Wrangler
  * creates the one the binding names while it deploys, and the migrations run right after.
  */
-export async function ciDeploy(root, { log = () => {} } = {}) {
-  const w = runner(root, {});
+export async function ciDeploy(root, { log = () => {}, wrangler = null } = {}) {
+  const w = wrangler ?? runner(root, {});
   refreshWorkerConfig(root);
   const names = configNames(root);
   const steps = [];

package/lib/dev-restart.mjs

@@ -0,0 +1,25 @@
+import {readFileSync,writeFileSync,rmSync} from 'node:fs';
+import {join} from 'node:path';
+import {randomUUID} from 'node:crypto';
+import {localCredential} from './local-test.mjs';
+const read=file=>{try{return JSON.parse(readFileSync(file,'utf8'));}catch{return null;}};
+export function takeDevRestart(root,secret){
+ const file=join(root,'.studio','restart-request.json'),value=read(file);
+ if(!value)return null;
+ rmSync(file,{force:true});
+ return value.secret===secret&&typeof value.id==='string'?value.id:null;
+}
+export function acknowledgeDevRestart(root,id){writeFileSync(join(root,'.studio','restart-result.json'),JSON.stringify({id}),{mode:0o600});}
+export async function requestDevRestart(root,url,{timeout=60000}={}){
+ const secret=localCredential(root,url);if(!secret)throw new Error('Restart requires this studio’s local dev credential');
+ const id=randomUUID(),file=join(root,'.studio','restart-request.json');
+ writeFileSync(file,JSON.stringify({id,secret}),{mode:0o600});
+ try{
+  const end=Date.now()+timeout;
+  while(Date.now()<end){
+   if(read(join(root,'.studio','restart-result.json'))?.id===id)return;
+   await new Promise(resolve=>setTimeout(resolve,100));
+  }
+  throw new Error('Dev did not acknowledge restart; run the current homie-studio dev');
+ }finally{if(read(file)?.id===id)rmSync(file,{force:true});}
+}

package/lib/dev.mjs

@@ -1,3 +1,4 @@
+import {takeDevRestart,acknowledgeDevRestart} from './dev-restart.mjs';
 import {createLocalCredential} from './local-test.mjs';
 import {workerEntry} from './worker-build.mjs';
 import { networkInterfaces } from 'node:os';
@@ -299,6 +300,7 @@ export function rulesStamp(g) {
   const walk=dir=>{for(const entry of readdirSync(dir,{withFileTypes:true})) {
     if(['node_modules','.git','.wrangler','.studio','.port','.cache','.parcel-cache','.vite','.DS_Store','coverage','dist','codex'].includes(entry.name))continue;
     const file=join(dir,entry.name);
+    if(file===join(g.dir,'CODEX.md'))continue; // check writes authoring evidence, never runtime inputs
     if(entry.isDirectory())walk(file);
     else if(entry.isFile()){const st=statSync(file);rows.push(`${file}:${st.size}:${st.mtimeMs}:${st.ctimeMs}`);}
   }};
@@ -371,7 +373,7 @@ export async function dev(root, { lan = false, port: askedPort = 8787, remoteAi
 
   let child = null;
   let ending = false;
-  let restart = null;
+  let restart = null, proofRestart = null;
   let failed = null;
   const lineState = {};
   // Stopping this process stops Wrangler with it, so no dev server is left running on its own.
@@ -395,6 +397,9 @@ export async function dev(root, { lan = false, port: askedPort = 8787, remoteAi
     if (busy || ending || restart || !up) return;
     busy = true;
     try {
+      const requested=takeDevRestart(root,localSecret);
+      if(requested){proofRestart=requested;restart='proof';child?.kill('SIGTERM');return;}
+
       const built = builtIds(root);
       if (!built) return; // mid-build: site/dist is being written
       for (const g of listGames(root)) {
@@ -490,6 +495,7 @@ export async function dev(root, { lan = false, port: askedPort = 8787, remoteAi
       await new Promise((r) => setTimeout(r, 500));
     }
     if (!up) return;
+    if(proofRestart){acknowledgeDevRestart(root,proofRestart);proofRestart=null;}
     const game = (builtIds(root) ?? [])[0];
     if (!game) return;
     const bad = await socketOriginProblem(origin, game);

package/lib/fork.mjs

@@ -0,0 +1,47 @@
+import {existsSync,mkdirSync,readdirSync,readFileSync,writeFileSync,copyFileSync,rmSync} from 'node:fs';
+import {resolve,join,dirname,extname,relative} from 'node:path';
+import {refreshWorkerConfig} from './worker-config.mjs';
+/** Copy editable source, never account state, installed code or a deployment. */
+export async function forkStudio(source,target,{name,slug,ids={}}={}) {
+ source=resolve(source);target=resolve(target);
+ if(existsSync(target))throw new Error('Fork target already exists');
+ if(!/^[a-z][a-z0-9-]{0,39}$/.test(slug??'')||typeof name!=='string'||!name.trim())throw new Error('Supply name and a lowercase slug (1–40 letters, digits and hyphens)');
+ if(!relative(source,target).startsWith('..'))throw new Error('Fork target must be outside the example');
+ const studio=JSON.parse(readFileSync(join(source,'studio.json'),'utf8'));
+ const excluded=new Set(['node_modules','.git','.studio','dist','.wrangler','.DS_Store','wrangler.json','wrangler.jsonc','wrangler.toml','wrangler.custom.json','package-lock.json']);
+ const files=[];
+ function walk(dir){for(const entry of readdirSync(join(source,dir),{withFileTypes:true})) {
+  if(excluded.has(entry.name)||entry.name.startsWith('.')&&entry.name!=='.gitignore'||entry.name.startsWith('.dev.vars')||entry.name.endsWith('.sqlite')||entry.name.endsWith('.db')||entry.name.endsWith('.pem')||entry.name.endsWith('.key')||entry.isSymbolicLink())continue;
+  const path=join(dir,entry.name);if(entry.isDirectory())walk(path);else if(entry.isFile())files.push(path);
+ }}walk('');
+ const mapping=new Map([[studio.slug,slug],[studio.name,name]]);
+ const collect=value=>{if(!value||typeof value!=='object')return;if(typeof value.id==='string'&&/^[a-z][a-z0-9-]*$/.test(value.id))mapping.set(value.id,ids[value.id]??`${slug}-${value.id}`);for(const child of Object.values(value))collect(child);};
+ for(const file of files.filter(p=>p.endsWith('.json')&&!['studio.json','package.json'].includes(p)))try{collect(JSON.parse(readFileSync(join(source,file),'utf8')));}catch{}
+ const ts=(await import('typescript')).default;
+ for(const file of files.filter(p=>/\.(?:[cm]?js|tsx?)$/.test(p))) {
+  const tree=ts.createSourceFile(file,readFileSync(join(source,file),'utf8'),ts.ScriptTarget.Latest,true);
+  const visit=node=>{
+   if(ts.isPropertyAssignment(node)&&(ts.isIdentifier(node.name)||ts.isStringLiteral(node.name))&&node.name.text==='id'&&ts.isStringLiteral(node.initializer))collect({id:node.initializer.text});
+   ts.forEachChild(node,visit);
+  };visit(tree);
+ }
+ for(const [old,next] of Object.entries(ids))mapping.set(old,next);
+ for(const [old,next] of mapping)if(typeof next!=='string'||!next.length)throw new Error(`Invalid replacement for ${old}`);
+ for(const [old,next] of mapping)if(old!==studio.name&&(!/^[a-z][a-z0-9-]{0,39}$/.test(next)))throw new Error(`Renamed id ${next} exceeds 40 characters; supply ids.${old}`);
+ const escape=s=>s.replace(/[.*+?^${}()|[\]\\]/g,'\\$&');
+ const pattern=new RegExp(`(?<![A-Za-z0-9_-])(?:${[...mapping.keys()].filter(Boolean).sort((a,b)=>b.length-a.length).map(escape).join('|')})(?![A-Za-z0-9_-])`,'g');
+ const rewrite=s=>s.replace(pattern,value=>mapping.get(value));
+ mkdirSync(target);
+ try {
+  for(const file of files) {
+   const to=join(target,...file.split('/').map(part=>mapping.get(part)??part));mkdirSync(dirname(to),{recursive:true});
+   if(['.json','.ts','.js','.mjs','.html','.css','.md','.sql','.txt','.svg','.yaml','.yml'].includes(extname(file)))writeFileSync(to,rewrite(readFileSync(join(source,file),'utf8')));else copyFileSync(join(source,file),to);
+  }
+  const fresh=JSON.parse(readFileSync(join(target,'studio.json'),'utf8'));fresh.name=name;fresh.slug=slug;delete fresh.github;delete fresh.template;
+  fresh.cloudflare={worker:slug,d1:slug+'-db',created:[]};fresh.homie={...fresh.homie,directory:false};
+  writeFileSync(join(target,'studio.json'),JSON.stringify(fresh,null,2)+'\n');
+  const pkg=JSON.parse(readFileSync(join(target,'package.json'),'utf8'));pkg.name=slug;delete pkg.repository;writeFileSync(join(target,'package.json'),JSON.stringify(pkg,null,2)+'\n');
+  refreshWorkerConfig(target);
+  return {ok:true,command:'fork',root:target,renamed:Object.fromEntries(mapping),next:['npm install','homie-studio check']};
+ }catch(error){rmSync(target,{recursive:true,force:true});throw error;}
+}

package/lib/functions-build.mjs

@@ -1,3 +1,4 @@
+import {CfWorkerJsonSchemaValidator} from '@modelcontextprotocol/server/validators/cf-worker';
 import {callbackUrl} from '../worker/mcp-events-wire.mjs';
 import {validateWebhook,webhookName} from '../worker/event-webhook-config.mjs';
 import {parseSchedule,nextDue,scheduleStatus} from '../worker/function-schedule.mjs';
@@ -12,6 +13,7 @@ export async function buildFunctions(root,esbuild,{log=()=>{}}={}) {
   const feeds=readStudio(root).mcp?.events??{};
   if(!feeds||typeof feeds!=='object'||Array.isArray(feeds))throw new Error('mcp.events must be a map of named event feeds');
   for(const [name,feed] of Object.entries(feeds)) {
+    if(feed?.schema)new CfWorkerJsonSchemaValidator().getValidator(feed.schema);
     if(feed?.webhook)validateWebhook(name,feed.webhook);
     if(feed?.maxSubscriptions!==undefined&&(!Number.isSafeInteger(feed.maxSubscriptions)||feed.maxSubscriptions<1))throw new Error('maxSubscriptions must be a positive integer');
     if(feed?.receivers!==undefined){if(!Array.isArray(feed.receivers))throw new Error('Event receivers must be an array of exact HTTPS callback URLs');for(const url of feed.receivers)callbackUrl(url);}
@@ -37,6 +39,7 @@ export async function buildFunctions(root,esbuild,{log=()=>{}}={}) {
       try {if(nextDue(parseSchedule(fn.schedule))===null)throw new Error('no matching date');}
       catch(error) {throw new Error(`Function ${fn.name} cannot run: invalid schedule ${JSON.stringify(fn.schedule)} (${error.message})`);}
     }
+    for(const name of fn.publish??[])if(!feeds[name]?.schema)throw new Error(`Function ${fn.name}: publish feed ${name} needs a declared schema`);
     names.add(fn.name);
   }
   const worker=join(root,'site/src/worker.mjs');

package/lib/jobs.mjs

@@ -158,6 +158,7 @@ export function jobView(job, { lines = 12 } = {}) {
     startedAt: job.startedAt, endedAt: job.endedAt,
     seconds: Math.round(((job.endedAt ? Date.parse(job.endedAt) : Date.now()) - Date.parse(job.startedAt)) / 1000),
     tail: text.slice(-lines), log: job.log, result: job.result,
+    events: job.err.split('\n').filter(line=>line.startsWith('HOMIE_EVENT ')).flatMap(line=>{try{return [JSON.parse(line.slice(12))];}catch{return [];}}),
   };
 }
 

package/lib/mcp-tools.mjs

@@ -1178,8 +1178,8 @@ 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 {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'}}},
+      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, supply new write responses as observations and replan until verified; earlier public observations are saved automatically. refresh:true checks external Stripe changes using paginated expanded link lists. 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'},refresh:{type:'boolean',description:'Discard saved observations and read current Stripe state (after Dashboard edits or before private webhook installation).'}}},
       annotations:{readOnlyHint:false,destructiveHint:false,openWorldHint:false},
       run:async a=>{
         const {shopMcpPlan,saveMcpVerification}=await import('./shop-mcp.mjs');
@@ -1195,7 +1195,7 @@ export function toolDefs(ctx, avail = {}) {
       run:async a=>{
         const job=cliJob(ctx.root(a.studio),'Private Stripe webhook',['shop','webhook',...(a.live?['--live']:[]),...(a.renew?['--renew']:[])],{cli:join(PACKAGE_ROOT,'bin','homie-studio.mjs'),keep:false});
         await waitJob(job,Math.min(ctx.waitMs,1000));
-        return ok('Follow studio_job; approve Stripe in the browser if requested.',{kind:'job',...jobView(job)});
+        return ok('Follow studio_job. Its events contain any required Stripe pairing; a saved login needs no new approval.',{kind:'job',...jobView(job)});
       },
     },
     {

package/lib/needs-headless.mjs

@@ -1,13 +1,14 @@
 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}) {
+export function needsHeadless({url,secret,app,meta,scope,sessionFor}) {
   return async (item,role) => {
-    if(!secret)throw new Error('Headless role proof requires homie-studio dev in this studio and its localhost URL');
+    if(!secret&&!sessionFor)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})}`}}});
+    const cookie=sessionFor?await sessionFor(role):{name:'homie_test',value:localCookie(secret,{app,role,scope})};
+    const transport=new StreamableHTTPClientTransport(new URL('/mcp',url),{requestInit:{headers:{...(secret?{authorization:`Bearer ${secret}`} : {}),...(cookie?{cookie:`${cookie.name}=${cookie.value}`}:{})}}});
     try {
       await client.connect(transport);
       let call=item.mcp;

package/lib/scaffold.mjs

@@ -1,3 +1,7 @@
+import {BOOKING_RESOURCES_MIGRATION,BOOKING_RESOURCES_MIGRATION_FILE} from '../worker/booking-resources.mjs';
+import {BOOKING_HOLDS_MIGRATION,BOOKING_HOLDS_MIGRATION_FILE} from '../worker/booking-holds.mjs';
+import {BUSINESS_EVENTS_MIGRATION,BUSINESS_EVENTS_MIGRATION_FILE} from '../worker/business-events.mjs';
+import {APP_LIVE_MIGRATION,APP_LIVE_MIGRATION_FILE} from '../worker/app-streams.mjs';
 import {TOOL_DATABASE_MIGRATION,TOOL_DATABASE_MIGRATION_FILE} from '../worker/tool-database.mjs';
 import { SUBSCRIPTIONS_MIGRATION, SUBSCRIPTIONS_MIGRATION_FILE } from '../worker/shop-subscriptions.mjs';
 import { BOOKINGS_MIGRATION, BOOKINGS_MIGRATION_FILE } from '../worker/booking-store.mjs';
@@ -823,6 +827,10 @@ export { default, Table, Lobby, Gate, Concentrator } from '@homie-rocks/studio/w
     [`site/migrations/${SHOP_LINES_FILE}`]: SHOP_LINES,
     [`site/migrations/${SHOP_REMOVE_REFERRALS_FILE}`]: SHOP_REMOVE_REFERRALS,
     [`site/migrations/${APPS_MIGRATION_FILE}`]: APPS_MIGRATION,
+    [`site/migrations/${BUSINESS_EVENTS_MIGRATION_FILE}`]: BUSINESS_EVENTS_MIGRATION,
+    [`site/migrations/${BOOKING_RESOURCES_MIGRATION_FILE}`]: BOOKING_RESOURCES_MIGRATION,
+    [`site/migrations/${BOOKING_HOLDS_MIGRATION_FILE}`]: BOOKING_HOLDS_MIGRATION,
+    [`site/migrations/${APP_LIVE_MIGRATION_FILE}`]: APP_LIVE_MIGRATION,
     [`site/migrations/${TOOL_DATABASE_MIGRATION_FILE}`]: TOOL_DATABASE_MIGRATION,
     [`site/migrations/${BOOKINGS_MIGRATION_FILE}`]: BOOKINGS_MIGRATION,
     [`site/migrations/${SUBSCRIPTIONS_MIGRATION_FILE}`]: SUBSCRIPTIONS_MIGRATION,
@@ -1048,8 +1056,28 @@ function ensureToolDatabase(root) {
   if(existsSync(file))return null;
   mkdirSync(dirname(file),{recursive:true});writeFileSync(file,TOOL_DATABASE_MIGRATION);return `site/migrations/${TOOL_DATABASE_MIGRATION_FILE}`;
 }
+function ensureAppLive(root) {
+  const file=join(root,'site','migrations',APP_LIVE_MIGRATION_FILE);
+  if(existsSync(file))return null;
+  mkdirSync(dirname(file),{recursive:true});writeFileSync(file,APP_LIVE_MIGRATION);return `site/migrations/${APP_LIVE_MIGRATION_FILE}`;
+}
+function ensureBusinessEvents(root) {
+  const file=join(root,'site','migrations',BUSINESS_EVENTS_MIGRATION_FILE);
+  if(existsSync(file))return null;
+  mkdirSync(dirname(file),{recursive:true});writeFileSync(file,BUSINESS_EVENTS_MIGRATION);return `site/migrations/${BUSINESS_EVENTS_MIGRATION_FILE}`;
+}
+function ensureBookingHolds(root) {
+  const file=join(root,'site','migrations',BOOKING_HOLDS_MIGRATION_FILE);
+  if(existsSync(file))return null;
+  mkdirSync(dirname(file),{recursive:true});writeFileSync(file,BOOKING_HOLDS_MIGRATION);return `site/migrations/${BOOKING_HOLDS_MIGRATION_FILE}`;
+}
+function ensureBookingResources(root) {
+  const file=join(root,'site','migrations',BOOKING_RESOURCES_MIGRATION_FILE);
+  if(existsSync(file))return null;
+  mkdirSync(dirname(file),{recursive:true});writeFileSync(file,BOOKING_RESOURCES_MIGRATION);return `site/migrations/${BOOKING_RESOURCES_MIGRATION_FILE}`;
+}
 export function ensureMigrations(root) {
-  return [ensureStatsMigration(root), ensurePlayersMigration(root), ensureOfficeMigration(root), ensureServersMigration(root), ensureChatMigration(root), ensureShopMigration(root), ensureLoungeMigration(root), ensureShopReservations(root), ensureShopLines(root), ensureAppsMigration(root), ensurePartsMigration(root), ensurePartsStateMigration(root), ensureMcpMigration(root), ensureFunctionsMigration(root), ensureFunctionCursors(root), ensureFunctionMeta(root), ensureFunctionReference(root), ensureShopRemoveReferrals(root), ensureFunctionRuns(root), ensureToolDatabase(root), ensureBookings(root), ensureSubscriptions(root)].filter(Boolean);
+  return [ensureStatsMigration(root), ensurePlayersMigration(root), ensureOfficeMigration(root), ensureServersMigration(root), ensureChatMigration(root), ensureShopMigration(root), ensureLoungeMigration(root), ensureShopReservations(root), ensureShopLines(root), ensureAppsMigration(root), ensurePartsMigration(root), ensurePartsStateMigration(root), ensureMcpMigration(root), ensureFunctionsMigration(root), ensureFunctionCursors(root), ensureFunctionMeta(root), ensureFunctionReference(root), ensureShopRemoveReferrals(root), ensureFunctionRuns(root), ensureToolDatabase(root), ensureBookings(root), ensureSubscriptions(root), ensureAppLive(root), ensureBusinessEvents(root), ensureBookingHolds(root),ensureBookingResources(root)].filter(Boolean);
 }
 
 /** What a migration file the template added is for, in a few words (deploy and dev say it). */