@homie-rocks/studio 0.51.3 → 0.51.4

package/CHANGELOG.md

@@ -17,6 +17,22 @@ To bring a studio up to date, tell Claude: "Upgrade my studio to the newest Homi
 `npx -y @homie-rocks/studio@latest upgrade`, which shows what's new since the version your studio pins (from this
 file) and what the upgrade would change, and changes nothing until you agree.
 
+## [0.51.4] - 2026-10-14
+
+**Plugin 0.51.4** · Studio events through experimental MCP Events.
+
+Your studio’s declared events reach supporting AI clients through experimental MCP polling, SSE streams and signed webhooks.
+
+### Added
+
+- Every declared studio feed speaks the Triggers & Events draft: role-filtered `events/list`, cursor/replay polling, SSE push with heartbeat and resume, and authenticated webhook subscribe/refresh/unsubscribe with negotiated TTLs and client-supplied Standard Webhooks secrets.
+- Extension and configured webhooks share the durable delivery engine. Owners can see retries and errors; rotation dual-signs for five minutes. Existing resource subscriptions and cursor tools keep working.
+- Servers, app and office guides explain subscription setup and Cloudflare's own Workers Issues events through the person's existing Cloudflare connection.
+
+### Upgrade notes
+
+- Experimental wire format tracks the working-group draft as inspected on 2026-10-14. Declare exact trusted HTTPS callback URLs in each feed's `receivers` array for extension webhooks. Workers fetch cannot pin DNS with original TLS SNI, so arbitrary callbacks are refused; the guide documents this draft limitation. Poll and push need no callback setup.
+
 ## [0.51.3] - 2026-10-14
 
 **Plugin 0.51.3**

package/docs/mcp-events.md

@@ -0,0 +1,68 @@
+# Experimental MCP Events
+
+Studio MCP implements the [Triggers & Events working group's design sketch](https://github.com/modelcontextprotocol/experimental-ext-triggers-events/blob/13e0a59749cde947374aaa8e3a65f0b424468d5a/docs/design-sketch-proposal.md) as inspected on 2026-10-14. This is an experimental draft, not an adopted MCP standard. Method names, envelopes, schemas, metadata keys and provisional error codes live in `worker/mcp-events-wire.mjs` so draft changes have one wire-format boundary. The studio's existing `resources/subscribe`, event resources and cursor-read tool continue to work.
+
+Declare feeds in `studio.json` under `mcp.events`. Each map key is the extension's event `name`. For example:
+
+```json
+{
+  "mcp": {
+    "events": {
+      "bookings": {
+        "event": "record.changed",
+        "app": "cafe",
+        "collection": "bookings",
+        "audience": { "app": "cafe", "role": "staff" },
+        "receivers": ["https://your-ai-receiver.example/hooks/studio"]
+      }
+    }
+  }
+}
+```
+
+`receivers` is an owner-controlled list of exact HTTPS callback URLs, without credentials or fragments. Include only endpoints whose operators have agreed to receive events. A feed's existing configured `webhook.url` is also accepted. Rebuild and deploy the declaration through the studio's usual authorized workflow. Poll and push need no receiver declaration. `maxSubscriptions`, when explicitly declared on a feed, limits its active extension webhooks; otherwise there is no subscription quota. Event arguments are currently `{}`: the declared feed already supplies the app, collection and audience filter.
+
+## An owner's AI connects and subscribes
+
+1. Use an MCP Events-capable client and connect to `<studio-site>/mcp/auth`. Approve with the person's existing studio account in the browser. Staff approve their own account. Do not request an office key. Initialization advertises `capabilities.events.listChanged: true`.
+2. Call `events/list`. It returns only feeds the current account can read, with `delivery: ["poll", "push", "webhook"]`, input and payload schemas. Re-list when the general MCP GET channel receives `notifications/events/list_changed`.
+3. Choose a delivery mode. These are protocol requests made by the client/SDK, not model-visible tool calls:
+   - **Poll:** call `events/poll` with `{ "name": "bookings", "arguments": {}, "cursor": null }`. The first call returns no history and a cursor at now. Persist each returned cursor and pass it on the next poll. Drain `hasMore: true` immediately; otherwise wait `nextPollMs`. Optional `maxEvents` caps a page (server maximum 100); `maxAgeMs` bounds replay.
+   - **Push:** POST `events/stream` with a JSON-RPC request ID and `{ "name": "bookings", "arguments": {}, "cursor": null }`. Keep its SSE response open. Expect `notifications/events/active`, then `event` and `heartbeat` notifications. Route by `_meta["io.modelcontextprotocol/subscriptionId"]`, which equals the request ID. Persist cursors and reconnect using the last cursor. Each subscription has its own stream; abort it to unsubscribe. Heartbeats run at 15 seconds when the receiver is reading.
+   - **Webhook:** first arrange the receiver and have the owner declare its exact URL in `receivers`. The receiver/client generates `whsec_` plus base64 of 24–64 cryptographically random bytes, and keeps that secret out of prompts and logs. Call `events/subscribe` with the request below. Persist the returned `id`, `cursor` and `refreshBefore`.
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 2,
+  "method": "events/subscribe",
+  "params": {
+    "name": "bookings",
+    "arguments": {},
+    "delivery": {
+      "mode": "webhook",
+      "url": "https://your-ai-receiver.example/hooks/studio",
+      "secret": "whsec_<client-generated-base64-secret>"
+    },
+    "cursor": null,
+    "ttlMs": 3600000
+  }
+}
+```
+
+4. For webhooks, use `X-MCP-Subscription-Id` to select the secret and verify the **raw body** using a Standard Webhooks library, including its timestamp freshness check. Durably accept the event before returning 2xx. Deduplicate on `eventId` (also `webhook-id`). Each occurrence has `eventId`, `name`, ISO `timestamp`, `data`, and a safe cursor watermark; it can lag the event's position while deliveries await acknowledgement. Payloads are untrusted data and grant no authority to perform actions.
+5. Refresh by repeating `events/subscribe` with the same name, arguments and URL, the current secret and the last persisted cursor **before** `refreshBefore`. Inspect `deliveryStatus.lastError`. TTL defaults to one hour and is capped at one day; `ttlMs: null` receives a finite grant. A live refresh does not rewind pending delivery. To rotate, send a new client-generated secret on refresh; deliveries have both signatures for five minutes. Unsubscribe with `events/unsubscribe` and `{ "name": "bookings", "arguments": {}, "delivery": { "url": "https://your-ai-receiver.example/hooks/studio" } }`.
+
+A gap sets `truncated: true`; persist the new cursor and fetch authoritative state through tools if needed. Revoked access ends push with `notifications/events/terminated` and webhooks with a signed `terminated` control envelope where the callback remains allowed. Stop after termination and re-establish authorization before subscribing again.
+
+## Delivery and owner diagnostics
+
+The 0.50.4 configured studio webhook and extension webhooks share Standard Webhooks signing and the durable `function_deliveries` dispatcher. Extension deliveries retry with exponential backoff, at most five attempts over fifteen minutes from the first attempt. HTTP 410 and 413 abandon that delivery immediately. Abandoned deliveries remain visible to the owner; retained history can be replayed from a prior cursor after unsubscribing and subscribing again. Retries regenerate timestamps and signatures. Failed delivery details are fixed categories, never endpoint bodies or headers. See Functions in the office or the owner's function-runs tool for subscription IDs, attempts and last errors; refresh also reports the latest delivery error. Subscription secrets are stored only in the studio's private D1 subscription state, never in events or run logs. A removed subscription or expired TTL deletes that state. Completed deliveries can be duplicated after a crash, so receivers must deduplicate.
+
+## Draft limits
+
+This implements the studio's **Streamable HTTP** MCP transport; the local toolkit's stdio MCP is a different server. The draft's endpoint-consent mechanism is the explicit server-configured allowlist, not a challenge handshake. Arbitrary client-supplied callback URLs are refused with `CallbackEndpointError / challenge_failed`. Workers `fetch` does not provide DNS address pinning with original Host/TLS SNI, so this implementation cannot follow that draft MUST literally. Exact owner-approved URLs, rechecked at every attempt, and disabled redirects constrain the destination; this is not a claim of draft-complete DNS-rebinding protection. Only approve trusted receiver operators. No no-expiry grants or asymmetric server signatures are offered. Durable queue positions survive Worker restarts, extending the sketch's ephemeral in-flight bookkeeping while preserving client-owned replay cursors. A webhook's conservative safe watermark may lag the event being delivered by one event.
+
+## Production failures from Cloudflare
+
+An owner's AI can also subscribe through the person's **existing Cloudflare connection** to Cloudflare's own API MCP at `https://mcp.cloudflare.com/mcp`: discover `cloudflare.alert.workers_observability_real_time_issue` with `events/list`, then use `events/subscribe` with that descriptor's arguments scoped to the studio's Worker and the client's webhook. Enable Workers Issues on that Worker and grant **Notifications Write** and **Workers Observability Write**. Cloudflare posts signed events for new or recurring production issues, so reliability problems reach the AI without polling. Homie hosts nothing for this connection. See [Cloudflare's 2026-10-13 announcement](https://developers.cloudflare.com/changelog/post/2026-10-13-cloudflare-mcp-events/).

package/guides/app/SKILL.md

@@ -288,3 +288,27 @@ Upgrade compares copied app presets with recorded toolkit versions. Unchanged
 preset files and default values take the new version; custom scene files, names and
 edited labels remain the studio’s. An app wall uses its join label rather than game
 instructions. Rebuild after upgrade and inspect both the wall and giving page.
+
+## Experimental MCP Events
+
+For an owner's AI that should hear a studio's declared events, read
+`node_modules/@homie-rocks/studio/docs/mcp-events.md`. Connect the client to
+`<site>/mcp/auth` through the person's existing studio approval, discover feeds
+with `events/list`, and use `events/poll`, an SSE `events/stream`, or
+`events/subscribe` with a client-generated `whsec_` secret and an exact
+owner-declared `mcp.events.<feed>.receivers` URL. Refresh before `refreshBefore`,
+persist cursors, verify Standard Webhooks signatures, deduplicate event IDs, and
+use `events/unsubscribe` to stop a webhook. The feeds keep their current roles;
+resources/subscribe and the cursor tool still work. This follows the experimental
+Triggers & Events working-group draft, with the Workers DNS-pinning limitation
+and receiver allowlist explained in that guide. Inspect Functions in the office
+and refresh's `deliveryStatus` for failed deliveries; never put secrets in logs.
+
+For production failures, the owner's AI can also use the person's existing
+Cloudflare connection to `https://mcp.cloudflare.com/mcp`, discover
+`cloudflare.alert.workers_observability_real_time_issue` with `events/list`, and
+subscribe with `events/subscribe` scoped to the studio's Worker. Enable Workers
+Issues and grant Notifications Write and Workers Observability Write. Cloudflare
+posts signed events to the client's webhook so new or recurring reliability
+problems reach the AI without polling; Homie hosts nothing for this. See
+[Cloudflare's announcement](https://developers.cloudflare.com/changelog/post/2026-10-13-cloudflare-mcp-events/).

package/guides/office/SKILL.md

@@ -156,3 +156,27 @@ in and continues there. A plain link-preview GET spends nothing; the loaded page
 submits the same-origin sign-in form. Keep the link private.
 Local office and role commands reuse the running dev server’s D1 configuration even
 after deploy records the production database id.
+
+## Experimental MCP Events
+
+For an owner's AI that should hear a studio's declared events, read
+`node_modules/@homie-rocks/studio/docs/mcp-events.md`. Connect the client to
+`<site>/mcp/auth` through the person's existing studio approval, discover feeds
+with `events/list`, and use `events/poll`, an SSE `events/stream`, or
+`events/subscribe` with a client-generated `whsec_` secret and an exact
+owner-declared `mcp.events.<feed>.receivers` URL. Refresh before `refreshBefore`,
+persist cursors, verify Standard Webhooks signatures, deduplicate event IDs, and
+use `events/unsubscribe` to stop a webhook. The feeds keep their current roles;
+resources/subscribe and the cursor tool still work. This follows the experimental
+Triggers & Events working-group draft, with the Workers DNS-pinning limitation
+and receiver allowlist explained in that guide. Inspect Functions in the office
+and refresh's `deliveryStatus` for failed deliveries; never put secrets in logs.
+
+For production failures, the owner's AI can also use the person's existing
+Cloudflare connection to `https://mcp.cloudflare.com/mcp`, discover
+`cloudflare.alert.workers_observability_real_time_issue` with `events/list`, and
+subscribe with `events/subscribe` scoped to the studio's Worker. Enable Workers
+Issues and grant Notifications Write and Workers Observability Write. Cloudflare
+posts signed events to the client's webhook so new or recurring reliability
+problems reach the AI without polling; Homie hosts nothing for this. See
+[Cloudflare's announcement](https://developers.cloudflare.com/changelog/post/2026-10-13-cloudflare-mcp-events/).

package/guides/servers/SKILL.md

@@ -157,3 +157,27 @@ For local function and tool proof, run `dev` and use its localhost URL. The priv
 dev credential permits headless owner tool calls; production still uses OAuth.
 App need sessions are scoped to the declared role and fresh records. See the app
 and functions guides for tablet/kiosk proof and atomic function storage.
+
+## Experimental MCP Events
+
+For an owner's AI that should hear a studio's declared events, read
+`node_modules/@homie-rocks/studio/docs/mcp-events.md`. Connect the client to
+`<site>/mcp/auth` through the person's existing studio approval, discover feeds
+with `events/list`, and use `events/poll`, an SSE `events/stream`, or
+`events/subscribe` with a client-generated `whsec_` secret and an exact
+owner-declared `mcp.events.<feed>.receivers` URL. Refresh before `refreshBefore`,
+persist cursors, verify Standard Webhooks signatures, deduplicate event IDs, and
+use `events/unsubscribe` to stop a webhook. The feeds keep their current roles;
+resources/subscribe and the cursor tool still work. This follows the experimental
+Triggers & Events working-group draft, with the Workers DNS-pinning limitation
+and receiver allowlist explained in that guide. Inspect Functions in the office
+and refresh's `deliveryStatus` for failed deliveries; never put secrets in logs.
+
+For production failures, the owner's AI can also use the person's existing
+Cloudflare connection to `https://mcp.cloudflare.com/mcp`, discover
+`cloudflare.alert.workers_observability_real_time_issue` with `events/list`, and
+subscribe with `events/subscribe` scoped to the studio's Worker. Enable Workers
+Issues and grant Notifications Write and Workers Observability Write. Cloudflare
+posts signed events to the client's webhook so new or recurring reliability
+problems reach the AI without polling; Homie hosts nothing for this. See
+[Cloudflare's announcement](https://developers.cloudflare.com/changelog/post/2026-10-13-cloudflare-mcp-events/).

package/lib/functions-build.mjs

@@ -1,3 +1,4 @@
+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';
 import {existsSync,readdirSync,mkdirSync,writeFileSync,readFileSync} from 'node:fs';
@@ -12,6 +13,8 @@ export async function buildFunctions(root,esbuild,{log=()=>{}}={}) {
   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?.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);}
     if(!/^[a-z][a-z0-9-]*$/.test(name)||!feed||typeof feed.event!=='string'||!feed.event.trim())throw new Error('Event feed needs a name and event type');
     if(feed.event==='record.changed'&&(!/^[a-z][a-z0-9-]*$/.test(feed.app??'')||!/^[a-z][a-z0-9-]*$/.test(feed.collection??'')))throw new Error('Record event feed needs app and collection');
     if(feed.audience!==undefined&&feed.audience!=='owner'&&!(feed.audience&&typeof feed.audience==='object'&&feed.audience.app===feed.app&&typeof feed.audience.role==='string'))throw new Error('Event feed audience must be owner or an app role');
@@ -51,5 +54,9 @@ export function functionDeploymentSQL(root) {
   const definitions=existsSync(file)?JSON.parse(readFileSync(file,'utf8')):[];
   for(const [name,feed] of Object.entries(readStudio(root).mcp?.events??{})){definitions.push({name:'@events/'+name,event:feed.event});if(feed.webhook)definitions.push({name:webhookName(name,feed.webhook),event:feed.event});}
   const literal=value=>"'"+String(value).replaceAll("'","''")+"'";
-  return [...definitions.map(fn=>`INSERT INTO function_subscriptions(name,type,cursor,started) VALUES(${literal(fn.name)},${literal(fn.event)},(SELECT COALESCE(MAX(seq),0) FROM studio_events),unixepoch()*1000) ON CONFLICT(name) DO UPDATE SET type=excluded.type,cursor=excluded.cursor,started=excluded.started WHERE type!=excluded.type;`),`DELETE FROM function_subscriptions WHERE name NOT IN (${definitions.map(fn=>literal(fn.name)).join(',')||"''"});`,"INSERT INTO meta(key,value) VALUES('function-registry-deployed','1') ON CONFLICT(key) DO UPDATE SET value='1';"].join(' ');
+  const feedNames=Object.keys(readStudio(root).mcp?.events??{}).map(literal).join(',')||"''";
+  // Declaration removal also removes private subscription secrets. Runtime studios
+  // without event feeds can retain their original no-MCP-storage fast path.
+  const cleanup=[`DELETE FROM function_deliveries WHERE function IN (SELECT '@mcp-webhook/' || json_extract(value,'$.id') FROM mcp_kv WHERE key LIKE 'mcp-event-hook:%' AND json_extract(value,'$.name') NOT IN (${feedNames}));`,`DELETE FROM function_subscriptions WHERE name IN (SELECT '@mcp-webhook/' || json_extract(value,'$.id') FROM mcp_kv WHERE key LIKE 'mcp-event-hook:%' AND json_extract(value,'$.name') NOT IN (${feedNames}));`,`DELETE FROM mcp_kv WHERE key LIKE 'mcp-event-hook:%' AND json_extract(value,'$.name') NOT IN (${feedNames});`];
+  return [...definitions.map(fn=>`INSERT INTO function_subscriptions(name,type,cursor,started) VALUES(${literal(fn.name)},${literal(fn.event)},(SELECT COALESCE(MAX(seq),0) FROM studio_events),unixepoch()*1000) ON CONFLICT(name) DO UPDATE SET type=excluded.type,cursor=excluded.cursor,started=excluded.started WHERE type!=excluded.type;`),...cleanup,`DELETE FROM function_subscriptions WHERE name NOT LIKE '@mcp-webhook/%' AND name NOT IN (${definitions.map(fn=>literal(fn.name)).join(',')||"''"});`,"INSERT INTO meta(key,value) VALUES('function-registry-deployed','1') ON CONFLICT(key) DO UPDATE SET value='1';"].join(' ');
 }

package/lib/template-history.json

@@ -3666,6 +3666,48 @@
      }
     }
    }
+  },
+  "0.51.4": {
+   "files": {
+    "CLAUDE.md": "ddf2b2a0376202f6",
+    "README.md": "684b3cca8001673c",
+    "HANDOFF.md": "29337e2ace95b2e7",
+    "games/README.md": "5ad32fe80c61f117",
+    "music/README.md": "a3dc042dadd39df8",
+    "videos/README.md": "16babc3437d5545b",
+    "posts/README.md": "37841aae476bd540",
+    "site/README.md": "1dbdf22c03a1e505",
+    "site/src/worker.mjs": "6cc5c6131eaf6fd0"
+   },
+   "sections": {
+    "AGENTS.md": {
+     "(intro)": "394cbbe934e80722",
+     "## Version-matched authoring guides": "f6261a0e5801b96b",
+     "## Layout": "f3a280b8c96cd068",
+     "## Apps: one screen, roles and parts": "c10aa0441ea89702",
+     "## Commands (all through the pinned CLI in node_modules)": "c20d90de21cde0c7",
+     "## The site": "0cb8dd9a6f8a0096",
+     "## Making games": "bb715272fd1a615b",
+     "## The Game Codex and progress": "0738ef719cef3a4c",
+     "## Art direction and models": "a48fff7bf0a5f2fc",
+     "## Running live games (the back office)": "51ebf2ab756f6e4d",
+     "## Servers and AI seats": "1ccfd549d2369a60",
+     "## Selling things (the shop)": "43a3556be93d1235",
+     "## Continuing a build from the Claude app": "0d68081e924ca419",
+     "## Rules": "b2234d80f6cbe71d",
+     "## Telling Homie": "80b46fdd9e578db8",
+     "## Beta": "9d02638207a26e73"
+    }
+   },
+   "named": {
+    "Homie Arcade": {
+     "sections": {
+      "AGENTS.md": {
+       "## Commands (all through the pinned CLI in node_modules)": "8364e05cebefcba4"
+      }
+     }
+    }
+   }
   }
  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homie-rocks/studio",
-  "version": "0.51.3",
+  "version": "0.51.4",
   "description": "A studio for games, music and video on its own Cloudflare: scaffold, multiplayer starters on the netplay contract, a port toolkit that makes existing single-player web games multiplayer, the site Worker with public rooms (Table/Lobby Durable Objects and D1, all on the free Workers plan, no payment method), a site with the hub's sections (Home, Games, Music, Videos, Rooms, Posts with feeds) in the studio's own look, an epic landing page for every game, big songs and videos in the studio's own R2 once it has storage (uploaded, checked by SHA-256, served at the same addresses), deploy, and the homie.rocks directory.",
   "type": "module",
   "license": "Apache-2.0",

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.4","sha256":"6286b3013c1ad438111eaed4338ccbffa2f85bf2a765f9f007155a809c414f71"});

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/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;

package/worker/version.mjs

@@ -1,2 +1,2 @@
 /** The @homie-rocks/studio version this Worker code is (package.json's; a test keeps them equal). Cache-busts /_homie/site.js. */
-export const STUDIO_VERSION_TAG = '0.51.3';
+export const STUDIO_VERSION_TAG = '0.51.4';