@homie-rocks/studio 0.51.3 → 0.51.5

package/rules/view.ts

@@ -728,6 +728,10 @@ export function openRoom<R = unknown>(opts: OpenRoomOptions = {}): Room<R> {
     while (stepped < t) {
       stepped += 1;
       step(stepped, stepped === t);
+      // fire() can read/cache the own entity before this pump advances it.
+      // A renderer later in the same callback must see the completed step,
+      // not hold that effect's old pose until the next (possibly early) frame.
+      presentedEntity = null;
       if (stepped % sendEvery === sendEvery - 1) flush(now, stepped);
     }
   }

package/shop/SHOP.md

@@ -101,26 +101,68 @@ One order stores every line and its item snapshot. `/api/shop/mine` lists the li
 
 `homie-studio shop init --supporter` writes an example item and `SELLING.md`, without a policy, cap or refund
 window. `shop check` validates settings; the build uses the same validation.
-`shop connect` (MCP `stripe_login`) starts Stripe's official browser approval, sandbox/test first.
-If Stripe CLI is missing, the result gives `npm install -g @stripe/cli@latest` for the AI to run.
-The person never supplies a key to the AI. A studio-specific CLI profile avoids borrowing another studio's login.
-If the studio is not deployed yet, approval is retained: deploy with `studio_deploy` (and
-`cloudflare_login` first if needed), then rerun connect. Webhooks require the deployed HTTPS address.
-
-**The default is keyless.** Connect syncs one Product and Price for each shop.json item and one
-Payment Link for each paid item, adjustable-quantity menus, and one capacity-limited link per published booking slot. Tip Prices use custom amounts; free orders stay local. It creates
-an account webhook at `<site>/api/shop/hook`, captures its signing secret without displaying it,
-and installs `STRIPE_WEBHOOK_SECRET` and `STRIPE_SHOP_LINKS` through Wrangler stdin. No Stripe
-API key goes into the Worker. Repeat connect after editing shop.json: changed prices get new
-Price versions, changed links get new versions, and removed objects are archived. Old paid orders
-keep their frozen item definitions. Receipts contain no credentials. Unchanged runs create nothing.
-
-With an existing account and deployed studio, the person approves Stripe CLI once; an already
-connected profile needs zero new approvals. An MCP-only grant is separate and is never extracted.
-The AI installs tooling, creates/syncs objects and stores the secret. New account verification,
-activation, administrator access settings and Cloudflare authorization are separate prerequisites.
-`shop connect --live` requires the owner's go-live request. `--renew` retries browser authorization.
-Never request a key from the person for the default flow.
+## Default: Stripe's official plugin
+
+Use Stripe's official plugin, authenticated with its browser OAuth approval, for Products,
+Prices, Payment Links, menu links, per-slot booking links, monthly giving and the customer
+portal. Install with `stripe agent setup` if needed; the MCP URL is
+`https://mcp.stripe.com`. Current tools are `stripe_api_search`, `stripe_api_details`,
+`stripe_api_read` and `stripe_api_write`. Discover the operation and its schema before
+calling it; tool argument shapes can change. See https://docs.stripe.com/mcp.
+
+1. Create/check `shop.json`. Read the app's published slot records and supply the complete
+   slot manifest described below. Select the owner's account and sandbox in Stripe's plugin;
+   read `/v1/account` to record its account ID. Live mode only after the owner requests it.
+2. Call Homie's `stripe_shop_plan` with `account`, `mode: "test"`, `slots` and
+   `observations: []`. CLI equivalent: `homie-studio shop plan --have plan-input.json`.
+   That JSON file contains the same fields. A returned `next` is the exact operation:
+   method, API path, parameters, API version and (for creates) idempotency key. Updates set desired fields; read before retrying. Metadata
+   scopes objects to this studio and origin; prices and links have content revisions.
+3. Perform each `next` through Stripe's official MCP. For GET, append
+   `{ "path": "…", "params": {…}, "body": <Stripe response> }` to `observations`
+   and plan again. Follow every pagination request. After a write, discard observations
+   and read fresh. Replanning resolves real Stripe IDs; never invent IDs or substitute
+   a different price. Reuse the supplied idempotency key where the tool supports it;
+   otherwise read before retrying and match the stable product ID/revision metadata.
+4. When no writes remain, use fresh reads with `stripe_shop_plan` `verify: true`
+   (CLI `homie-studio shop verify --have plan-input.json`). It checks the catalog,
+   actual link fields and line items, menus, slot limits and portal settings against
+   shop.json and the slot manifest. A mismatch blocks verification. It saves only public
+   configuration to `.studio/stripe-mcp.json`; 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
+   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
+   archive replaced catalog objects, then verify fresh reads again. Test a sandbox
+   purchase and its signed event, order grant, booking capacity or recurring invoice;
+   a browser return is never proof. Stripe CLI `trigger` can send a test event, and
+   `events resend <event> --webhook-endpoint <endpoint>` retries a delivery. Check the
+   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.
+
+Never create a webhook through model-visible Stripe MCP: its response exposes the signing secret.
+
+The owner never handles an API key or signing secret. No Homie backend handles payments.
+The Worker needs only public link configuration and the signing secret; buyers pay
+Stripe directly even when the AI and the owner's computer are offline. The old
+`stripe_login` / `shop connect` flow remains an alternative that syncs everything
+through Stripe CLI browser approval. `--renew` renews that approval; `--live` requires
+the owner's go-live request. Never read CLI config or print login-completion output.
+
+For local checkout, pass `url: "http://localhost:8787"` (or the private Wi-Fi address)
+and `mode: "test"` to the same plan/verify flow; the official plugin makes the links.
+Run `homie-studio shop listen --profile <sandbox-profile>` in a background terminal.
+Stripe CLI is required for forwarding; one browser approval is enough if needed.
+The command captures and saves the listener secret privately. Start/restart
+`homie-studio dev --lan` once it reports ready and keep the listener running.
+Never copy the listener's raw output into the conversation.
+
+For a faster local iteration, `homie-studio build --quick` skips generated rules play
+and the snapshot smoke-run, while retaining compilation, guards and type checks.
+Run a full build before release; quick output is not evidence that play checks passed.
 
 At purchase time, the Worker saves an opaque order reference and sends it as the link's
 `client_reference_id`. The buyer confirms quantity or tip amount on Stripe. A signed snapshot
@@ -142,17 +184,7 @@ items; failed refunds restore the financial booking. A lost dispute revokes good
 | Managed Payments | Payment Links support managed_payments.enabled; connect uses it when the studio selects Stripe as seller, subject to Stripe eligibility and terms. |
 | Currency display | Payment Links always enable Stripe Adaptive Pricing. Bookkeeping uses integration currency; presentment details describe what the customer saw. |
 
-A key alone never selects the fuller path. It requires explicit `STRIPE_CHECKOUT_MODE=sessions` as well as a Worker key. Only if requested, explain: “The optional session connection adds exact app-built carts, spending reservations, expiring holds and runtime refunds.”
-The explicit `shop connect --manual` path remains available, including `--live`, but requires the
-owner's existing Dashboard key step; it does not satisfy one approval. Never choose it automatically.
-Running default connect again saves links, removes the API key, and keeps signed-event fulfillment.
-When switching to spending restrictions, the AI must deactivate previously issued Payment Links through
-the approved CLI and resolve in-flight checkouts before relying on those restrictions; switching credentials
-does not cancel old Stripe sessions. The runtime OAuth finding and sources are in `docs/stripe-connect-research.md` in the source checkout.
-
-`shop`, `shop orders`, and `/_studio/office/shop` show readiness and sales. Stripe's optional MCP
-is useful for owner-requested refunds and analytics; honor its approval links. Do not create a
-secret-returning webhook through a conversation tool: the private connect process owns that call.
+`shop`, `shop orders`, and `/_studio/office/shop` show readiness and sales. Use Stripe's official MCP for owner-requested refunds and analytics; honor its approval links.
 
 ## Payment guarantees and schema
 
@@ -220,7 +252,7 @@ For referrals, use Stripe Connect to split payments or a Stripe-based affiliate
 
 ## Keyless menus, paid seats and monthly giving (0.51.0)
 
-Use `shop connect` by default. All objects belong to the owner's Stripe account and
+Use the official MCP plan/verify flow by default. All objects belong to the owner's Stripe account and
 are created through its approved CLI session. Homie has no platform key, OAuth
 backend, payment intermediary or cut. A desktop is needed to sync, not to take money.
 
@@ -251,7 +283,7 @@ data goes in that reference. A return URL is never proof of payment.
 collection with integer `capacity` and a server-managed `bookings` collection with
 `"booking":{"slots":"slots","item":"full-tune"}`. Publish slot records, then have
 the owner's AI write the complete manifest to `.studio/booking-slots.json` and run
-`shop connect`, or call local MCP `stripe_bookings_sync` with the same `slots` array:
+`stripe_shop_plan` with the same `slots` array (the CLI alternative is `stripe_bookings_sync`):
 
 ```json
 [{"app":"tune","collection":"bookings","slots":"slots","slot":"sat-0900","item":"full-tune","capacity":1}]
@@ -303,7 +335,7 @@ Signed `subscription.started`, `.renewed`, `.failed`, `.cancelled` events drive
 membership and giving. Membership access ends at the paid invoice line's period end;
 failed invoices cannot extend it and cancellation ends access. Unknown Prices grant
 nothing. Keyless portal configuration supports cancellation, payment-method updates
-and invoice history. `shop connect` enables `login_page.enabled` through the CLI API
+and invoice history. The official MCP plan enables `login_page.enabled` through Stripe’s API
 and stores Stripe's no-code login URL; **no Dashboard toggle is required**. Givers
 verify their email with Stripe to manage/cancel. The buyer-owned `/api/shop/portal`
 returns this URL. Plan changes require deliberate portal configuration and fulfilment

package/worker/build-id.mjs

@@ -1,2 +1,2 @@
 // Generated by lib/build-identity.mjs; identifies the bundled runtime sources.
-export const STUDIO_BUILD = Object.freeze({"version":"0.51.3","sha256":"ac8867ee4a8f906ed64a106d28d60921552d1caad2d99dd70467ae42e70aea75"});
+export const STUDIO_BUILD = Object.freeze({"version":"0.51.5","sha256":"1e11f3b33959ff475ed31b5e5e0b5b4e7a155be104d47db80901422409830b23"});

package/worker/event-resources.mjs

@@ -1,3 +1,6 @@
+import {McpEventStreams} from './mcp-event-streams.mjs';
+import {listEvents} from './mcp-events.mjs';
+import {notification,sseFrame} from './mcp-events-wire.mjs';
 import {allowed,currentCaller} from './mcp-tools.mjs';
 import {settingsOf,launchOf} from './office.mjs';
 
@@ -44,9 +47,10 @@ export function eventHub(env,connection) {return env.LOBBY.get(env.LOBBY.idFromN
 export async function pushEvents(env,cat,origin) {
   if(!env.LOBBY||!Object.keys(eventFeeds(env)).length)return;
   // Page subscriptions, without a studio-wide subscription or delivery cap.
+  await env.DB.prepare("DELETE FROM mcp_kv WHERE key LIKE 'mcp-event-stream:%' AND expires<?1").bind(Date.now()).run();
   let after='';const seen=new Set();
   for(;;){
-    const rows=(await env.DB.prepare("SELECT key,value FROM mcp_kv WHERE key LIKE 'event-sub:%' AND key>?1 ORDER BY key LIMIT 100").bind(after).all()).results;
+    const rows=(await env.DB.prepare("SELECT key,value FROM mcp_kv WHERE (key LIKE 'event-sub:%' OR key LIKE 'mcp-event-stream:%' OR key LIKE 'tools-stream:%') AND key>?1 ORDER BY key LIMIT 100").bind(after).all()).results;
     for(const row of rows){const {connection}=JSON.parse(row.value);if(seen.has(connection))continue;seen.add(connection);
       const response=await eventHub(env,connection).fetch('https://events/__studio_events',{method:'POST',body:JSON.stringify({op:'wake',connection,cat,origin})});
       if(!response.ok)throw new Error('Event stream wake failed');
@@ -58,11 +62,13 @@ export async function pushEvents(env,cat,origin) {
 /** One existing Lobby object per OAuth connection: streams never live in a Worker isolate. */
 const streamCaller=(env,connection)=>connection.startsWith('public:')?Promise.resolve({id:null,owner:false,client:null,connection}):currentCaller(env,{connection});
 export class EventStreams {
-  constructor(env,ctx){this.env=env;this.ctx=ctx;this.stream=null;this.tail=Promise.resolve();}
+  constructor(env,ctx){this.env=env;this.ctx=ctx;this.stream=null;this.tail=Promise.resolve();this.extensions=new McpEventStreams(env,ctx);}
   close(stream){stream.cancelled=true;stream.resume?.();try{stream.controller.close();}catch{}if(this.stream===stream){this.stream=null;this.ctx.waitUntil(this.env.DB.prepare('DELETE FROM mcp_kv WHERE key=?1').bind('tools-stream:'+stream.connection).run().catch(()=>{}));}}
   background(input){this.ctx.waitUntil(this.wake(input).catch(error=>{if(this.stream)this.close(this.stream);console.error('Event stream delivery failed',error);}));}
   async fetch(request) {
     const input=await request.json();
+    if(input.op==='extension-stream')return this.extensions.open(input);
+    this.extensions.wake(input);
     if(input.op==='tools') {await this.wake(input);return new Response(null,{status:204});}
     if(input.op==='stream') {
       // A reconnect replaces the previous GET, including a half-open socket.
@@ -78,6 +84,7 @@ export class EventStreams {
       const caller=await streamCaller(this.env,connection).catch(()=>null);
       if(!caller){this.close(stream);return new Response('Unauthorized',{status:401});}
       stream.toolSignature=await this.toolSignature(input.tools??[],caller);
+      stream.eventSignature=JSON.stringify(await listEvents(this.env,input.cat,caller));
       await this.env.DB.prepare('INSERT INTO mcp_kv(key,value) VALUES(?1,?2) ON CONFLICT(key) DO UPDATE SET value=excluded.value').bind('tools-stream:'+connection,JSON.stringify({connection})).run();
       // Replay and later wakes share one ordered pump. Backpressure must not
       // hold up the writer's request or a function handler.
@@ -93,6 +100,8 @@ export class EventStreams {
     let caller;
     try{caller=await streamCaller(this.env,input.connection);}
     catch{this.close(stream);return;}
+    const eventSignature=JSON.stringify(await listEvents(this.env,input.cat,caller));
+    if(stream.eventSignature!==eventSignature){stream.eventSignature=eventSignature;stream.controller.enqueue(sseFrame(notification('list_changed',{})));}
     if(input.tools){
       const signature=await this.toolSignature(input.tools,caller);
       if(stream.toolSignature!==signature){stream.toolSignature=signature;stream.controller.enqueue(new TextEncoder().encode('event: message\ndata: '+JSON.stringify({jsonrpc:'2.0',method:'notifications/tools/list_changed'})+'\n\n'));}
@@ -130,7 +139,7 @@ export class EventStreams {
 export async function pushToolList(env,cat,tools,origin) {
   if(!env.LOBBY)return;
   const publicShape=tools.map(({name,description,inputSchema,audience,kind})=>({name,description,inputSchema,audience,kind}));
-  const signature=JSON.stringify(publicShape);
+  const signature=JSON.stringify([publicShape,eventFeeds(env)]);
   const previous=await env.DB.prepare("SELECT value FROM mcp_kv WHERE key='tools-catalogue'").first();
   if(previous?.value===signature)return;
   await env.DB.prepare("INSERT INTO mcp_kv(key,value) VALUES('tools-catalogue',?1) ON CONFLICT(key) DO UPDATE SET value=excluded.value").bind(signature).run();

package/worker/event-webhooks.mjs

@@ -10,7 +10,7 @@ export async function readableWebhook(env,cat,feed) {
   if((feed.audience??'owner')==='owner')return true;
   return feed.audience?.app===app.id && app.roles?.[feed.audience.role]?.can?.includes('read:'+feed.collection)===true && launchOf(app,await settingsOf(env,{fresh:true}),env)==='public';
 }
-class WebhookFailure extends Error {
+export class WebhookFailure extends Error {
   constructor(message){super(message);this.name='WebhookFailure';}
 }
 export function webhookFailure(error){return error instanceof WebhookFailure?error.message:'Webhook delivery failed';}
@@ -21,23 +21,28 @@ export async function postWebhook(env,name,event,{fetchFn=globalThis.fetch.bind(
   validateWebhook(name,hook);
   const secret=env[hook.secret];
   if(typeof secret!=='string'||!/^whsec_[A-Za-z0-9+/]{43}=$/.test(secret))throw new WebhookFailure('Webhook signing secret unavailable');
-  const key=await crypto.subtle.importKey('raw',Uint8Array.from(atob(secret.slice(6)),c=>c.charCodeAt(0)),{name:'HMAC',hash:'SHA-256'},false,['sign']);
-  // Encode the event ID to avoid ambiguous dot-delimited signatures and invalid headers.
   const id='evt_'+btoa(String.fromCharCode(...new TextEncoder().encode(event.id))).replaceAll('+','-').replaceAll('/','_').replaceAll('=','');
+  return signedWebhook(hook.url,{id,body:{id:event.id,type:event.type,at:event.at,data:event.data},secrets:[secret]},{fetchFn,now,timeoutMs});
+}
+/** Shared transport for configured studio hooks and MCP Events subscriptions. */
+export async function signedWebhook(url,{id,body,secrets,headers={}},{fetchFn=globalThis.fetch.bind(globalThis),now=Date.now,timeoutMs=10000}={}) {
   const timestamp=String(Math.floor(now()/1000));
-  const body=JSON.stringify({id:event.id,type:event.type,at:event.at,data:event.data});
-  const signature=btoa(String.fromCharCode(...new Uint8Array(await crypto.subtle.sign('HMAC',key,new TextEncoder().encode(`${id}.${timestamp}.${body}`)))));
-  const controller=new AbortController();const timer=setTimeout(()=>controller.abort(),timeoutMs);
+  const encoded=JSON.stringify(body),signatures=[];
+  for(const secret of secrets){
+    const key=await crypto.subtle.importKey('raw',Uint8Array.from(atob(secret.slice(6)),c=>c.charCodeAt(0)),{name:'HMAC',hash:'SHA-256'},false,['sign']);
+    signatures.push('v1,'+btoa(String.fromCharCode(...new Uint8Array(await crypto.subtle.sign('HMAC',key,new TextEncoder().encode(`${id}.${timestamp}.${encoded}`))))));
+  }
+  const controller=new AbortController(),timer=setTimeout(()=>controller.abort(),timeoutMs);
   try {
-    const response=await fetchFn(hook.url,{method:'POST',redirect:'manual',signal:controller.signal,headers:{'content-type':'application/json','webhook-id':id,'webhook-timestamp':timestamp,'webhook-signature':'v1,'+signature},body});
-    // Never read or log receiver content: it may echo credentials or private records.
+    const response=await fetchFn(url,{method:'POST',redirect:'manual',signal:controller.signal,headers:{'content-type':'application/json','webhook-id':id,'webhook-timestamp':timestamp,'webhook-signature':signatures.join(' '),...headers},body:encoded});
     await response.body?.cancel();
-    if(!response.ok)throw new WebhookFailure('Webhook HTTP '+response.status);
+    if(!response.ok){const error=new WebhookFailure('Webhook HTTP '+response.status);error.status=response.status;throw error;}
   }catch(error){
     if(error instanceof WebhookFailure)throw error;
     throw new WebhookFailure(controller.signal.aborted?'Webhook timed out':'Webhook network failure');
   }finally{clearTimeout(timer);}
 }
+
 export function webhookSubscriptions(env,cat,options={}) {
   return Object.entries(eventFeeds(env)).filter(([,feed])=>feed.webhook).map(([name,feed])=>({
     name:webhookName(name,feed.webhook),event:feed.event,webhook:true,

package/worker/functions.mjs

@@ -1,3 +1,4 @@
+import {eventHookSubscriptions} from './mcp-events.mjs';
 import {webhookSubscriptions,webhookFailure,webhookBackoff} from './event-webhooks.mjs';
 import {parseSchedule,scheduleStatus} from './function-schedule.mjs';
 import {redactText} from '../lib/redact.mjs';
@@ -15,7 +16,7 @@ export async function syncFunctions(env, definitions = null, now = Date.now()) {
   // Deploy owns the production registry; an old in-flight Worker must not overwrite it.
   if(await env.DB.prepare("SELECT 1 FROM meta WHERE key='function-registry-deployed'").first())return definitions;
   const statements=definitions.map(fn=>env.DB.prepare(`INSERT INTO function_subscriptions(name,type,cursor,started) VALUES(?1,?2,(SELECT COALESCE(MAX(seq),0) FROM studio_events),?3) ON CONFLICT(name) DO UPDATE SET type=excluded.type,cursor=excluded.cursor,started=excluded.started WHERE type!=excluded.type`).bind(fn.name,fn.event,now));
-  statements.push(env.DB.prepare(`DELETE FROM function_subscriptions WHERE name NOT IN (SELECT value FROM json_each(?1))`).bind(JSON.stringify(definitions.map(f=>f.name))));
+  statements.push(env.DB.prepare(`DELETE FROM function_subscriptions WHERE name NOT LIKE '@mcp-webhook/%' AND name NOT IN (SELECT value FROM json_each(?1))`).bind(JSON.stringify(definitions.map(f=>f.name))));
   await env.DB.batch(statements);
   return definitions;
 }
@@ -33,7 +34,7 @@ export async function pruneEvents(env) {
   const cursor=Number((await env.DB.prepare("SELECT value FROM meta WHERE key='function-prune-cursor'").first())?.value??0);
   const rows=(await env.DB.prepare('SELECT seq,id FROM studio_events WHERE seq>?1 ORDER BY seq LIMIT 100').bind(cursor).all()).results;
   const statements=rows.flatMap(({id})=>[
-    env.DB.prepare(`DELETE FROM function_deliveries WHERE event=?1 AND ((state='complete' AND function NOT LIKE '@webhook/%') OR NOT EXISTS (SELECT 1 FROM function_subscriptions s WHERE s.name=function_deliveries.function))`).bind(id),
+    env.DB.prepare(`DELETE FROM function_deliveries WHERE event=?1 AND ((state='complete' AND function NOT LIKE '@webhook/%' AND function NOT LIKE '@mcp-webhook/%') OR NOT EXISTS (SELECT 1 FROM function_subscriptions s WHERE s.name=function_deliveries.function))`).bind(id),
     env.DB.prepare(`DELETE FROM studio_events WHERE id=?1 AND NOT EXISTS (SELECT 1 FROM function_subscriptions s WHERE s.type=studio_events.type AND s.cursor<studio_events.seq) AND NOT EXISTS (SELECT 1 FROM function_deliveries d WHERE d.event=studio_events.id)`).bind(id),
   ]);
   statements.push(env.DB.prepare("INSERT INTO meta(key,value) VALUES('function-prune-cursor',?1) ON CONFLICT(key) DO UPDATE SET value=excluded.value").bind(String(rows.at(-1)?.seq??0)));
@@ -41,10 +42,11 @@ export async function pruneEvents(env) {
 }
 /** A lease is for retry after a crashed Worker, not a deadline imposed on studio code. */
 export async function runFunctions(env, cat, origin, {definitions, now = Date.now, leaseMs = 60000, webhookOptions = {}} = {}) {
+  if(!env.DB)return;
   definitions = await syncFunctions(env,definitions,now());
-  if(!definitions.length)return;
+  if(!definitions.length&&!env.STUDIO_EVENT_FEEDS)return;
   if(typeof cat==='function')cat=await cat();
-  definitions=definitions.filter(fn=>!fn.webhook).concat(webhookSubscriptions(env,cat,webhookOptions));
+  definitions=definitions.filter(fn=>!fn.webhook).concat(webhookSubscriptions(env,cat,webhookOptions),env.STUDIO_EVENT_FEEDS?await eventHookSubscriptions(env,cat,{...webhookOptions,now}):[]);
   // An AI notification must not wait behind a slow function handler.
   const notify=()=>pushEvents(env,cat,origin).catch(error=>console.error('Event notification wake failed',error));
   const notifications=notify();
@@ -72,18 +74,21 @@ export async function runFunctions(env, cat, origin, {definitions, now = Date.no
           env.DB.prepare("INSERT INTO function_runs(id,function,event,trigger,started,outcome,attempt) SELECT ?1,?2,?3,?4,?5,'running',attempts FROM function_deliveries WHERE event=?3 AND function=?2 AND lease=?1").bind(lease,fn.name,row.event,row.event.startsWith(`schedule:${fn.name}:`)?`schedule: ${JSON.parse(row.data).cron}`:row.type,started),
         ]);
         if (!claimed.meta.changes) continue;
-        let failure=null;
+        let failure=null,permanent=false;
         try {
           const stored=JSON.parse(row.data);
           const isolated=env.HOMIE_LOCAL_TEST_SECRET && /^([a-z][a-z0-9-]*):check:([a-zA-Z0-9-]+)$/.exec(stored?.app??'');
           const event=Object.freeze({id:row.event,type:row.type,at:row.at,data:isolated?{...stored,app:isolated[1]}:stored,attempt:row.attempts+1});
           const testScope=isolated?isolated[2]:null;
           await fn.handler(event,services(env,cat,origin,{id:'studio-function',owner:true,client:null,...(testScope?{testScope}:{})},'function:'+fn.name+(testScope?':check:'+testScope:''),fn));
-        } catch(error) {failure=fn.webhook?webhookFailure(error):functionError(error,env);}
+        } catch(error) {permanent=error.permanent===true;failure=fn.webhook?webhookFailure(error):functionError(error,env);}
         const finished=now();
+        const firstAttempt=fn.mcpEvent?(await env.DB.prepare('SELECT MIN(started) at FROM function_runs WHERE event=?1 AND function=?2').bind(row.event,fn.name).first()).at:finished;
+        const abandoned=fn.mcpEvent&&failure!==null&&(permanent||row.attempts+1>=5||finished-firstAttempt>=900000);
         await env.DB.batch([
           failure===null
             ? env.DB.prepare(`UPDATE function_deliveries SET state='complete',completed=?4,error=NULL WHERE event=?1 AND function=?2 AND lease=?3`).bind(row.event,fn.name,lease,finished)
+            : abandoned ? env.DB.prepare(`UPDATE function_deliveries SET state='complete',completed=?4,error=?5 WHERE event=?1 AND function=?2 AND lease=?3`).bind(row.event,fn.name,lease,finished,failure)
             : env.DB.prepare(`UPDATE function_deliveries SET state='failed',error=?5,due=?4 WHERE event=?1 AND function=?2 AND lease=?3`).bind(row.event,fn.name,lease,finished+(fn.webhook?webhookBackoff(row.attempts+1):leaseMs),fn.webhook?failure:'Function failed; inspect its code and retry'),
           env.DB.prepare("UPDATE function_runs SET outcome=?2,finished=?3,error=?4 WHERE id=?1").bind(lease,failure===null?'complete':'failed',finished,failure),
         ]);

package/worker/index.mjs

@@ -189,7 +189,11 @@ async function availableShellShop(env, cat, game, options) {
   // The shell can show a disabled catalog before payment setup is complete.
   // Checkout readiness is enforced by the shop API, separately from visibility.
   const preview = (cat.games ?? []).find(g => g.id === game)?.screen?.shopPreview === true;
-  return (preview && !shopOf(cat)?.broken || await sellingShop(env, cat)) ? shellShop(cat, game, options) : null;
+  const shop = shopOf(cat);
+  // Free services must retain their bridge in a mixed free/paid catalogue.
+  // Paid readiness, policy and atomic booking capacity remain API decisions.
+  const free = shop?.open && !shop.broken && shop.items.some(i => i.price === 0 && !i.interval && (!i.game || i.game === game));
+  return (preview && !shop?.broken || free || await sellingShop(env, cat)) ? shellShop(cat, game, options) : null;
 }
 
 async function postsOf(env, origin) {

package/worker/mcp-event-streams.mjs

@@ -0,0 +1,58 @@
+import {eventSource,eventCaller,checkEvent,eventStart,pollEvents} from './mcp-events.mjs';
+import {EVENT_ERRORS,terminalEventError,EventsError,eventError,notification,sseFrame,streamResult,cursorOf} from './mcp-events-wire.mjs';
+
+/** Connection-scoped push subscriptions hosted by the existing per-connection Lobby. */
+export class McpEventStreams {
+  constructor(env,ctx){this.env=env;this.ctx=ctx;this.streams=new Set();}
+  close(stream){if(stream.closed)return;stream.closed=true;clearInterval(stream.timer);stream.resume?.();try{stream.controller.close();}catch{}this.streams.delete(stream);if(stream.registryKey)this.ctx.waitUntil(this.env.DB.prepare('DELETE FROM mcp_kv WHERE key=?1').bind(stream.registryKey).run().catch(()=>{}));}
+  async write(stream,value,authorize){
+    if(stream.closed)return false;
+    if(stream.controller.desiredSize<=0)await new Promise(resolve=>{stream.resume=resolve;});
+    if(stream.closed)return false;
+    if(authorize)await authorize();
+    try{stream.controller.enqueue(sseFrame(value));return true;}catch{this.close(stream);return false;}
+  }
+  wake(input){for(const stream of this.streams){if(input.cat)stream.cat=input.cat;this.pump(stream);}}
+  pump(stream){if(stream.busy||stream.closed)return;stream.busy=true;this.ctx.waitUntil(this.deliver(stream).catch(()=>this.close(stream)).finally(()=>{stream.busy=false;}));}
+  async open(input){
+    try{
+      const caller=await eventCaller(this.env,input.connection);const feed=await checkEvent(this.env,input.cat,caller,input.params);
+      const start=await eventStart(this.env,input.params);
+      const registryKey='mcp-event-stream:'+input.connection+':'+crypto.randomUUID();
+      await this.env.DB.prepare('INSERT INTO mcp_kv(key,value,expires) VALUES(?1,?2,?3)').bind(registryKey,JSON.stringify({connection:input.connection}),Date.now()+60000).run();
+      const stream={...input,registryKey,source:eventSource(feed),cursor:cursorOf(input.params.name,start.after),closed:false,busy:false};
+      const body=new ReadableStream({start:controller=>{stream.controller=controller;controller.enqueue(sseFrame(notification('active',{cursor:stream.cursor,truncated:start.truncated},stream.id)));},pull:()=>{const resume=stream.resume;stream.resume=null;resume?.();},cancel:()=>this.close(stream)});
+      this.streams.add(stream);
+      // Heartbeats also recheck authorization, catch missed wakes and renew discovery.
+      stream.timer=setInterval(()=>this.pump(stream),15000);
+      this.pump(stream);
+      return new Response(body,{headers:{'content-type':'text/event-stream','cache-control':'no-store'}});
+    }catch(error){return Response.json({jsonrpc:'2.0',id:input.id,error:eventError(error)});}
+  }
+  async deliver(stream){
+    try{
+      let more=true;
+      while(more&&!stream.closed){
+        const caller=await eventCaller(this.env,stream.connection);
+        const feed=await checkEvent(this.env,stream.cat,caller,stream.params);
+        if(stream.source!==eventSource(feed))throw new EventsError(EVENT_ERRORS.unsupported,{feature:'payloadSchema',reason:'schema_changed'});
+        const start=await eventStart(this.env,{name:stream.params.name,cursor:stream.cursor});
+        if(start.truncated){stream.cursor=cursorOf(stream.params.name,start.after);await this.write(stream,notification('active',{cursor:stream.cursor,truncated:true},stream.id));}
+        const page=await pollEvents(this.env,stream.cat,caller,{...stream.params,maxAgeMs:undefined,cursor:stream.cursor});
+        for(const event of page.events){
+          await checkEvent(this.env,stream.cat,await eventCaller(this.env,stream.connection),stream.params);
+          if(!await this.write(stream,notification('event',event,stream.id),async()=>checkEvent(this.env,stream.cat,await eventCaller(this.env,stream.connection),stream.params)))return;
+          stream.cursor=event.cursor;
+        }
+        stream.cursor=page.cursor;more=page.hasMore;
+      }
+      await this.env.DB.prepare('UPDATE mcp_kv SET expires=?2 WHERE key=?1').bind(stream.registryKey,Date.now()+60000).run();
+      await this.write(stream,notification('heartbeat',{cursor:stream.cursor},stream.id));
+    }catch(error){
+      const details=eventError(error);
+      if(terminalEventError(details.code)){
+        await this.write(stream,notification('terminated',{error:details},stream.id));await this.write(stream,streamResult(stream.id));this.close(stream);
+      }else await this.write(stream,notification('error',{error:details},stream.id));
+    }
+  }
+}

package/worker/mcp-events-wire.mjs

@@ -0,0 +1,41 @@
+/** Experimental MCP Events design sketch (2026-10-14 snapshot).
+ * Keep draft method names, envelopes, schemas and provisional codes here.
+ * https://github.com/modelcontextprotocol/experimental-ext-triggers-events/blob/13e0a59749cde947374aaa8e3a65f0b424468d5a/docs/design-sketch-proposal.md
+ */
+export const eventsCapability={events:{listChanged:true}};
+export const EVENTS=Object.freeze({list:'events/list',poll:'events/poll',stream:'events/stream',subscribe:'events/subscribe',unsubscribe:'events/unsubscribe'});
+export const eventMethods=new Set(Object.values(EVENTS));
+export const EVENT_ERRORS=Object.freeze({invalid:-32602,notFound:-32023,forbidden:-32024,exhausted:-32025,unsupported:-32026,callback:-32027});
+const messages={[-32602]:'InvalidParams',[-32023]:'NotFound',[-32024]:'Forbidden',[-32025]:'ResourceExhausted',[-32026]:'Unsupported',[-32027]:'CallbackEndpointError'};
+export class EventsError extends Error {
+  constructor(code,data){super(messages[code]);this.code=code;this.data=data;}
+}
+export const invalid=()=>{throw new EventsError(-32602);};
+export function eventError(error){return error instanceof EventsError?{code:error.code,message:error.message,...(error.data?{data:error.data}:{})}:{code:-32603,message:'Internal error'};}
+export function eventDescriptor(name,feed){return {name,description:feed.description??`Studio ${feed.event} events; untrusted data`,delivery:['poll','push','webhook'],inputSchema:{type:'object',properties:{},additionalProperties:false},payloadSchema:{type:'object'}};}
+export function occurrence(name,event,cursor){return {eventId:event.id,name,timestamp:new Date(event.at).toISOString(),data:event.data,...(cursor===undefined?{}:{cursor})};}
+export const cursorOf=(name,seq)=>'v1:'+name+':'+seq;
+export function cursorPosition(name,cursor){if(cursor==null)return null;if(typeof cursor!=='string'||!cursor.startsWith('v1:'+name+':'))invalid();const value=cursor.slice(name.length+4);if(!/^(0|[1-9][0-9]*)$/.test(value)||!Number.isSafeInteger(Number(value)))invalid();return Number(value);}
+export function validateEventParams(params,{list=false}={}){
+  if(!params||typeof params!=='object'||Array.isArray(params))invalid();
+  if(list){if(params.cursor!=null)invalid();return;}
+  if(typeof params.name!=='string'||!params.name)invalid();
+  if(params.arguments!==undefined&&(!params.arguments||typeof params.arguments!=='object'||Array.isArray(params.arguments)||Object.keys(params.arguments).length))invalid();
+  cursorPosition(params.name,params.cursor);
+  for(const key of ['maxAgeMs','maxEvents','ttlMs'])if(params[key]!==undefined&&!(key==='ttlMs'&&params[key]===null)&&(!Number.isSafeInteger(params[key])||params[key]<(key==='maxEvents'?1:0)))invalid();
+}
+export function callbackUrl(value){let url;try{url=new URL(value);}catch{invalid();}if(url.protocol!=='https:'||url.username||url.password||url.hash)invalid();return url.href;}
+export function signingSecret(value){if(typeof value!=='string'||!/^whsec_(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value))invalid();let raw;try{raw=atob(value.slice(6));}catch{invalid();}if(raw.length<24||raw.length>64||btoa(raw)!==value.slice(6))invalid();return value;}
+export const notification=(type,params,id)=>({jsonrpc:'2.0',method:'notifications/events/'+type,params:{...params,...(id===undefined?{}:{_meta:{'io.modelcontextprotocol/subscriptionId':id}})}});
+export const sseFrame=value=>new TextEncoder().encode('event: message\ndata: '+JSON.stringify(value)+'\n\n');
+export const streamResult=id=>({jsonrpc:'2.0',id,result:{_meta:{}}});
+export const control=(type,fields)=>({type,...fields});
+export const subscriptionResult=(sub,cursor,truncated,deliveryStatus)=>({id:sub.id,refreshBefore:new Date(sub.expires).toISOString(),cursor,truncated,...(deliveryStatus?{deliveryStatus}:{})});
+export const subscriptionHeaders=id=>({'X-MCP-Subscription-Id':id});
+/** Internal pages keep stable names; draft field changes stay at the transport boundary. */
+export function eventsResult(method,value){
+  if(method===EVENTS.list)return {events:value.events};
+  if(method===EVENTS.poll)return {events:value.events.map(({cursor,...event})=>event),cursor:value.cursor,truncated:value.truncated,hasMore:value.hasMore,nextPollMs:value.nextPollMs};
+  return value;
+}
+export const terminalEventError=code=>[EVENT_ERRORS.notFound,EVENT_ERRORS.forbidden,EVENT_ERRORS.unsupported].includes(code);

package/worker/mcp-events.mjs

@@ -0,0 +1,132 @@
+import {rateLimit,callsPerMinute} from './mcp-store.mjs';
+import {eventFeeds,readableFeed,matchesFeed,eventHub} from './event-resources.mjs';
+import {currentCaller} from './mcp-tools.mjs';
+import {signedWebhook,WebhookFailure} from './event-webhooks.mjs';
+import {EVENTS,EVENT_ERRORS,eventsResult,EventsError,invalid,eventError,eventDescriptor,occurrence,cursorOf,cursorPosition,validateEventParams,callbackUrl,signingSecret,subscriptionResult,subscriptionHeaders,control} from './mcp-events-wire.mjs';
+
+const prefix='mcp-event-hook:';
+export const eventSource=feed=>JSON.stringify([feed.event,feed.app??null,feed.collection??null]);
+export const hookFunction=id=>'@mcp-webhook/'+id;
+const head=async env=>(await env.DB.prepare('SELECT COALESCE(MAX(seq),0) seq FROM studio_events').first()).seq;
+export async function eventCaller(env,connection){
+  if(connection==='local-test-owner'&&env.HOMIE_LOCAL_TEST_SECRET)return {id:'local-test-owner',owner:true,connection};
+  try{return await currentCaller(env,{connection});}catch{throw new EventsError(EVENT_ERRORS.forbidden);}
+}
+export async function checkEvent(env,cat,caller,params){
+  validateEventParams(params);
+  const feeds=eventFeeds(env),feed=Object.hasOwn(feeds,params.name)?feeds[params.name]:null;
+  if(!feed)throw new EventsError(EVENT_ERRORS.notFound,{kind:'event'});
+  if(!await readableFeed(env,cat,caller,params.name))throw new EventsError(EVENT_ERRORS.forbidden);
+  return feed;
+}
+export async function listEvents(env,cat,caller,params={}){
+  validateEventParams(params,{list:true});const events=[];
+  for(const [name,feed] of Object.entries(eventFeeds(env)))if(await readableFeed(env,cat,caller,name))events.push(eventDescriptor(name,feed));
+  return {events};
+}
+export async function eventStart(env,params,now=Date.now()){
+  const through=await head(env);let after=cursorPosition(params.name,params.cursor),truncated=false;
+  if(after===null)return {after:through,through,truncated};
+  if(after>through){after=through;truncated=true;}
+  const first=(await env.DB.prepare('SELECT MIN(seq) seq FROM studio_events').first()).seq;
+  if(first!==null&&after<first-1){after=first-1;truncated=true;}
+  if(params.maxAgeMs!==undefined){const floor=(await env.DB.prepare('SELECT COALESCE(MAX(seq),0) seq FROM studio_events WHERE at<?1 AND seq<=?2').bind(now-params.maxAgeMs,through).first()).seq;if(floor>after){after=floor;truncated=true;}}
+  return {after,through,truncated};
+}
+export async function pollEvents(env,cat,caller,params,now=Date.now()){
+  const feed=await checkEvent(env,cat,caller,params),start=await eventStart(env,params,now);
+  const max=Math.min(params.maxEvents??100,100);
+  // Filter before limiting: unrelated collections must not create a false hasMore
+  // or force the client through pages containing no matching occurrences.
+  const rows=(await env.DB.prepare(`SELECT seq,id,type,data,at FROM studio_events
+    WHERE type=?1 AND seq>?2 AND seq<=?3
+      AND (?4 IS NULL OR (json_extract(data,'$.app')=?4 AND json_extract(data,'$.collection')=?5))
+    ORDER BY seq LIMIT ?6`).bind(feed.event,start.after,start.through,feed.event==='record.changed'?feed.app:null,feed.collection??null,max+1).all()).results;
+  const hasMore=rows.length>max,page=rows.slice(0,max);
+  const events=page.map(row=>occurrence(params.name,{...row,data:JSON.parse(row.data)},cursorOf(params.name,row.seq)));
+  const after=hasMore?page.at(-1).seq:start.through;
+  return {events,cursor:cursorOf(params.name,after),truncated:start.truncated,hasMore,nextPollMs:5000};
+}
+async function subId(caller,params,url){const bytes=await crypto.subtle.digest('SHA-256',new TextEncoder().encode(JSON.stringify([caller.id,url,params.name,{}])));return 'sub_'+Array.from(new Uint8Array(bytes),b=>b.toString(16).padStart(2,'0')).join('');}
+async function stored(env,id){const row=await env.DB.prepare('SELECT value FROM mcp_kv WHERE key=?1').bind(prefix+id).first();return row?JSON.parse(row.value):null;}
+export async function removeEventHook(env,id){await env.DB.batch([env.DB.prepare('DELETE FROM mcp_kv WHERE key=?1').bind(prefix+id),env.DB.prepare('DELETE FROM function_subscriptions WHERE name=?1').bind(hookFunction(id)),env.DB.prepare('DELETE FROM function_deliveries WHERE function=?1').bind(hookFunction(id))]);}
+export function deliveryCategory(error){if(error.message==='challenge_failed')return 'challenge_failed';if(error.message==='Webhook timed out')return 'timeout';if(error.status>=500)return 'http_5xx';if(error.status)return 'http_4xx';return 'connection_refused';}
+// Worker fetch cannot pin an independently resolved address with original TLS SNI.
+// Restrict callbacks to exact owner-declared URLs, rechecked on every attempt.
+// This also supplies the draft's server-configured endpoint-consent allowlist.
+export function permittedCallback(env,name,url){
+  const feed=eventFeeds(env)[name];
+  return [...(feed?.receivers??[]),...(feed?.webhook?[feed.webhook.url]:[])].some(value=>callbackUrl(value)===url);
+}
+async function send(env,sub,body,id,options={}){
+  if(!permittedCallback(env,sub.name,sub.url))throw new WebhookFailure('Callback no longer allowed');
+  const secrets=[sub.secret,...(sub.previous&&sub.rotateUntil>(options.now??Date.now)()?[sub.previous]:[])];
+  return signedWebhook(sub.url,{id,body,secrets,headers:subscriptionHeaders(sub.id)},options);
+}
+async function watermark(env,sub){
+  const registry=await env.DB.prepare('SELECT cursor FROM function_subscriptions WHERE name=?1').bind(hookFunction(sub.id)).first();
+  const pending=await env.DB.prepare("SELECT MIN(e.seq) seq FROM function_deliveries d JOIN studio_events e ON e.id=d.event WHERE d.function=?1 AND d.state!='complete'").bind(hookFunction(sub.id)).first();
+  return cursorOf(sub.name,Math.max(sub.start,Math.min(registry?.cursor??sub.start,pending.seq===null?Number.MAX_SAFE_INTEGER:pending.seq-1)));
+}
+export async function subscribeEvents(env,cat,caller,params,{now=Date.now}={}){
+  if(!caller.id)throw new EventsError(EVENT_ERRORS.forbidden);
+  const feed=await checkEvent(env,cat,caller,params);
+  if(!params.delivery||typeof params.delivery!=='object')invalid();
+  if(params.delivery.mode!==undefined&&params.delivery.mode!=='webhook')throw new EventsError(EVENT_ERRORS.unsupported,{feature:'deliveryMode',value:params.delivery.mode});
+  const url=callbackUrl(params.delivery.url),secret=signingSecret(params.delivery.secret);
+  if(!permittedCallback(env,params.name,url))throw new EventsError(EVENT_ERRORS.callback,{reason:'challenge_failed'});
+  const id=await subId(caller,params,url),previous=await stored(env,id),live=previous&&previous.expires>now();
+  if(live&&previous.source!==eventSource(feed)){await removeEventHook(env,id);throw new EventsError(EVENT_ERRORS.unsupported,{feature:'payloadSchema',reason:'schema_changed'});}
+  if(previous&&!live)await removeEventHook(env,id);
+  if(!live&&feed.maxSubscriptions!==undefined){const rows=(await env.DB.prepare("SELECT value FROM mcp_kv WHERE key LIKE 'mcp-event-hook:%'").all()).results;if(rows.filter(row=>{const sub=JSON.parse(row.value);return sub.name===params.name&&sub.expires>now();}).length>=feed.maxSubscriptions)throw new EventsError(EVENT_ERRORS.exhausted,{limit:'subscriptions',max:feed.maxSubscriptions});}
+  const start=await eventStart(env,params,now());
+  const sub={id,name:params.name,source:eventSource(feed),url,secret,principal:caller.id,connection:caller.connection??'local-test-owner',start:live?previous.start:start.after,expires:now()+Math.min(params.ttlMs??3600000,86400000)};
+  if(live){if(previous.secret!==secret){sub.previous=previous.secret;sub.rotateUntil=now()+300000;}else if(previous.rotateUntil>now()){sub.previous=previous.previous;sub.rotateUntil=previous.rotateUntil;}}
+  await env.DB.batch([
+    env.DB.prepare('INSERT INTO mcp_kv(key,value) VALUES(?1,?2) ON CONFLICT(key) DO UPDATE SET value=excluded.value').bind(prefix+id,JSON.stringify(sub)),
+    env.DB.prepare('INSERT OR IGNORE INTO function_subscriptions(name,type,cursor,started) VALUES(?1,?2,?3,?4)').bind(hookFunction(id),feed.event,sub.start,now()),
+  ]);
+  const latest=await env.DB.prepare("SELECT error,completed FROM function_deliveries WHERE function=?1 ORDER BY CASE WHEN state!='complete' AND error IS NOT NULL THEN 0 ELSE 1 END, rowid DESC LIMIT 1").bind(hookFunction(id)).first();
+  return subscriptionResult(sub,await watermark(env,sub),live?false:start.truncated,{active:true,lastError:latest?.error??null,lastDeliveryAt:latest?.completed?new Date(latest.completed).toISOString():null});
+}
+export async function unsubscribeEvents(env,caller,params){
+  if(!caller.id)throw new EventsError(EVENT_ERRORS.forbidden);validateEventParams(params);
+  const id=await subId(caller,params,callbackUrl(params.delivery?.url)),sub=await stored(env,id);
+  if(!sub||sub.expires<=Date.now())throw new EventsError(EVENT_ERRORS.notFound,{kind:'subscription'});
+  await removeEventHook(env,id);return {};
+}
+/** Dynamic hooks become ordinary durable function deliveries: one queue and retry engine. */
+export async function eventHookSubscriptions(env,cat,options={}){
+  const now=options.now??Date.now,definitions=[];let after='';
+  for(;;){const rows=(await env.DB.prepare("SELECT key,value FROM mcp_kv WHERE key LIKE 'mcp-event-hook:%' AND key>?1 ORDER BY key LIMIT 100").bind(after).all()).results;
+    for(const row of rows){const sub=JSON.parse(row.value);if(sub.expires<=now()){await removeEventHook(env,sub.id);continue;}
+      let feed;
+      try{feed=await checkEvent(env,cat,await eventCaller(env,sub.connection),{name:sub.name});if(!permittedCallback(env,sub.name,sub.url))throw new EventsError(EVENT_ERRORS.forbidden);if(sub.source!==eventSource(feed))throw new EventsError(EVENT_ERRORS.unsupported,{feature:'payloadSchema',reason:'schema_changed'});}
+      catch(error){try{await send(env,sub,control('terminated',{error:eventError(error)}),'msg_terminated_'+crypto.randomUUID(),options);}catch{}await removeEventHook(env,sub.id);continue;}
+      definitions.push({name:hookFunction(sub.id),event:feed.event,webhook:true,mcpEvent:true,matches:event=>matchesFeed(feed,event),async handler(event){
+        const fresh=await stored(env,sub.id);if(!fresh||fresh.expires<=now())return;
+        try{await checkEvent(env,cat,await eventCaller(env,fresh.connection),{name:fresh.name});}
+        catch(error){try{await send(env,fresh,control('terminated',{error:eventError(error)}),'msg_terminated_'+crypto.randomUUID(),options);}catch{}await removeEventHook(env,fresh.id);return;}
+        try{await send(env,fresh,occurrence(fresh.name,event,await watermark(env,fresh)),event.id,options);}
+        catch(error){const failure=new WebhookFailure(deliveryCategory(error));failure.permanent=error.status===410||error.status===413;throw failure;}
+      }});
+    }
+    if(rows.length<100)break;after=rows.at(-1).key;
+  }return definitions;
+}
+export async function eventsRequest(request,env,ctx,cat,caller,body){
+  const params=body.params??{};
+  try{
+    if(!await rateLimit(env,caller.id??`public:${request.headers.get('cf-connecting-ip')??'local'}`,callsPerMinute(cat)))throw new EventsError(EVENT_ERRORS.exhausted,{limit:'requests'});
+    if(body.jsonrpc!=='2.0'||!['string','number'].includes(typeof body.id))invalid();
+    if(body.method===EVENTS.stream){
+      await checkEvent(env,cat,caller,params);
+      if(!env.LOBBY)throw new EventsError(EVENT_ERRORS.unsupported,{feature:'deliveryMode',value:'push'});
+      const connection=caller.connection??'local-test-owner';
+      return eventHub(env,connection).fetch('https://events/__studio_events',{method:'POST',body:JSON.stringify({op:'extension-stream',connection,cat,id:body.id,params})});
+    }
+    const result=body.method===EVENTS.list?await listEvents(env,cat,caller,params):body.method===EVENTS.poll?await pollEvents(env,cat,caller,params):body.method===EVENTS.subscribe?await subscribeEvents(env,cat,caller,params):await unsubscribeEvents(env,caller,params);
+    if(body.method===EVENTS.subscribe){const work=import('./functions.mjs').then(m=>m.runFunctions(env,cat,new URL(request.url).origin));if(ctx?.waitUntil)ctx.waitUntil(work);else await work;}
+    return Response.json({jsonrpc:'2.0',id:body.id,result:eventsResult(body.method,result)},{headers:{'cache-control':'no-store'}});
+  }catch(error){return Response.json({jsonrpc:'2.0',id:body.id??null,error:eventError(error)},{headers:{'cache-control':'no-store'}});}
+}

package/worker/mcp.mjs

@@ -1,3 +1,5 @@
+import {eventMethods,eventsCapability} from './mcp-events-wire.mjs';
+import {eventsRequest} from './mcp-events.mjs';
 function freshErrorMessage(error,env,caller) {
   let message=String(error?.message??error);
   for(const [key,value] of Object.entries(env))if(typeof value==='string'&&/SECRET|KEY|TOKEN|PASSWORD/.test(key)&&value.length)message=message.replaceAll(value,'[redacted]');
@@ -50,6 +52,7 @@ export async function remoteMcp(request,env,ctx,{catalogueOf,definitions=[]}) {
     }
     if(request.method==='POST') {
       const body=await request.clone().json().catch(()=>null);
+      if(eventMethods.has(body?.method))return eventsRequest(request,env,ctx,cat,caller,body);
       if(body?.method==='tools/call') {
         const tool=tools.find(t=>t.name===body.params?.name);
         const schema=tool?.price?{...tool.inputSchema,properties:{...tool.inputSchema.properties,_payment:paymentInputSchema}}:tool?.inputSchema;
@@ -71,7 +74,7 @@ export async function remoteMcp(request,env,ctx,{catalogueOf,definitions=[]}) {
     };
     const server=async()=>{
       const capabilities=await selling.machineCapabilities(env);
-      const s=new McpServer({name:cat.studio?.name??'Homie studio',version:'1.0.0'},{jsonSchemaValidator:validator,capabilities:{tools:{listChanged:true},...(Object.keys(eventFeeds(env)).length?{resources:{subscribe:true}}:{}),experimental:{payment:{methods:capabilities.machine?.card?{stripe:{intents:['charge']}}:{}}}}});
+      const s=new McpServer({name:cat.studio?.name??'Homie studio',version:'1.0.0'},{jsonSchemaValidator:validator,capabilities:{tools:{listChanged:true},...(Object.keys(eventFeeds(env)).length?{resources:{subscribe:true},...eventsCapability}:{}),experimental:{payment:{methods:capabilities.machine?.card?{stripe:{intents:['charge']}}:{}}}}});
       const dispatch=new Map();
       for(const name of Object.keys(eventFeeds(env))) {
         if(!await readableFeed(env,cat,caller,name))continue;