@standardagents/builder 0.41.7 → 0.41.9

package/dist/{discovery-CIGNVJfG.d.ts → discovery-D5pmuazY.d.ts}

@@ -1,4 +1,4 @@
-import { D as DiscoveredPackage } from './types-D1ABHvAH.js';
+import { D as DiscoveredPackage } from './types-Dhd0M369.js';
 import { ParentHookRequirement, PackageSignature } from '@standardagents/spec';
 
 /**

package/dist/{index-PSu6cMEz.d.ts → index-ChHAVogf.d.ts}

@@ -1,6 +1,6 @@
 import * as _standardagents_spec from '@standardagents/spec';
 import { ThreadState, ErrorOrigin, ToolResult as ToolResult$1, VariableDefinition, HookName, HookSignatures, HookMessage, HookToolCall, HookToolResult, CodeExecutionOptions, CodeExecutionResult, InjectMessageInput, QueueMessageInput, SubagentRegistryEntry, SubagentRelationship, PackageSignature, ProviderUsagePricing, ThreadUser, AgentDefinition, SkillMetadata, SkillFileInput, ControllerContext, Controller, ThreadEndpointHandler } from '@standardagents/spec';
-import { N as NamespacedRegistry } from './types-D1ABHvAH.js';
+import { N as NamespacedRegistry } from './types-Dhd0M369.js';
 import { DurableObjectStorage } from '@cloudflare/workers-types';
 import { ZodObject, ZodRawShape } from 'zod';
 
@@ -1979,4 +1979,4 @@ declare function defineController<Env extends ThreadEnv = ThreadEnv>(controller:
  */
 declare function createThreadEndpointHandler<Env extends ThreadEnv = ThreadEnv>(handler: ThreadEndpointHandler): BuilderController<Env>;
 
-export { type AuthUser as A, type BuilderController as B, CLIENT_STREAM_CHUNK_BYTES as C, type FlowResult as D, type TelemetryEvent as E, type FlowState as F, type Env as G, type FileRecord as H, type ImageMetadata as I, type AttachmentRef as J, type GrepResult as K, type LLMResponse as L, type Message as M, type FileStats as N, type TextContentPart as O, type ImageContentPart as P, type MultimodalContent as Q, type RequestContext as R, type StorageBackend as S, type ToolCall as T, type MessageContent as U, type ProxyStreamReceiver as V, type ProxyStreamFrame as W, type ProxyStreamTarget as X, type ProxyStreamOpenResult as Y, type SkillStorageScope as Z, type BuilderControllerContext as a, type ThreadEndpointContext as b, createThreadEndpointHandler as c, defineController as d, type ThreadEnv as e, type BuilderThreadEndpointHandler as f, authenticate as g, requireAdmin as h, endpointCallerFromAuth as i, type AuthContext as j, callClient as k, callClientStream as l, encodeStreamChunk as m, decodeStreamChunk as n, type ClientToolRequest as o, type ClientToolResponse as p, type ClientStreamRequest as q, requireAuth as r, supportsClientForwarding as s, type ClientStreamResponse as t, type ClientDuplex as u, type ClientForwarding as v, type Agent as w, type ThreadInstance as x, type ThreadMetadata as y, type ToolResult as z };
+export { type AuthUser as A, type BuilderController as B, CLIENT_STREAM_CHUNK_BYTES as C, type FlowResult as D, type TelemetryEvent as E, type FlowState as F, type Env as G, type FileRecord as H, type ImageMetadata as I, type AttachmentRef as J, type GrepResult as K, type LLMResponse as L, type Message as M, type FileStats as N, type TextContentPart as O, type ImageContentPart as P, type MultimodalContent as Q, type RequestContext as R, type StorageBackend as S, type ThreadEndpointContext as T, type MessageContent as U, type ProxyStreamReceiver as V, type ProxyStreamFrame as W, type ProxyStreamTarget as X, type ProxyStreamOpenResult as Y, type SkillStorageScope as Z, type BuilderControllerContext as a, type ThreadEnv as b, createThreadEndpointHandler as c, defineController as d, type BuilderThreadEndpointHandler as e, authenticate as f, requireAdmin as g, endpointCallerFromAuth as h, type AuthContext as i, callClient as j, callClientStream as k, encodeStreamChunk as l, decodeStreamChunk as m, type ClientToolRequest as n, type ClientToolResponse as o, type ClientStreamRequest as p, type ClientStreamResponse as q, requireAuth as r, supportsClientForwarding as s, type ClientDuplex as t, type ClientForwarding as u, type Agent as v, type ThreadInstance as w, type ThreadMetadata as x, type ToolCall as y, type ToolResult as z };

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-import { ModelDefinition, AgentDefinition } from './runtime.js';
-export { AgentBuilderEnv, AgentBuilderEvent, BroadcastOptions, CodeExecutionBridge, DurableAgentBuilder, DurableThread, DurableUserHub, FlowStateSdk, FlowStateWithSdk, HandlerSide, HubClientInfo, HumanSide, ImageContextConfig, InjectMessageOptions, LLMProviderInterface, NamespaceResolutionError, PromptContent, PromptDefinition, PromptIncludePart, PromptPart, PromptSide, PromptToolConfig, Provider, ProviderContentPart, ProviderFilePart, ProviderImagePart, ProviderRegistry, ProviderTextPart, SessionToolBinding, SessionToolConfig, SideConfig, SubagentRelationship, SubagentToolConfig, SubpromptConfig, ThreadEventPayload, ThreadRegistryEntry, ThreadWatchdog, ThreadWatchdogState, ToolConfig, UpdateThreadParams, User, WatchdogCheckin, WatchdogProbeResult, applyRuntimeCors, buildImageDescription, canAccessThread, cat, createNamespaceContext, emitThreadEvent, enhanceFlowState, exists, find, forceTurn, generateImageDescription, getFileStats, getMessages, getMessagesToSummarize, getShortName, getThumbnail, getUnsummarizedImageAttachments, getVisibleAgentNames, getVisibleModelNames, getVisiblePromptNames, getVisibleToolNames, grep, hasImageAttachments, head, injectMessage, isAdminOnlyApiRoute, isHostedInstance, isPublicApiRoute, isQualifiedName, isSameOriginBrowserRequest, isTrustedLocalDevelopmentRequest, linkFile, mkdir, move, optimizeImageContext, parseQualifiedName, qualifyName, queueTool, readFile, readdir, reloadHistory, rename, replaceImagesWithDescriptions, resolveAgent, resolveHook, resolveModel, resolvePrompt, resolveTool, rmdir, runtimeCorsHeaders, runtimePreflightResponse, stat, tail, unlink, updateThread, writeFile, writeImage } from './runtime.js';
+import { M as ModelDefinition, A as AgentDefinition } from './resolver-DWuGxI4w.js';
+export { m as AgentBuilderEnv, n as AgentBuilderEvent, ah as BroadcastOptions, C as CodeExecutionBridge, h as DurableAgentBuilder, D as DurableThread, l as DurableUserHub, af as FlowStateSdk, ai as FlowStateWithSdk, G as HandlerSide, H as HubClientInfo, E as HumanSide, aq as ImageContextConfig, ae as InjectMessageOptions, as as LLMProviderInterface, aL as NamespaceResolutionError, w as PromptContent, s as PromptDefinition, y as PromptIncludePart, x as PromptPart, F as PromptSide, t as PromptToolConfig, P as Provider, at as ProviderContentPart, aw as ProviderFilePart, av as ProviderImagePart, ar as ProviderRegistry, au as ProviderTextPart, B as SessionToolBinding, z as SessionToolConfig, I as SideConfig, J as SubagentRelationship, u as SubagentToolConfig, S as SubpromptConfig, o as ThreadEventPayload, p as ThreadRegistryEntry, T as ThreadWatchdog, j as ThreadWatchdogState, v as ToolConfig, U as UpdateThreadParams, q as User, k as WatchdogCheckin, W as WatchdogProbeResult, f as applyRuntimeCors, am as buildImageDescription, c as canAccessThread, a9 as cat, aJ as createNamespaceContext, Q as emitThreadEvent, ag as enhanceFlowState, a0 as exists, ad as find, R as forceTurn, ap as generateImageDescription, a7 as getFileStats, N as getMessages, al as getMessagesToSummarize, az as getShortName, a8 as getThumbnail, ak as getUnsummarizedImageAttachments, aG as getVisibleAgentNames, aI as getVisibleModelNames, aH as getVisiblePromptNames, aF as getVisibleToolNames, ac as grep, aj as hasImageAttachments, aa as head, L as injectMessage, d as isAdminOnlyApiRoute, i as isHostedInstance, b as isPublicApiRoute, aK as isQualifiedName, e as isSameOriginBrowserRequest, a as isTrustedLocalDevelopmentRequest, Z as linkFile, a2 as mkdir, a5 as move, ao as optimizeImageContext, ax as parseQualifiedName, ay as qualifyName, K as queueTool, _ as readFile, a3 as readdir, O as reloadHistory, a6 as rename, an as replaceImagesWithDescriptions, aD as resolveAgent, aE as resolveHook, aC as resolveModel, aB as resolvePrompt, aA as resolveTool, a4 as rmdir, r as runtimeCorsHeaders, g as runtimePreflightResponse, $ as stat, ab as tail, a1 as unlink, V as updateThread, X as writeFile, Y as writeImage } from './resolver-DWuGxI4w.js';
 export { AgentPluginOptions, agentbuilder, builder } from './plugin.js';
-export { w as Agent, J as AttachmentRef, j as AuthContext, A as AuthUser, f as BuilderThreadEndpointHandler, C as CLIENT_STREAM_CHUNK_BYTES, u as ClientDuplex, v as ClientForwarding, q as ClientStreamRequest, t as ClientStreamResponse, o as ClientToolRequest, p as ClientToolResponse, B as Controller, a as ControllerContext, G as Env, H as FileRecord, N as FileStats, D as FlowResult, F as FlowState, K as GrepResult, P as ImageContentPart, I as ImageMetadata, L as LLMResponse, M as Message, U as MessageContent, Q as MultimodalContent, R as RequestContext, S as StorageBackend, E as TelemetryEvent, O as TextContentPart, b as ThreadEndpointContext, e as ThreadEnv, x as ThreadInstance, y as ThreadMetadata, T as ToolCall, z as ToolResult, g as authenticate, k as callClient, l as callClientStream, c as createThreadEndpointHandler, n as decodeStreamChunk, d as defineController, m as encodeStreamChunk, i as endpointCallerFromAuth, h as requireAdmin, r as requireAuth, s as supportsClientForwarding } from './index-PSu6cMEz.js';
+export { v as Agent, J as AttachmentRef, i as AuthContext, A as AuthUser, e as BuilderThreadEndpointHandler, C as CLIENT_STREAM_CHUNK_BYTES, t as ClientDuplex, u as ClientForwarding, p as ClientStreamRequest, q as ClientStreamResponse, n as ClientToolRequest, o as ClientToolResponse, B as Controller, a as ControllerContext, G as Env, H as FileRecord, N as FileStats, D as FlowResult, F as FlowState, K as GrepResult, P as ImageContentPart, I as ImageMetadata, L as LLMResponse, M as Message, U as MessageContent, Q as MultimodalContent, R as RequestContext, S as StorageBackend, E as TelemetryEvent, O as TextContentPart, T as ThreadEndpointContext, b as ThreadEnv, w as ThreadInstance, x as ThreadMetadata, y as ToolCall, z as ToolResult, f as authenticate, j as callClient, k as callClientStream, c as createThreadEndpointHandler, m as decodeStreamChunk, d as defineController, l as encodeStreamChunk, h as endpointCallerFromAuth, g as requireAdmin, r as requireAuth, s as supportsClientForwarding } from './index-ChHAVogf.js';
 export { AgentType, DefineHandlerOptions, DefinitionLoader, GlobalNamespaceContext, HANDLER_SYMBOL, HandlerDefinition, HookExecutionContext, HookExecutionSource, HookSignatures, ImageContent, ModelCapabilities, ModelProvider, NamespaceContext, PackageSignature, PackedExports, PackedMeta, PackedMetadata, PackedNamespaceContext, ParentHookRequirement, ParentHookStage, PromptInput, PromptTextPart, ProviderAssistantMessage, ProviderConfigSlot, ProviderConfigSlots, ProviderConfigValueSource, ProviderDefinition, ProviderError, ProviderErrorCode, ProviderFactory, ProviderFactoryConfig, ProviderFinishReason, ProviderGeneratedImage, ProviderMessage, ProviderMessageContent, ProviderMethodOverrides, ModelCapabilities as ProviderModelCapabilities, ProviderOverride, ProviderOverrideContext, ProviderReasoningDetail, ProviderRequest, ProviderResponse, ProviderStreamChunk, ProviderSyncOverride, ProviderSystemMessage, ProviderTool, ProviderToolCallPart, ProviderToolMessage, ProviderToolResultContent, ProviderUsage, ProviderUserMessage, ReasoningConfig, StructuredPrompt, TextContent, ThreadHookName, Tool, ToolArgs, ToolArgsNode, ToolArgsRawShape, ToolContent, belongsToPackage, defineAgent, defineHandler, defineHook, defineModel, definePrompt, defineProvider, defineTool, isHandler, isPacked, isVisibleInNamespace, mapReasoningLevel, providerConst, providerEnv, providerValue } from '@standardagents/spec';
-export { C as ConstituentItem, D as DiscoveredPackage, N as NamespacedRegistry, P as PackingAnalysis, a as PackingOptions, b as PackingResult, c as UnpackOptions, d as UnpackResult } from './types-D1ABHvAH.js';
-export { D as DiscoveryConfig, P as PackageDiscoveryService, d as discoverPackages } from './discovery-CIGNVJfG.js';
+export { C as ConstituentItem, D as DiscoveredPackage, N as NamespacedRegistry, P as PackingAnalysis, a as PackingOptions, b as PackingResult, U as UnpackOptions, c as UnpackResult } from './types-Dhd0M369.js';
+export { D as DiscoveryConfig, P as PackageDiscoveryService, d as discoverPackages } from './discovery-D5pmuazY.js';
 import 'cloudflare:workers';
 import 'vite';
 import '@cloudflare/workers-types';

package/dist/index.js

@@ -1,6 +1,6 @@
 import { getProviderModelPricing } from '@standardagents/provider-pricing';
 import { jsonPathReader } from '@formkit/jsonreader';
-import { ProviderError, mapReasoningLevel, validateAgentDefinition, THREAD_STREAM_REASONING_PARAM, isUserEndpoint } from '@standardagents/spec';
+import { ProviderError, mapReasoningLevel, validateAgentDefinition, THREAD_STREAM_REASONING_PARAM, isUserRoom, isUserEndpoint } from '@standardagents/spec';
 export { HANDLER_SYMBOL, ProviderError, belongsToPackage, defineAgent, defineHandler, defineHook, defineModel, definePrompt, defineProvider, defineTool, isHandler, isPacked, isVisibleInNamespace, mapReasoningLevel, providerConst, providerEnv, providerValue } from '@standardagents/spec';
 import 'virtual:@standardagents-providers';
 import { DurableObject, WorkerEntrypoint } from 'cloudflare:workers';
@@ -37709,6 +37709,8 @@ import {
   applyRuntimeCors,
   runtimeCorsHeaders,
   runtimePreflightResponse,
+  formatUpstreamTiming,
+  withUpstreamTiming,
 } from "@standardagents/builder/runtime";
 import { isThreadEndpoint, getEndpointAccess } from "@standardagents/spec";
 
@@ -37833,13 +37835,19 @@ ${packedThreadRouteCode}
     // thread id, for same-request reuse by controllers (AB-05). Never cached
     // across requests.
     let threadAccess = null;
+    // The request handed to the controller. A protected API request carries
+    // x-standard-upstream-timing with the authentication cost; the header is
+    // overwritten, never merged, so a caller cannot forge upstream time.
+    let controllerRequest = request;
 
     // Require authentication for all API routes except public ones.
     // WebSocket tickets are single-use and are consumed here. Controllers
     // must reuse context.auth (resolveRequestAuth) rather than calling
     // requireAuth again, or a ticket-only upgrade will 401.
     if (isApiRoute && !publicRoute) {
+      const authStartedAt = Date.now();
       const authResult = await requireAuth(request, env);
+      controllerRequest = withUpstreamTiming(request, formatUpstreamTiming('auth', Date.now() - authStartedAt));
 
       // If requireAuth returns a Response, it's an error (401)
       if (authResult instanceof Response) {
@@ -37896,7 +37904,7 @@ ${packedThreadRouteCode}
     }
 
     const context = {
-      req: request,
+      req: controllerRequest,
       params: routeMatch.params || {},
       env: env,
       url: url,
@@ -39380,6 +39388,9 @@ var UserStateImpl = class {
   host;
   /** Caller descriptor for grant `allow` policy checks. */
   caller;
+  /** One identity lookup per execution: the singleton RPC runs at most once. */
+  identityLookup = null;
+  identityLookupMs = null;
   constructor(userId, host, caller) {
     this.userId = userId;
     this.host = host;
@@ -39391,6 +39402,22 @@ var UserStateImpl = class {
     return ns.get(ns.idFromName("singleton"));
   }
   async identity() {
+    if (!this.identityLookup) {
+      const started = Date.now();
+      this.identityLookup = this.lookupIdentity().finally(() => {
+        this.identityLookupMs = Date.now() - started;
+      });
+      this.identityLookup.catch(() => {
+        this.identityLookup = null;
+      });
+    }
+    return this.identityLookup;
+  }
+  /** Milliseconds the execution spent resolving identity, once it has. */
+  timing() {
+    return { identity_ms: this.identityLookupMs };
+  }
+  async lookupIdentity() {
     const user = await this.singleton().getUserById(this.userId);
     if (!user) throw new Error(`Unknown user: ${this.userId}`);
     return {
@@ -39422,6 +39449,12 @@ var UserStateImpl = class {
   emit(event, data) {
     this.host.broadcastUserEvent(this.userId, event, data);
   }
+  async clients() {
+    return this.host.listRoomClients(this.userId);
+  }
+  async send(clientId, frame) {
+    return this.host.sendToRoomClient(this.userId, clientId, frame);
+  }
   async listThreads(options) {
     const { threads, total } = await this.singleton().listThreads({
       user_id: this.userId,
@@ -39489,6 +39522,107 @@ function createExecutionChain() {
   };
 }
 
+// src/users/upstream-timing.ts
+var UPSTREAM_TIMING_HEADER = "x-standard-upstream-timing";
+var MAX_HEADER_CHARS = 512;
+function formatUpstreamTiming(name, durationMs) {
+  const safe = Number.isFinite(durationMs) && durationMs > 0 ? durationMs : 0;
+  return `${name};dur=${Math.round(safe * 10) / 10}`;
+}
+function appendUpstreamTiming(current, name, durationMs) {
+  const entry = formatUpstreamTiming(name, durationMs);
+  if (!current) return entry;
+  const combined = `${current}, ${entry}`;
+  return combined.length > MAX_HEADER_CHARS ? current : combined;
+}
+function withUpstreamTiming(request, value) {
+  const headers = new Headers(request.headers);
+  headers.set(UPSTREAM_TIMING_HEADER, value);
+  return new Request(request, { headers });
+}
+function responseWithUpstreamTiming(response, name, durationMs) {
+  if (response.status === 101) return response;
+  const value = appendUpstreamTiming(response.headers.get(UPSTREAM_TIMING_HEADER), name, durationMs);
+  try {
+    response.headers.set(UPSTREAM_TIMING_HEADER, value);
+    return response;
+  } catch {
+    const headers = new Headers(response.headers);
+    headers.set(UPSTREAM_TIMING_HEADER, value);
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+}
+
+// src/durable-objects/DurableUserHub.ts
+init_bridge_owner();
+
+// src/users/room.ts
+var ROOM_FRAME_MAX_BYTES = 1024 * 1024;
+var ROOM_FRAME_RATE_PER_SECOND = 200;
+var ROOM_FRAME_BURST = 400;
+var ROOM_SEND_BUDGET_BYTES = 8 * 1024 * 1024;
+var ROOM_SEND_BUDGET_WINDOW_MS = 1e4;
+var ROOM_PRESENCE_GRACE_MS = 3e4;
+var ROOM_CLOSE_SUPERSEDED = 4001;
+var ROOM_CLOSE_TOO_LARGE = 1009;
+var ROOM_CLOSE_TRY_AGAIN = 1013;
+function parseRoomFrame(message) {
+  const size = typeof message === "string" ? message.length : message.byteLength;
+  if (size > ROOM_FRAME_MAX_BYTES) return "too_large";
+  if (typeof message !== "string") return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(message);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const frame = parsed;
+  if (frame.type !== "room" || typeof frame.id !== "string" || frame.id.length === 0 || frame.id.length > 256) {
+    return null;
+  }
+  return frame;
+}
+var RoomRateLimiter = class {
+  constructor(ratePerSecond = ROOM_FRAME_RATE_PER_SECOND, burst = ROOM_FRAME_BURST, now = Date.now()) {
+    this.ratePerSecond = ratePerSecond;
+    this.burst = burst;
+    this.tokens = burst;
+    this.last = now;
+  }
+  tokens;
+  last;
+  take(now = Date.now()) {
+    const elapsed = Math.max(0, now - this.last) / 1e3;
+    this.tokens = Math.min(this.burst, this.tokens + elapsed * this.ratePerSecond);
+    this.last = now;
+    if (this.tokens < 1) return false;
+    this.tokens -= 1;
+    return true;
+  }
+};
+var RoomSendBudget = class {
+  constructor(budgetBytes = ROOM_SEND_BUDGET_BYTES, windowMs = ROOM_SEND_BUDGET_WINDOW_MS, now = Date.now()) {
+    this.budgetBytes = budgetBytes;
+    this.windowMs = windowMs;
+    this.windowStart = now;
+  }
+  spent = 0;
+  windowStart;
+  charge(bytes, now = Date.now()) {
+    if (now - this.windowStart >= this.windowMs) {
+      this.windowStart = now;
+      this.spent = 0;
+    }
+    this.spent += bytes;
+    return this.spent <= this.budgetBytes;
+  }
+};
+
 // src/users/grants.ts
 var INSTANCE_GRANTS_MAX_BYTES = 64 * 1024;
 var INSTANCE_GRANTS_MAX_COUNT = 64;
@@ -39644,6 +39778,12 @@ var DurableUserHub = class extends DurableObject {
   clientSockets = /* @__PURE__ */ new Set();
   clientInfo = /* @__PURE__ */ new Map();
   migrated = false;
+  /** Inbound frame rate and outbound byte budget per room socket. */
+  roomLimits = /* @__PURE__ */ new Map();
+  /** Detach notices held for the presence grace window, by client id. */
+  pendingDetach = /* @__PURE__ */ new Map();
+  /** The project's room definition, loaded once per instance. */
+  roomDefinition = null;
   constructor(ctx, env) {
     super(ctx, env);
     ctx.blockConcurrencyWhile(async () => {
@@ -39656,7 +39796,8 @@ var DurableUserHub = class extends DurableObject {
         this.clientInfo.set(ws, {
           clientId: typeof attachment.clientId === "string" ? attachment.clientId : null,
           clientName: typeof attachment.clientName === "string" ? attachment.clientName : null,
-          clientKind: typeof attachment.clientKind === "string" ? attachment.clientKind : null
+          clientKind: typeof attachment.clientKind === "string" ? attachment.clientKind : null,
+          since: typeof attachment.since === "number" ? attachment.since : void 0
         });
       }
     }
@@ -39729,24 +39870,188 @@ var DurableUserHub = class extends DurableObject {
     if (request.headers.get("Upgrade") === "websocket") {
       const pair = new WebSocketPair();
       const [client, server] = [pair[0], pair[1]];
-      const info = {
-        clientId: url.searchParams.get("client_id"),
-        clientName: url.searchParams.get("client_name"),
-        clientKind: url.searchParams.get("client_kind")
-      };
+      const info = { ...parseBridgeClientParams(url).info, since: Date.now() };
       this.ensureHeartbeatAutoResponse();
       this.ctx.acceptWebSocket(server);
       server.serializeAttachment({ type: "hub_client", ...info });
+      const reconnecting = info.clientId !== null && this.supersedeClient(info.clientId, server);
       this.clientSockets.add(server);
       this.clientInfo.set(server, info);
       try {
         server.send(JSON.stringify({ type: "hub_ready" }));
       } catch {
       }
+      if (info.clientId) {
+        const connection = this.connectionOf(info);
+        if (connection) this.observeAttach(connection, reconnecting);
+      }
       return new Response(null, { status: 101, webSocket: client });
     }
     return new Response("Not found", { status: 404 });
   }
+  // ─── Room connections (spec: Users rooms) ───────────────────────────────────
+  connectionOf(info) {
+    if (!info?.clientId) return null;
+    return { clientId: info.clientId, clientKind: info.clientKind, since: info.since ?? 0 };
+  }
+  /** Close every other socket presenting `clientId`; true when one existed. */
+  supersedeClient(clientId, keep) {
+    let superseded = false;
+    for (const ws of Array.from(this.clientSockets)) {
+      if (ws === keep || this.clientInfo.get(ws)?.clientId !== clientId) continue;
+      this.forgetSocket(ws);
+      superseded = true;
+      try {
+        ws.send(JSON.stringify({ type: "superseded" }));
+      } catch {
+      }
+      try {
+        ws.close(ROOM_CLOSE_SUPERSEDED, "Superseded by a newer connection from this client");
+      } catch {
+      }
+    }
+    return superseded;
+  }
+  forgetSocket(ws) {
+    this.clientSockets.delete(ws);
+    this.clientInfo.delete(ws);
+    this.roomLimits.delete(ws);
+  }
+  liveSocketFor(clientId) {
+    for (const ws of this.clientSockets) {
+      if (this.clientInfo.get(ws)?.clientId === clientId && ws.readyState === WebSocket.OPEN) return ws;
+    }
+    return null;
+  }
+  /** Live room connections, one per client id, oldest attachment first. */
+  listRoomClients() {
+    const byId = /* @__PURE__ */ new Map();
+    for (const ws of this.clientSockets) {
+      if (ws.readyState !== WebSocket.OPEN) continue;
+      const connection = this.connectionOf(this.clientInfo.get(ws));
+      if (connection) byId.set(connection.clientId, connection);
+    }
+    return Array.from(byId.values()).sort((a, b) => a.since - b.since);
+  }
+  /** Deliver one frame to the socket carrying `clientId`, within its send budget. */
+  sendToRoomClient(clientId, frame) {
+    const ws = this.liveSocketFor(clientId);
+    if (!ws) return false;
+    return this.sendRoomFrame(ws, JSON.stringify(frame));
+  }
+  sendRoomFrame(ws, payload) {
+    const limits = this.limitsFor(ws);
+    if (!limits.send.charge(payload.length)) {
+      this.forgetSocket(ws);
+      try {
+        ws.close(ROOM_CLOSE_TRY_AGAIN, "Slow consumer: send budget exceeded");
+      } catch {
+      }
+      return false;
+    }
+    try {
+      ws.send(payload);
+      return true;
+    } catch {
+      this.forgetSocket(ws);
+      return false;
+    }
+  }
+  limitsFor(ws) {
+    let limits = this.roomLimits.get(ws);
+    if (!limits) {
+      limits = { rate: new RoomRateLimiter(), send: new RoomSendBudget() };
+      this.roomLimits.set(ws, limits);
+    }
+    return limits;
+  }
+  /** Load the project's room definition from the users registry, once. */
+  async loadRoom() {
+    if (!this.roomDefinition) {
+      this.roomDefinition = (async () => {
+        const registry = this.userEndpoints();
+        for (const key of Object.keys(registry)) {
+          if (!/(^|\/)room$/.test(key)) continue;
+          try {
+            const loaded = await registry[key]();
+            const candidate = loaded.default ?? loaded;
+            if (isUserRoom(candidate)) return candidate;
+          } catch {
+          }
+        }
+        return null;
+      })();
+    }
+    return this.roomDefinition;
+  }
+  /** Whether `key` is room-owned state, exempt from `user_value_changed`. */
+  async roomOwnsKey(key) {
+    const room = await this.loadRoom();
+    return Boolean(room?.valuePrefix && key.startsWith(room.valuePrefix));
+  }
+  /**
+   * Presence runs inside the serialization chain, after any execution the
+   * event raced with, so a room's presence write never interleaves with a
+   * mutation. A reconnect inside the grace window is not a change.
+   */
+  observeAttach(connection, reconnecting) {
+    const pending = this.pendingDetach.get(connection.clientId);
+    if (pending) {
+      clearTimeout(pending);
+      this.pendingDetach.delete(connection.clientId);
+      return;
+    }
+    if (reconnecting) return;
+    this.dispatchRoomPresence({ kind: "attached", connection, at: Date.now() });
+  }
+  observeDetach(connection) {
+    if (this.liveSocketFor(connection.clientId)) return;
+    const existing = this.pendingDetach.get(connection.clientId);
+    if (existing) clearTimeout(existing);
+    this.pendingDetach.set(
+      connection.clientId,
+      setTimeout(() => {
+        this.pendingDetach.delete(connection.clientId);
+        if (this.liveSocketFor(connection.clientId)) return;
+        this.dispatchRoomPresence({ kind: "detached", connection, at: Date.now() });
+      }, ROOM_PRESENCE_GRACE_MS)
+    );
+  }
+  dispatchRoomPresence(event) {
+    const run = this.executionChain.run(async () => {
+      const room = await this.loadRoom();
+      if (!room?.onPresence) return;
+      const user = new UserStateImpl(this.roomUserId(), this.scopeHost(), { kind: "userRoom", name: "presence" });
+      try {
+        await room.onPresence(user, event);
+      } catch (error) {
+        console.error("[DurableUserHub] room presence handler failed:", error);
+      }
+    });
+    this.ctx.waitUntil(run);
+  }
+  /** The hub is one object per user; its name is the user id. */
+  roomUserId() {
+    return this.ctx.id.name ?? this.ctx.id.toString();
+  }
+  async dispatchRoomFrame(ws, frame) {
+    const connection = this.connectionOf(this.clientInfo.get(ws));
+    if (!connection) return;
+    await this.executionChain.run(async () => {
+      const room = await this.loadRoom();
+      if (!room) {
+        this.sendRoomFrame(ws, JSON.stringify({ type: "room", id: frame.id, error: "no_room" }));
+        return;
+      }
+      const user = new UserStateImpl(this.roomUserId(), this.scopeHost(), { kind: "userRoom", name: "frame" });
+      try {
+        await room.onFrame(user, connection, frame);
+      } catch (error) {
+        console.error("[DurableUserHub] room frame handler failed:", error);
+        this.sendRoomFrame(ws, JSON.stringify({ type: "room", id: frame.id, error: "handler_failed" }));
+      }
+    });
+  }
   // ─── User scope: event stream (spec: Users §4) ─────────────────────────────
   /** Idle sockets answer heartbeats at the edge without waking the object.
    *  Registered at accept time rather than in the constructor so a hub that
@@ -39784,8 +40089,9 @@ var DurableUserHub = class extends DurableObject {
     return new Response(null, { status: 101, webSocket: client });
   }
   /**
-   * Deliver an event frame to every socket attached to this user's stream.
-   * At-most-once, live-only (spec: Users §4) — no history, no acks.
+   * Deliver an event frame to every socket attached to this user's stream
+   * and to every room socket. At-most-once, live-only (spec: Users §4) —
+   * no history, no acks.
    */
   broadcastUserEvent(userId, event, data) {
     const frame = JSON.stringify({ event, data });
@@ -39797,6 +40103,10 @@ var DurableUserHub = class extends DurableObject {
       } catch {
       }
     }
+    for (const ws of Array.from(this.clientSockets)) {
+      if (ws.readyState !== WebSocket.OPEN || !this.clientInfo.get(ws)?.clientId) continue;
+      this.sendRoomFrame(ws, frame);
+    }
   }
   // ─── User scope: serialized endpoint execution (spec: Users §2.1, §3) ─────
   /** Per-user execution chain (spec: Users §2.1) — see users/serialize.ts. */
@@ -39807,6 +40117,8 @@ var DurableUserHub = class extends DurableObject {
       setUserValue: (userId, key, value) => this.setUserValue(userId, key, value),
       listUserValues: (userId, options) => this.listUserValues(userId, options ?? {}),
       broadcastUserEvent: (userId, event, data) => this.broadcastUserEvent(userId, event, data),
+      listRoomClients: () => this.listRoomClients(),
+      sendToRoomClient: (_userId, clientId, frame) => this.sendToRoomClient(clientId, frame),
       grantFetch: (userId, grant, req) => this.grantFetch(userId, grant, req),
       env: this.env
     };
@@ -39826,19 +40138,28 @@ var DurableUserHub = class extends DurableObject {
     }
     const module = loaded;
     const handler = module.default ?? loaded;
+    if (isUserRoom(handler)) return Response.json({ error: "Not found" }, { status: 404 });
     if (!isUserEndpoint(handler)) {
       return Response.json(
         { error: `${match.key} is not a defineUserEndpoint export` },
         { status: 500 }
       );
     }
+    const queuedAt = Date.now();
     return this.executionChain.run(async () => {
+      const queueMs = Date.now() - queuedAt;
+      const timed = withUpstreamTiming(
+        request,
+        appendUpstreamTiming(request.headers.get(UPSTREAM_TIMING_HEADER), "queue", queueMs)
+      );
       const user = new UserStateImpl(userId, this.scopeHost(), {
         kind: "userEndpoint",
         name: match.key
       });
       try {
-        return await handler.__handler(request, user, match.params);
+        const response = await handler.__handler(timed, user, match.params);
+        const identityMs = user.timing().identity_ms;
+        return identityMs === null ? response : responseWithUpstreamTiming(response, "identity", identityMs);
       } catch (error) {
         return Response.json(
           { error: error instanceof Error ? error.message : "User endpoint failed" },
@@ -39861,6 +40182,7 @@ var DurableUserHub = class extends DurableObject {
     const names = Object.keys(registry);
     if (names.length === 0) return;
     const run = async () => {
+      if (hookType === "user_value_changed" && await this.roomOwnsKey(String(args[0]))) return;
       const user = new UserStateImpl(userId, this.scopeHost(), {
         kind: "userHook",
         name: hookType
@@ -39885,6 +40207,9 @@ var DurableUserHub = class extends DurableObject {
     this.ctx.waitUntil(run());
   }
   async webSocketClose(ws) {
+    const connection = this.connectionOf(this.clientInfo.get(ws));
+    this.forgetSocket(ws);
+    if (connection) this.observeDetach(connection);
     const attachment = ws.deserializeAttachment();
     if (attachment?.type === "user_stream") {
       this.dispatchUserHooks(String(attachment.userId), "user_client_detached", [
@@ -39893,10 +40218,7 @@ var DurableUserHub = class extends DurableObject {
           kind: typeof attachment.clientKind === "string" ? attachment.clientKind : void 0
         }
       ]);
-      return;
     }
-    this.clientSockets.delete(ws);
-    this.clientInfo.delete(ws);
   }
   // ─── User scope: credential grants (spec: Users §6) ───────────────────────
   /**
@@ -40016,8 +40338,37 @@ var DurableUserHub = class extends DurableObject {
       caller: body.caller ?? { kind: "unknown", name: "unknown" }
     });
   }
-  async webSocketMessage(ws, _message) {
-    if (!this.clientSockets.has(ws)) this.clientSockets.add(ws);
+  async webSocketMessage(ws, message) {
+    const attachment = ws.deserializeAttachment();
+    if (attachment?.type !== "hub_client") return;
+    if (!this.clientSockets.has(ws)) {
+      this.clientSockets.add(ws);
+      this.clientInfo.set(ws, {
+        clientId: typeof attachment.clientId === "string" ? attachment.clientId : null,
+        clientName: typeof attachment.clientName === "string" ? attachment.clientName : null,
+        clientKind: typeof attachment.clientKind === "string" ? attachment.clientKind : null,
+        since: typeof attachment.since === "number" ? attachment.since : void 0
+      });
+    }
+    if (!this.limitsFor(ws).rate.take()) {
+      this.forgetSocket(ws);
+      try {
+        ws.close(ROOM_CLOSE_TRY_AGAIN, "Frame rate exceeded");
+      } catch {
+      }
+      return;
+    }
+    const frame = parseRoomFrame(message);
+    if (frame === "too_large") {
+      this.forgetSocket(ws);
+      try {
+        ws.close(ROOM_CLOSE_TOO_LARGE, "Frame exceeds 1 MiB");
+      } catch {
+      }
+      return;
+    }
+    if (frame === null || !this.clientInfo.get(ws)?.clientId) return;
+    await this.dispatchRoomFrame(ws, frame);
   }
   async webSocketError(ws) {
     await this.webSocketClose(ws);