@edge-base/server 0.2.6 → 0.2.8

package/src/index.ts

@@ -1,6 +1,7 @@
 import type { HonoEnv } from './lib/hono.js';
 import type { OpenApiSpec } from './lib/openapi.js';
 import type { Env } from './types.js';
+import type { FrontendConfigLike } from './lib/frontend-config.js';
 import { ensureServerStartup } from './lib/runtime-startup.js';
 
 // ─── DO Re-exports (wrangler needs exports from main entry) ───
@@ -11,12 +12,14 @@ export { RoomsDO } from './durable-objects/rooms-do.js';
 export { LogsDO } from './durable-objects/logs-do.js';
 
 let appPromise: Promise<Awaited<ReturnType<typeof buildApp>>> | null = null;
+const FRONTEND_ASSET_REDIRECT_STATUSES = new Set([301, 302, 307, 308]);
+const FRONTEND_ASSET_REDIRECT_LIMIT = 4;
 
 function assetUnavailableMessage(
-  assetName: 'admin dashboard' | 'harness assets',
+  assetName: 'admin dashboard' | 'frontend bundle' | 'harness assets',
 ): string {
   const label = `${assetName[0].toUpperCase()}${assetName.slice(1)}`;
-  const verb = assetName === 'admin dashboard' ? 'is' : 'are';
+  const verb = assetName === 'harness assets' ? 'are' : 'is';
   return `${label} ${verb} not deployed for this worker. Deploy the assets bundle or configure ADMIN_ORIGIN if they are hosted elsewhere.`;
 }
 
@@ -56,6 +59,7 @@ async function buildApp() {
     analyticsRouteModule,
     adminAssetsModule,
     adminRoutingModule,
+    frontendAssetsModule,
     schemasModule,
     pluginMigrationsModule,
     pluginMigrationRoutingModule,
@@ -95,6 +99,7 @@ async function buildApp() {
     import('./routes/analytics-api.js'),
     import('./lib/admin-assets.js'),
     import('./lib/admin-routing.js'),
+    import('./lib/frontend-assets.js'),
     import('./lib/schemas.js'),
     import('./lib/plugin-migrations.js'),
     import('./lib/plugin-migration-routing.js'),
@@ -116,6 +121,7 @@ async function buildApp() {
   const { SERVER_VERSION } = versionModule;
   const { createAdminAssetRequest } = adminAssetsModule;
   const { resolveAdminFaviconTarget, resolveAdminRedirectTarget } = adminRoutingModule;
+  const { applyFrontendAssetHeaders, createFrontendAssetRequest } = frontendAssetsModule;
   const { zodDefaultHook } = schemasModule;
   const { executePluginMigrations } = pluginMigrationsModule;
   const { shouldRunPluginMigrationsForRequestPath } = pluginMigrationRoutingModule;
@@ -163,8 +169,75 @@ async function buildApp() {
   app.route('/admin/api', adminRouteModule.adminRoute);
   app.route('/admin/api/backup', backupRouteModule.backupRoute);
 
-  app.get('/', (c) => {
+  function getFrontendConfig(env: Env): FrontendConfigLike | undefined {
+    return (doRouterModule.parseConfig(env) as { frontend?: FrontendConfigLike } | undefined)?.frontend;
+  }
+
+  async function fetchFrontendAssetResponse(
+    assetsBinding: { fetch(request: Request): Promise<Response> },
+    assetRequest: Request,
+  ): Promise<Response> {
+    let currentRequest = assetRequest;
+    const visitedUrls = new Set<string>();
+
+    for (let attempt = 0; attempt <= FRONTEND_ASSET_REDIRECT_LIMIT; attempt += 1) {
+      visitedUrls.add(currentRequest.url);
+      const assetResponse = await assetsBinding.fetch(currentRequest);
+      if (!FRONTEND_ASSET_REDIRECT_STATUSES.has(assetResponse.status)) {
+        return assetResponse;
+      }
+
+      const location = assetResponse.headers.get('location');
+      if (!location) {
+        return assetResponse;
+      }
+
+      const nextUrl = new URL(location, currentRequest.url);
+      if (nextUrl.origin !== new URL(currentRequest.url).origin) {
+        return assetResponse;
+      }
+
+      if (visitedUrls.has(nextUrl.toString())) {
+        return assetResponse;
+      }
+
+      currentRequest = new Request(nextUrl.toString(), currentRequest);
+    }
+
+    return assetsBinding.fetch(currentRequest);
+  }
+
+  async function serveFrontendAsset(c: { env: Env; req: { raw: Request } }): Promise<Response | null> {
+    const frontend = getFrontendConfig(c.env);
+    if (!frontend) {
+      return null;
+    }
+
+    if (!c.env.ASSETS) {
+      return new Response(
+        JSON.stringify({ code: 404, message: assetUnavailableMessage('frontend bundle') }),
+        {
+          status: 404,
+          headers: { 'content-type': 'application/json; charset=UTF-8' },
+        },
+      );
+    }
+
+    const assetRequest = createFrontendAssetRequest(c.req.raw, frontend);
+    if (!assetRequest) {
+      return null;
+    }
+
+    const assetResponse = await fetchFrontendAssetResponse(c.env.ASSETS, assetRequest);
+    return applyFrontendAssetHeaders(assetResponse, new URL(assetRequest.url).pathname);
+  }
+
+  app.get('/', async (c) => {
     const env = c.env as Env;
+    const frontendResponse = await serveFrontendAsset({ env, req: c.req });
+    if (frontendResponse) {
+      return frontendResponse;
+    }
     const externalAdminUrl = resolveAdminRedirectTarget(c.req.url, env.ADMIN_ORIGIN);
     if (externalAdminUrl) {
       return c.redirect(externalAdminUrl, 302);
@@ -181,6 +254,10 @@ async function buildApp() {
 
   app.get('/favicon.ico', async (c) => {
     const env = c.env as Env;
+    const frontendResponse = await serveFrontendAsset({ env, req: c.req });
+    if (frontendResponse) {
+      return frontendResponse;
+    }
     const externalFaviconUrl = resolveAdminFaviconTarget(env.ADMIN_ORIGIN);
     if (externalFaviconUrl) {
       return c.redirect(externalFaviconUrl, 302);
@@ -197,6 +274,10 @@ async function buildApp() {
 
   app.get('/favicon.svg', async (c) => {
     const env = c.env as Env;
+    const frontendResponse = await serveFrontendAsset({ env, req: c.req });
+    if (frontendResponse) {
+      return frontendResponse;
+    }
     const externalFaviconUrl = resolveAdminFaviconTarget(env.ADMIN_ORIGIN);
     if (externalFaviconUrl) {
       return c.redirect(externalFaviconUrl, 302);
@@ -275,6 +356,19 @@ async function buildApp() {
     return c.json(normalizeOpenApiDocument(spec as OpenApiSpec, new URL(c.req.url).origin));
   });
 
+  app.on(['GET', 'HEAD'], '*', async (c) => {
+    const env = c.env as Env;
+    const frontendResponse = await serveFrontendAsset({ env, req: c.req });
+    if (frontendResponse) {
+      return frontendResponse;
+    }
+
+    return c.json({
+      code: 404,
+      message: `Path '${new URL(c.req.url).pathname}' was not found on this EdgeBase server.`,
+    }, 404);
+  });
+
   app.notFound((c) => {
     return c.json({
       code: 404,

package/src/lib/admin-assets.ts

@@ -1,6 +1,6 @@
 export function resolveAdminAssetPath(pathname: string): string {
   if (pathname === '/admin' || pathname === '/admin/') {
-    return '/';
+    return '/admin/index.html';
   }
 
   if (!pathname.startsWith('/admin/')) {
@@ -9,19 +9,19 @@ export function resolveAdminAssetPath(pathname: string): string {
 
   const assetPath = pathname.slice('/admin'.length) || '/';
   if (assetPath === '/' || assetPath === '') {
-    return '/';
+    return '/admin/index.html';
   }
 
   if (assetPath.startsWith('/_app/')) {
-    return assetPath;
+    return `/admin${assetPath}`;
   }
 
   const lastSegment = assetPath.split('/').pop() ?? '';
   if (lastSegment.includes('.')) {
-    return assetPath;
+    return `/admin${assetPath}`;
   }
 
-  return '/';
+  return '/admin/index.html';
 }
 
 export function createAdminAssetRequest(request: Request): Request {

package/src/lib/frontend-assets.ts

@@ -0,0 +1,129 @@
+import { normalizeFrontendMountPath, type FrontendConfigLike } from './frontend-config.js';
+
+interface ResolveFrontendAssetPathOptions {
+  method?: string;
+  accept?: string | null;
+  mountPath?: string;
+  spaFallback?: boolean;
+}
+
+const HTML_ACCEPT_MARKERS = ['text/html', 'application/xhtml+xml'];
+const HASHED_ASSET_PATTERN = /(?:^|[-._])[A-Za-z0-9]{8,}\.[A-Za-z0-9]+$/;
+
+function isExplicitAssetPath(pathname: string): boolean {
+  const lastSegment = pathname.split('/').pop() ?? '';
+  return lastSegment.includes('.');
+}
+
+function isHtmlNavigationRequest(method: string | undefined, accept: string | null | undefined): boolean {
+  if (method && method !== 'GET' && method !== 'HEAD') {
+    return false;
+  }
+
+  if (!accept) {
+    return false;
+  }
+
+  return HTML_ACCEPT_MARKERS.some((marker) => accept.includes(marker));
+}
+
+function stripMountPath(pathname: string, mountPath: string): string | null {
+  if (mountPath === '/') {
+    return pathname || '/';
+  }
+
+  if (pathname === mountPath || pathname === `${mountPath}/`) {
+    return '/';
+  }
+
+  if (!pathname.startsWith(`${mountPath}/`)) {
+    return null;
+  }
+
+  return pathname.slice(mountPath.length) || '/';
+}
+
+export function resolveFrontendAssetPath(
+  pathname: string,
+  options: ResolveFrontendAssetPathOptions = {},
+): string | null {
+  const mountPath = normalizeFrontendMountPath(options.mountPath);
+  const relativePath = stripMountPath(pathname || '/', mountPath);
+  if (relativePath === null) {
+    return null;
+  }
+
+  const assetPrefix = mountPath === '/' ? '' : mountPath;
+
+  if (relativePath === '/' || relativePath === '') {
+    return `${assetPrefix}/index.html`;
+  }
+
+  const explicitAssetPath = `${assetPrefix}${relativePath}`;
+  if (isExplicitAssetPath(relativePath)) {
+    return explicitAssetPath;
+  }
+
+  if (options.spaFallback && isHtmlNavigationRequest(options.method, options.accept)) {
+    return `${assetPrefix}/index.html`;
+  }
+
+  return explicitAssetPath;
+}
+
+export function createFrontendAssetRequest(
+  request: Request,
+  config: FrontendConfigLike,
+): Request | null {
+  const url = new URL(request.url);
+  const pathname = resolveFrontendAssetPath(url.pathname, {
+    method: request.method,
+    accept: request.headers.get('accept'),
+    mountPath: config.mountPath,
+    spaFallback: config.spaFallback,
+  });
+
+  if (!pathname) {
+    return null;
+  }
+
+  url.pathname = pathname;
+  return new Request(url.toString(), request);
+}
+
+function getFrontendCacheControl(pathname: string): string | null {
+  const assetName = pathname.split('/').pop() ?? '';
+
+  if (assetName === 'index.html' || assetName === 'manifest.webmanifest' || assetName === 'sw.js') {
+    return 'no-cache';
+  }
+
+  if (HASHED_ASSET_PATTERN.test(assetName)) {
+    return 'public, max-age=31536000, immutable';
+  }
+
+  if (isExplicitAssetPath(pathname)) {
+    return 'public, max-age=300';
+  }
+
+  return null;
+}
+
+export function applyFrontendAssetHeaders(response: Response, pathname: string): Response {
+  if (!response.ok) {
+    return response;
+  }
+
+  const cacheControl = getFrontendCacheControl(pathname);
+  if (!cacheControl) {
+    return response;
+  }
+
+  const headers = new Headers(response.headers);
+  headers.set('Cache-Control', cacheControl);
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+}

package/src/lib/frontend-config.ts

@@ -0,0 +1,11 @@
+export interface FrontendConfigLike {
+  directory: string;
+  mountPath?: string;
+  spaFallback?: boolean;
+}
+
+export function normalizeFrontendMountPath(mountPath: string | undefined): string {
+  if (!mountPath) return '/';
+  if (mountPath === '/') return '/';
+  return mountPath.endsWith('/') ? mountPath.slice(0, -1) : mountPath;
+}

package/src/lib/openapi.ts

@@ -47,10 +47,7 @@ const USER_BEARER_PATHS = new Set([
   '/api/push/topic/unsubscribe',
 ]);
 
-const USER_BEARER_PREFIXES = [
-  '/api/room/media/realtime/',
-  '/api/room/media/cloudflare_realtimekit/',
-];
+const USER_BEARER_PREFIXES: string[] = [];
 
 const SERVICE_KEY_ONLY_PATHS = new Set([
   '/api/db/broadcast',

package/src/routes/room.ts

@@ -65,109 +65,6 @@ const roomSummaryCollectionSchema = z.object({
   deniedIds: z.array(z.string()),
   updatedAt: z.string(),
 });
-const roomRealtimeSessionDescriptionSchema = z.object({
-  sdp: z.string().openapi({ description: 'WebRTC session description payload' }),
-  type: z.enum(['offer', 'answer']).openapi({ description: 'Session description type' }),
-});
-const roomRealtimeTrackSchema = z.object({
-  location: z.enum(['local', 'remote']).openapi({ description: 'Track direction relative to the caller' }),
-  mid: z.string().optional().openapi({ description: 'WebRTC media ID' }),
-  sessionId: z.string().optional().openapi({ description: 'Provider session ID associated with this track' }),
-  trackName: z.string().optional().openapi({ description: 'Track name used by the provider' }),
-  bidirectionalMediaStream: z.boolean().optional().openapi({ description: 'Whether the track should be bidirectional' }),
-  kind: z.string().optional().openapi({ description: 'Track kind reported by the provider' }),
-  simulcast: z.object({
-    preferredRid: z.string().optional(),
-    priorityOrdering: z.enum(['none', 'asciibetical']).optional(),
-    ridNotAvailable: z.enum(['none', 'asciibetical']).optional(),
-  }).optional().openapi({ description: 'Optional simulcast preferences' }),
-  errorCode: z.string().optional().openapi({ description: 'Provider-level error code for this track' }),
-  errorDescription: z.string().optional().openapi({ description: 'Provider-level error description for this track' }),
-});
-const roomRealtimeCreateSessionBodySchema = z.object({
-  connectionId: z.string().optional().openapi({ description: 'Specific room connection ID to bind the realtime session to' }),
-  correlationId: z.string().optional().openapi({ description: 'Optional provider correlation ID' }),
-  thirdparty: z.boolean().optional().openapi({ description: 'Forward Cloudflare Realtime thirdparty mode' }),
-  sessionDescription: roomRealtimeSessionDescriptionSchema.optional(),
-});
-const roomCloudflareRealtimeKitCreateSessionBodySchema = z.object({
-  connectionId: z.string().optional().openapi({ description: 'Specific room connection ID to bind the Cloudflare RealtimeKit participant to' }),
-  customParticipantId: z.string().optional().openapi({ description: 'Optional custom participant identifier for the provisioned RealtimeKit participant' }),
-  name: z.string().optional().openapi({ description: 'Optional display name for the provisioned RealtimeKit participant' }),
-  picture: z.string().optional().openapi({ description: 'Optional avatar URL for the provisioned RealtimeKit participant' }),
-});
-const roomRealtimeCreateSessionResponseSchema = z.object({
-  sessionId: z.string().openapi({ description: 'Realtime provider session ID' }),
-  sessionDescription: roomRealtimeSessionDescriptionSchema.optional(),
-  errorCode: z.string().optional(),
-  errorDescription: z.string().optional(),
-  connectionId: z.string().optional().openapi({ description: 'Room connection ID associated with the session' }),
-  reused: z.boolean().optional().openapi({ description: 'Whether an existing provider session was reused' }),
-});
-const roomCloudflareRealtimeKitCreateSessionResponseSchema = z.object({
-  sessionId: z.string().openapi({ description: 'Cloudflare RealtimeKit participant ID' }),
-  meetingId: z.string().openapi({ description: 'Cloudflare RealtimeKit meeting ID backing the room session' }),
-  participantId: z.string().openapi({ description: 'Cloudflare RealtimeKit participant ID' }),
-  authToken: z.string().openapi({ description: 'RealtimeKit auth token for the provisioned participant' }),
-  presetName: z.string().optional().openapi({ description: 'RealtimeKit preset used for the provisioned participant' }),
-  connectionId: z.string().optional().openapi({ description: 'Room connection ID associated with the session' }),
-  reused: z.boolean().optional().openapi({ description: 'Whether an existing provider participant was reused' }),
-});
-const roomRealtimeSessionStateSchema = z.object({
-  sessionId: z.string().openapi({ description: 'Realtime provider session ID' }),
-  connectionId: z.string().optional().openapi({ description: 'Room connection ID associated with the session' }),
-  createdAt: z.number().openapi({ description: 'Unix epoch milliseconds when the session was created' }),
-  updatedAt: z.number().openapi({ description: 'Unix epoch milliseconds when the session was last updated' }),
-});
-const roomRealtimeIceServerSchema = z.object({
-  urls: z.union([z.array(z.string()), z.string()]).openapi({ description: 'ICE server URL or URL list' }),
-  username: z.string().optional(),
-  credential: z.string().optional(),
-});
-const roomRealtimeIceServersBodySchema = z.object({
-  ttl: z.number().optional().openapi({ description: 'Requested TURN credential TTL in seconds' }),
-});
-const roomRealtimeIceServersResponseSchema = z.object({
-  iceServers: z.array(roomRealtimeIceServerSchema).openapi({ description: 'ICE servers returned by Cloudflare TURN' }),
-});
-const roomRealtimeTracksResponseSchema = z.object({
-  errorCode: z.string().optional(),
-  errorDescription: z.string().optional(),
-  requiresImmediateRenegotiation: z.boolean().optional(),
-  sessionDescription: roomRealtimeSessionDescriptionSchema.optional(),
-  tracks: z.array(roomRealtimeTrackSchema).optional(),
-});
-const roomRealtimeTracksBodySchema = z.object({
-  sessionId: z.string().openapi({ description: 'Realtime provider session ID' }),
-  connectionId: z.string().optional().openapi({ description: 'Specific room connection ID to bind the track operation to' }),
-  sessionDescription: roomRealtimeSessionDescriptionSchema.optional(),
-  tracks: z.array(roomRealtimeTrackSchema).min(1).openapi({ description: 'Tracks to create or subscribe to' }),
-  autoDiscover: z.boolean().optional().openapi({ description: 'Ask the provider to auto-discover remote tracks' }),
-  publish: z.object({
-    kind: z.enum(['audio', 'video', 'screen']).optional(),
-    trackId: z.string().optional(),
-    deviceId: z.string().optional(),
-    muted: z.boolean().optional(),
-  }).optional().openapi({ description: 'Optional room media state updates to apply after track creation' }),
-});
-const roomRealtimeRenegotiateBodySchema = z.object({
-  sessionId: z.string().openapi({ description: 'Realtime provider session ID' }),
-  connectionId: z.string().optional().openapi({ description: 'Specific room connection ID to bind the renegotiation to' }),
-  sessionDescription: roomRealtimeSessionDescriptionSchema,
-});
-const roomRealtimeCloseTracksBodySchema = z.object({
-  sessionId: z.string().openapi({ description: 'Realtime provider session ID' }),
-  connectionId: z.string().optional().openapi({ description: 'Specific room connection ID to bind the close operation to' }),
-  sessionDescription: roomRealtimeSessionDescriptionSchema.optional(),
-  tracks: z.array(z.object({
-    mid: z.string().openapi({ description: 'Track MID to close' }),
-  })).min(1).openapi({ description: 'Tracks to close' }),
-  force: z.boolean().optional().openapi({ description: 'Force close even if the provider reports the track as active' }),
-  unpublish: z.object({
-    kind: z.enum(['audio', 'video', 'screen']).optional(),
-  }).optional().openapi({ description: 'Optional room media state cleanup after closing tracks' }),
-});
-
 function isRoomOperationPublic(
   namespaceConfig: RoomNamespaceConfig | null | undefined,
   operation: 'metadata' | 'join' | 'action',
@@ -705,185 +602,3 @@ roomRoute.openapi(getRoomSummaries, async (c) => {
     updatedAt: new Date().toISOString(),
   });
 });
-
-const getRoomRealtimeSession = createRoute({
-  operationId: 'getRoomRealtimeSession',
-  method: 'get',
-  path: '/media/realtime/session',
-  tags: ['client'],
-  summary: 'Get the active room realtime media session',
-  description: 'Returns the provider session currently bound to the authenticated room member.',
-  request: {
-    query: roomQuerySchema.extend({
-      connectionId: z.string().optional().openapi({ description: 'Optional room connection ID override' }),
-    }),
-  },
-  responses: {
-    200: { description: 'Active room realtime session', content: { 'application/json': { schema: roomRealtimeSessionStateSchema } } },
-    400: { description: 'Bad request', content: { 'application/json': { schema: errorResponseSchema } } },
-    401: { description: 'Authentication required', content: { 'application/json': { schema: errorResponseSchema } } },
-    403: { description: 'Forbidden', content: { 'application/json': { schema: errorResponseSchema } } },
-    404: { description: 'No active session or runtime not found', content: { 'application/json': { schema: errorResponseSchema } } },
-  },
-});
-
-const createRoomRealtimeSession = createRoute({
-  operationId: 'createRoomRealtimeSession',
-  method: 'post',
-  path: '/media/realtime/session',
-  tags: ['client'],
-  summary: 'Create a room realtime media session',
-  description: 'Creates a Cloudflare Realtime session for the authenticated room member.',
-  request: {
-    query: roomQuerySchema,
-    body: { content: { 'application/json': { schema: roomRealtimeCreateSessionBodySchema } }, required: false },
-  },
-  responses: {
-    200: { description: 'Realtime session created', content: { 'application/json': { schema: roomRealtimeCreateSessionResponseSchema } } },
-    400: { description: 'Bad request', content: { 'application/json': { schema: errorResponseSchema } } },
-    401: { description: 'Authentication required', content: { 'application/json': { schema: errorResponseSchema } } },
-    403: { description: 'Forbidden', content: { 'application/json': { schema: errorResponseSchema } } },
-    404: { description: 'Room runtime not found', content: { 'application/json': { schema: errorResponseSchema } } },
-    409: { description: 'Conflicting existing published media', content: { 'application/json': { schema: errorResponseSchema } } },
-  },
-});
-
-const createRoomCloudflareRealtimeKitSession = createRoute({
-  operationId: 'createRoomCloudflareRealtimeKitSession',
-  method: 'post',
-  path: '/media/cloudflare_realtimekit/session',
-  tags: ['client'],
-  summary: 'Create a room Cloudflare RealtimeKit session',
-  description: 'Creates a Cloudflare RealtimeKit session for the authenticated room member.',
-  request: {
-    query: roomQuerySchema,
-    body: { content: { 'application/json': { schema: roomCloudflareRealtimeKitCreateSessionBodySchema } }, required: false },
-  },
-  responses: {
-    200: { description: 'Cloudflare RealtimeKit session created', content: { 'application/json': { schema: roomCloudflareRealtimeKitCreateSessionResponseSchema } } },
-    400: { description: 'Bad request', content: { 'application/json': { schema: errorResponseSchema } } },
-    401: { description: 'Authentication required', content: { 'application/json': { schema: errorResponseSchema } } },
-    403: { description: 'Forbidden', content: { 'application/json': { schema: errorResponseSchema } } },
-    404: { description: 'Room runtime not found', content: { 'application/json': { schema: errorResponseSchema } } },
-    409: { description: 'Conflicting existing published media', content: { 'application/json': { schema: errorResponseSchema } } },
-  },
-});
-
-const createRoomRealtimeIceServers = createRoute({
-  operationId: 'createRoomRealtimeIceServers',
-  method: 'post',
-  path: '/media/realtime/turn',
-  tags: ['client'],
-  summary: 'Generate TURN / ICE credentials for room realtime media',
-  description: 'Generates ICE server credentials for the authenticated room member.',
-  request: {
-    query: roomQuerySchema,
-    body: { content: { 'application/json': { schema: roomRealtimeIceServersBodySchema } }, required: false },
-  },
-  responses: {
-    200: { description: 'ICE servers generated', content: { 'application/json': { schema: roomRealtimeIceServersResponseSchema } } },
-    400: { description: 'Bad request', content: { 'application/json': { schema: errorResponseSchema } } },
-    401: { description: 'Authentication required', content: { 'application/json': { schema: errorResponseSchema } } },
-    403: { description: 'Forbidden', content: { 'application/json': { schema: errorResponseSchema } } },
-    404: { description: 'Room runtime not found', content: { 'application/json': { schema: errorResponseSchema } } },
-  },
-});
-
-const addRoomRealtimeTracks = createRoute({
-  operationId: 'addRoomRealtimeTracks',
-  method: 'post',
-  path: '/media/realtime/tracks/new',
-  tags: ['client'],
-  summary: 'Add realtime media tracks to a room session',
-  description: 'Creates or subscribes realtime tracks for the authenticated room member.',
-  request: {
-    query: roomQuerySchema,
-    body: { content: { 'application/json': { schema: roomRealtimeTracksBodySchema } }, required: true },
-  },
-  responses: {
-    200: { description: 'Realtime tracks updated', content: { 'application/json': { schema: roomRealtimeTracksResponseSchema } } },
-    400: { description: 'Bad request', content: { 'application/json': { schema: errorResponseSchema } } },
-    401: { description: 'Authentication required', content: { 'application/json': { schema: errorResponseSchema } } },
-    403: { description: 'Forbidden', content: { 'application/json': { schema: errorResponseSchema } } },
-    404: { description: 'Room runtime not found', content: { 'application/json': { schema: errorResponseSchema } } },
-  },
-});
-
-const renegotiateRoomRealtimeSession = createRoute({
-  operationId: 'renegotiateRoomRealtimeSession',
-  method: 'put',
-  path: '/media/realtime/renegotiate',
-  tags: ['client'],
-  summary: 'Renegotiate a room realtime media session',
-  description: 'Submits a new session description for an existing room realtime media session.',
-  request: {
-    query: roomQuerySchema,
-    body: { content: { 'application/json': { schema: roomRealtimeRenegotiateBodySchema } }, required: true },
-  },
-  responses: {
-    200: { description: 'Realtime session renegotiated', content: { 'application/json': { schema: roomRealtimeTracksResponseSchema } } },
-    400: { description: 'Bad request', content: { 'application/json': { schema: errorResponseSchema } } },
-    401: { description: 'Authentication required', content: { 'application/json': { schema: errorResponseSchema } } },
-    403: { description: 'Forbidden', content: { 'application/json': { schema: errorResponseSchema } } },
-    404: { description: 'Room runtime not found', content: { 'application/json': { schema: errorResponseSchema } } },
-  },
-});
-
-const closeRoomRealtimeTracks = createRoute({
-  operationId: 'closeRoomRealtimeTracks',
-  method: 'put',
-  path: '/media/realtime/tracks/close',
-  tags: ['client'],
-  summary: 'Close room realtime media tracks',
-  description: 'Closes provider tracks for the authenticated room member and optionally unpublishes room media state.',
-  request: {
-    query: roomQuerySchema,
-    body: { content: { 'application/json': { schema: roomRealtimeCloseTracksBodySchema } }, required: true },
-  },
-  responses: {
-    200: { description: 'Realtime tracks closed', content: { 'application/json': { schema: roomRealtimeTracksResponseSchema } } },
-    400: { description: 'Bad request', content: { 'application/json': { schema: errorResponseSchema } } },
-    401: { description: 'Authentication required', content: { 'application/json': { schema: errorResponseSchema } } },
-    403: { description: 'Forbidden', content: { 'application/json': { schema: errorResponseSchema } } },
-    404: { description: 'Room runtime not found', content: { 'application/json': { schema: errorResponseSchema } } },
-  },
-});
-
-roomRoute.openapi(getRoomRealtimeSession, async (c) =>
-  proxyRoomDoRequest(c, '/media/realtime/session', 'GET', { requireAuth: true }));
-
-roomRoute.openapi(createRoomRealtimeSession, async (c) =>
-  proxyRoomDoRequest(c, '/media/realtime/session', 'POST', {
-    requireAuth: true,
-    validatedJson: c.req.valid('json'),
-  }));
-
-roomRoute.openapi(createRoomRealtimeIceServers, async (c) =>
-  proxyRoomDoRequest(c, '/media/realtime/turn', 'POST', {
-    requireAuth: true,
-    validatedJson: c.req.valid('json'),
-  }));
-
-roomRoute.openapi(addRoomRealtimeTracks, async (c) =>
-  proxyRoomDoRequest(c, '/media/realtime/tracks/new', 'POST', {
-    requireAuth: true,
-    validatedJson: c.req.valid('json'),
-  }));
-
-roomRoute.openapi(renegotiateRoomRealtimeSession, async (c) =>
-  proxyRoomDoRequest(c, '/media/realtime/renegotiate', 'PUT', {
-    requireAuth: true,
-    validatedJson: c.req.valid('json'),
-  }));
-
-roomRoute.openapi(closeRoomRealtimeTracks, async (c) =>
-  proxyRoomDoRequest(c, '/media/realtime/tracks/close', 'PUT', {
-    requireAuth: true,
-    validatedJson: c.req.valid('json'),
-  }));
-
-roomRoute.openapi(createRoomCloudflareRealtimeKitSession, async (c) =>
-  proxyRoomDoRequest(c, '/media/cloudflare_realtimekit/session', 'POST', {
-    requireAuth: true,
-    validatedJson: c.req.valid('json'),
-  }));

package/src/types.ts

@@ -7,7 +7,7 @@ export interface Env {
   DATABASE: DurableObjectNamespace;
   AUTH: DurableObjectNamespace;
   DATABASE_LIVE: DurableObjectNamespace;
-  /** Room DO — per-room state synchronization, members, signals, media */
+  /** Room DO — per-room state synchronization, members, and signals */
   ROOMS: DurableObjectNamespace;
 
   // ─── R2 Storage ───
@@ -66,19 +66,6 @@ export interface Env {
   TURNSTILE_SECRET?: string;
   /** Turnstile site key — public, returned to clients via GET /api/config (§34) */
   CAPTCHA_SITE_KEY?: string;
-  /** Cloudflare Realtime app ID for SFU session control. */
-  CF_REALTIME_APP_ID?: string;
-  /** Cloudflare RealtimeKit preset name used when creating participant tokens. */
-  CF_REALTIME_PRESET_NAME?: string;
-  /** Cloudflare Realtime app secret for SFU session control. */
-  CF_REALTIME_APP_SECRET?: string;
-  /** Optional override for the Cloudflare Realtime API base URL. */
-  CF_REALTIME_BASE_URL?: string;
-  /** Cloudflare TURN key ID used to mint short-lived ICE credentials. */
-  CF_REALTIME_TURN_KEY_ID?: string;
-  /** Cloudflare TURN API token returned when the TURN key is created. */
-  CF_REALTIME_TURN_API_TOKEN?: string;
-
   // ─── Environment Identification ───
   /** Server environment name for Service Key constraints.env evaluation */
   ENVIRONMENT?: string;