@absolutejs/voice 0.0.22-beta.671 → 0.0.22-beta.673

package/dist/index.js

@@ -249,6 +249,7 @@ var resolveAudioConditioningConfig = (config) => {
 
 // src/core/plugin.ts
 import { Elysia as Elysia70 } from "elysia";
+import { websocket as websocket5 } from "elysia/websocket";
 import { resolve } from "path";
 
 // src/internal/html.ts
@@ -4434,9 +4435,13 @@ var createVoiceSession = (options) => {
       if (snapshot.status === "completed" || snapshot.status === "failed" || snapshot.call?.endedAt) {
         return;
       }
+      const { lastSpeechAt, lastTranscriptAt } = snapshot.currentTurn;
+      if (lastTranscriptAt !== undefined && stuckCloseAfterMs !== undefined && Date.now() - lastTranscriptAt < stuckCloseAfterMs) {
+        kickStuckCloseWatchdog();
+        return;
+      }
       stuckCloseFired = true;
       const reason = `no caller progress for ${stuckCloseAfterMs}ms`;
-      const { lastSpeechAt, lastTranscriptAt } = snapshot.currentTurn;
       const sttDeafConfirmed = sttDeafConfirmedAt > 0 && (lastTranscriptAt === undefined || sttDeafConfirmedAt > lastTranscriptAt);
       const diagnostic = {
         action: "stuck-call-close",
@@ -21385,6 +21390,7 @@ var summarizeVoiceMediaPipelineReport = (report, options = {}) => {
 
 // src/core/monitor.ts
 import { Elysia as Elysia32 } from "elysia";
+import { websocket } from "elysia/websocket";
 var buildAudioFanout = () => {
   const handlers = new Set;
   return {
@@ -21673,7 +21679,7 @@ var createVoiceLiveMonitorRoutes = (options) => {
     transfer: options.controlHandlers?.transfer ?? buildDefaultControlHandler("transfer"),
     voicemail: options.controlHandlers?.voicemail ?? buildDefaultControlHandler("voicemail")
   };
-  const app = new Elysia32({ name: "absolutejs-voice-monitor" });
+  const app = new Elysia32({ name: "absolutejs-voice-monitor" }).use(websocket());
   const unsubscribers = new WeakMap;
   if (listenPath !== false && listenPath.length > 0) {
     app.ws(`/${listenPath.replace(/^\/+/, "")}`, {
@@ -24884,7 +24890,9 @@ var createVoiceTelephonyWebhookRoutes = (options = {}) => {
   const handler = createVoiceTelephonyWebhookHandler(options);
   return new Elysia36({
     name: options.name ?? "absolutejs-voice-telephony-webhooks"
-  }).post(path, async ({ query, request }) => {
+  }).post(path, {
+    parse: "none"
+  }, async ({ query, request }) => {
     try {
       return await handler({ query, request });
     } catch (error) {
@@ -24898,8 +24906,6 @@ var createVoiceTelephonyWebhookRoutes = (options = {}) => {
       }
       throw error;
     }
-  }, {
-    parse: "none"
   });
 };
 
@@ -25439,10 +25445,12 @@ var createVoiceSQLiteTraceSinkDeliveryStore = (options) => createSQLiteTraceSink
 import { Buffer as Buffer4 } from "buffer";
 import { Database as Database3 } from "bun:sqlite";
 import { Elysia as Elysia38 } from "elysia";
+import { websocket as websocket3 } from "elysia/websocket";
 
 // src/telephony/twilio.ts
 import { Buffer as Buffer3 } from "buffer";
 import { Elysia as Elysia37 } from "elysia";
+import { websocket as websocket2 } from "elysia/websocket";
 var TWILIO_MULAW_SAMPLE_RATE = 8000;
 var VOICE_PCM_SAMPLE_RATE = 16000;
 var escapeXml2 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
@@ -25477,10 +25485,12 @@ var resolveTrustedTwilioRequestUrl = (security, request) => {
   return `${resolveTwilioPublicOrigin(security)}${requestUrl.pathname}${requestUrl.search}`;
 };
 var resolveTwilioSocketHeaders = (socket) => {
-  if (!socket.data || typeof socket.data !== "object")
-    return new Headers;
-  const data = socket.data;
-  for (const candidate of [data.request?.headers, data.headers]) {
+  const data = socket.data && typeof socket.data === "object" ? socket.data : {
+    headers: socket.headers,
+    request: socket.request && typeof socket.request === "object" ? socket.request : undefined
+  };
+  const candidates = [data.request?.headers, data.headers];
+  for (const candidate of candidates) {
     if (!candidate)
       continue;
     if (typeof candidate === "object" && "get" in candidate && typeof candidate.get === "function") {
@@ -25492,6 +25502,7 @@ var resolveTwilioSocketHeaders = (socket) => {
   }
   return new Headers;
 };
+var socketKey = (socket) => ("raw" in socket) && socket.raw && typeof socket.raw === "object" ? socket.raw : socket;
 var readTwilioVoiceForm = async (request) => {
   const declaredLength = Number(request.headers.get("content-length"));
   if (Number.isFinite(declaredLength) && declaredLength > MAX_TWILIO_VOICE_BODY_BYTES) {
@@ -26259,9 +26270,9 @@ var createTwilioVoiceRoutes = (options) => {
   const streamVerificationUrl = options.security.streamVerificationUrl ?? `${resolveTwilioPublicOrigin(options.security).replace(/^https:/, "wss:")}${streamPath}`;
   const app = new Elysia37({
     name: options.name ?? "absolutejs-voice-twilio"
-  }).get(twimlPath, renderTwiml).post(twimlPath, renderTwiml, { parse: "none" }).ws(streamPath, {
+  }).use(websocket2()).get(twimlPath, renderTwiml).post(twimlPath, { parse: "none" }, renderTwiml).ws(streamPath, {
     close: async (ws, _code, reason) => {
-      const key = ws.raw ?? ws;
+      const key = socketKey(ws);
       const bridge = bridges.get(key);
       bridges.delete(key);
       admittedSockets.delete(key);
@@ -26269,7 +26280,7 @@ var createTwilioVoiceRoutes = (options) => {
       await bridge?.close(reason);
     },
     message: async (ws, raw) => {
-      const key = ws.raw ?? ws;
+      const key = socketKey(ws);
       if (!admittedSockets.has(key)) {
         const verification = await verifyVoiceTwilioWebhookSignature({
           authToken: options.security.authToken,
@@ -26876,6 +26887,7 @@ var createPlivoVoiceRoutes = (options = {}) => {
   const setupPath = options.setup?.path === false ? false : options.setup?.path ?? "/api/voice/plivo/setup";
   const smokePath = options.smoke?.path === false ? false : options.smoke?.path ?? "/api/voice/plivo/smoke";
   const bridges = new WeakMap;
+  const socketKey2 = (socket) => ("raw" in socket) && socket.raw && typeof socket.raw === "object" ? socket.raw : socket;
   const webhookPolicy = options.webhook?.policy ?? options.outcomePolicy ?? createVoiceTelephonyOutcomePolicy();
   const verify = options.webhook?.verify ?? (options.webhook?.authToken ? createVoicePlivoWebhookVerifier({
     authToken: options.webhook.authToken,
@@ -26884,7 +26896,7 @@ var createPlivoVoiceRoutes = (options = {}) => {
   }) : undefined);
   const app = new Elysia38({
     name: options.name ?? "absolutejs-voice-plivo"
-  }).get(answerPath, async ({ query, request }) => {
+  }).use(websocket3()).get(answerPath, async ({ query, request }) => {
     const streamUrl = await resolvePlivoStreamUrl(options, {
       query,
       request,
@@ -26914,7 +26926,7 @@ var createPlivoVoiceRoutes = (options = {}) => {
     });
   }).ws(streamPath, {
     close: async (ws, _code, reason) => {
-      const key = ws.raw ?? ws;
+      const key = socketKey2(ws);
       const bridge = bridges.get(key);
       bridges.delete(key);
       await bridge?.close(reason);
@@ -26924,7 +26936,7 @@ var createPlivoVoiceRoutes = (options = {}) => {
         ws.close(1011, "Plivo media bridge is not configured.");
         return;
       }
-      const key = ws.raw ?? ws;
+      const key = socketKey2(ws);
       let bridge = bridges.get(key);
       if (!bridge) {
         bridge = createPlivoMediaStreamBridge({
@@ -26997,6 +27009,7 @@ var createPlivoVoiceRoutes = (options = {}) => {
 import { Buffer as Buffer5 } from "buffer";
 import { Database as Database4 } from "bun:sqlite";
 import { Elysia as Elysia39 } from "elysia";
+import { websocket as websocket4 } from "elysia/websocket";
 var escapeXml4 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var joinUrlPath3 = (origin, path) => `${origin.replace(/\/$/, "")}${path.startsWith("/") ? path : `/${path}`}`;
 var resolveRequestOrigin2 = (request) => {
@@ -27455,6 +27468,7 @@ var createTelnyxVoiceRoutes = (options = {}) => {
   const setupPath = options.setup?.path === false ? false : options.setup?.path ?? "/api/voice/telnyx/setup";
   const smokePath = options.smoke?.path === false ? false : options.smoke?.path ?? "/api/voice/telnyx/smoke";
   const bridges = new WeakMap;
+  const socketKey2 = (socket) => ("raw" in socket) && socket.raw && typeof socket.raw === "object" ? socket.raw : socket;
   const webhookPolicy = options.webhook?.policy ?? options.outcomePolicy ?? createVoiceTelephonyOutcomePolicy();
   const verify = options.webhook?.verify ?? (options.webhook?.publicKey ? createVoiceTelnyxWebhookVerifier({
     eventStore: options.webhook.eventStore,
@@ -27463,7 +27477,7 @@ var createTelnyxVoiceRoutes = (options = {}) => {
   }) : undefined);
   const app = new Elysia39({
     name: options.name ?? "absolutejs-voice-telnyx"
-  }).get(texmlPath, async ({ query, request }) => {
+  }).use(websocket4()).get(texmlPath, async ({ query, request }) => {
     const streamUrl = await resolveTelnyxStreamUrl(options, {
       query,
       request,
@@ -27493,7 +27507,7 @@ var createTelnyxVoiceRoutes = (options = {}) => {
     });
   }).ws(streamPath, {
     close: async (ws, _code, reason) => {
-      const key = ws.raw ?? ws;
+      const key = socketKey2(ws);
       const bridge = bridges.get(key);
       bridges.delete(key);
       await bridge?.close(reason);
@@ -27503,7 +27517,7 @@ var createTelnyxVoiceRoutes = (options = {}) => {
         ws.close(1011, "Telnyx media bridge is not configured.");
         return;
       }
-      const key = ws.raw ?? ws;
+      const key = socketKey2(ws);
       let bridge = bridges.get(key);
       if (!bridge) {
         bridge = createTelnyxMediaStreamBridge({
@@ -31808,7 +31822,9 @@ var createVoiceOpsWebhookEnvelope = async (input) => {
 };
 var createVoiceOpsWebhookReceiverRoutes = (options = {}) => {
   const path = options.path ?? "/api/voice-ops/webhook";
-  return new Elysia48().post(path, async ({ body, request, set }) => {
+  return new Elysia48().post(path, {
+    parse: "text"
+  }, async ({ body, request, set }) => {
     const bodyText = typeof body === "string" ? body : JSON.stringify(body);
     if (options.signingSecret) {
       const verification = await verifyVoiceOpsWebhookSignature({
@@ -31836,8 +31852,6 @@ var createVoiceOpsWebhookReceiverRoutes = (options = {}) => {
       ok: true,
       type: envelope.event?.type
     };
-  }, {
-    parse: "text"
   });
 };
 var createVoiceOpsWebhookSink = (options) => createVoiceIntegrationHTTPSink({
@@ -40107,7 +40121,7 @@ var parseClientMessage = (raw) => {
   return null;
 };
 var resolveSessionId3 = (runtime, ws) => {
-  const query = ws.data && typeof ws.data === "object" && "query" in ws.data ? ws.data.query : undefined;
+  const query = resolveSocketQuery(ws);
   const identity = socketIdentity(ws);
   const existing = runtime.socketSessions.get(identity);
   const providedSessionId = typeof query?.sessionId === "string" && query.sessionId.trim() ? query.sessionId.trim() : existing?.sessionId ?? createId();
@@ -40119,7 +40133,21 @@ var resolveSessionId3 = (runtime, ws) => {
   runtime.socketSessions.set(identity, resolved);
   return resolved;
 };
-var resolveSocketQuery = (ws) => ws.data && typeof ws.data === "object" && ("query" in ws.data) ? ws.data.query ?? {} : {};
+var resolveSocketQuery = (ws) => {
+  if (ws.query && typeof ws.query === "object") {
+    return ws.query;
+  }
+  if (ws.data && typeof ws.data === "object" && "query" in ws.data) {
+    return ws.data.query ?? {};
+  }
+  return {};
+};
+var resolveSocketContext = (ws) => {
+  if (ws.data && typeof ws.data === "object" && (("headers" in ws.data) || ("query" in ws.data) || ("request" in ws.data))) {
+    return ws.data;
+  }
+  return ws;
+};
 var normalizeSocketHeaders = (value) => {
   if (!value || typeof value !== "object")
     return null;
@@ -40133,6 +40161,14 @@ var normalizeSocketHeaders = (value) => {
   }
 };
 var resolveSocketHeaders = (ws) => {
+  if (ws.request && typeof ws.request === "object" && "headers" in ws.request) {
+    const requestHeaders = normalizeSocketHeaders(ws.request.headers);
+    if (requestHeaders)
+      return requestHeaders;
+  }
+  const directContextHeaders = normalizeSocketHeaders(ws.headers);
+  if (directContextHeaders)
+    return directContextHeaders;
   if (!ws.data || typeof ws.data !== "object")
     return new Headers;
   if ("request" in ws.data && ws.data.request && typeof ws.data.request === "object" && "headers" in ws.data.request) {
@@ -40339,7 +40375,7 @@ var voice = (config) => {
       let authorized = false;
       try {
         authorized = await config.authorizeConnection({
-          context: ws.data,
+          context: resolveSocketContext(ws),
           headers: resolveSocketHeaders(ws),
           path: config.path,
           query: resolveSocketQuery(ws),
@@ -40431,7 +40467,7 @@ var voice = (config) => {
   const htmxRenderers = resolveVoiceHTMXRenderers(config.htmx && config.htmx !== true ? config.htmx : undefined);
   const htmxTargets = resolveVoiceHTMXTargets(htmxOptions?.targets);
   const createManagedSession = async (ws, sessionId, scenarioId) => {
-    const context = ws.data;
+    const context = resolveSocketContext(ws);
     const profileSwitchDecision = await resolveProfileSwitchGuard(config, runtime, {
       context,
       scenarioId,
@@ -40720,7 +40756,7 @@ var voice = (config) => {
       }
     }));
   };
-  return new Elysia70({ name: "absolutejs-voice" }).ws(config.path, {
+  return new Elysia70({ name: "absolutejs-voice" }).use(websocket5()).ws(config.path, {
     close: async (ws, code, reason) => {
       const identity = socketIdentity(ws);
       closedSockets.add(identity);
@@ -44087,7 +44123,7 @@ var isBypassed = (bypassPaths, url) => {
 };
 var createVoiceRouteAuth = (options) => {
   const bypassPaths = options.bypassPaths ?? [];
-  return new Elysia71({ name: options.name ?? "voice-route-auth" }).onRequest(async ({ request, set }) => {
+  return new Elysia71({ name: options.name ?? "voice-route-auth" }).request(async ({ request, set }) => {
     const { url } = request;
     if (isBypassed(bypassPaths, url))
       return;

package/dist/telephony/matrix.d.ts

@@ -1,4 +1,3 @@
-import { Elysia } from "elysia";
 import { type VoiceTelephonyContractOptions, type VoiceTelephonyContractReport, type VoiceTelephonyProvider, type VoiceTelephonySetupStatus, type VoiceTelephonySmokeReport } from "./contract";
 export type VoiceTelephonyCarrierMatrixStatus = "fail" | "pass" | "warn";
 export type VoiceTelephonyCarrierMatrixInput<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = {
@@ -52,46 +51,156 @@ export type VoiceTelephonyCarrierMatrixRoutesOptions = {
     contract?: VoiceTelephonyContractOptions;
 };
 export declare const createVoiceTelephonyCarrierMatrix: (options: VoiceTelephonyCarrierMatrixOptions) => VoiceTelephonyCarrierMatrix;
-export declare const createVoiceTelephonyCarrierMatrixRoutes: (options: VoiceTelephonyCarrierMatrixRoutesOptions) => Elysia<"", {
-    decorator: {};
-    store: {};
-    derive: {};
-    resolve: {};
-}, {
+export declare const createVoiceTelephonyCarrierMatrixRoutes: (options: VoiceTelephonyCarrierMatrixRoutesOptions) => import("elysia/types").AddRoute<"", "local", import("elysia/types").DefaultSingleton, {
     typebox: {};
-    error: {};
-}, {
-    schema: {};
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: {};
-}, {
-    [x: string]: {
-        get: {
-            body: unknown;
-            params: {};
-            query: unknown;
-            headers: unknown;
-            response: {
-                200: Response | VoiceTelephonyCarrierMatrix;
-            };
-        };
+    error: [];
+}, import("elysia/types").DefaultMetadata, {}, import("elysia/types").DefaultEphemeral, import("elysia/types").DefaultEphemeral, "get", string, import("elysia/types").IntersectIfObjectSchema<import("elysia").UnwrapRoute<{}, {}, `/${string}`>, import("elysia/types").MergeScopedSchemas<{}, {}, {}>>, {}, ({ query, request }: {
+    body: unknown;
+    query: Record<string, string | undefined>;
+    params: {};
+    headers: Record<string, string | undefined>;
+    cookie: Record<string, import("elysia").Cookie<unknown>>;
+    server: import("elysia").Server | null;
+    redirect: import("elysia").redirect;
+    set: {
+        headers: import("elysia").HTTPHeaders;
+        status?: number | keyof import("elysia").StatusMap;
+        cookie?: Record<string, import("elysia").BaseCookie>;
     };
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}>;
+    status: <const Code extends number | keyof import("elysia").StatusMap, const T = Code extends 100 | 404 | 400 | 408 | 401 | 503 | 200 | 429 | 500 | 300 | 420 | 413 | 415 | 403 | 101 | 102 | 103 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 301 | 302 | 303 | 304 | 307 | 308 | 402 | 405 | 406 | 407 | 409 | 410 | 411 | 412 | 414 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 431 | 451 | 501 | 502 | 504 | 505 | 506 | 507 | 508 | 510 | 511 ? {
+        readonly 100: "Continue";
+        readonly 101: "Switching Protocols";
+        readonly 102: "Processing";
+        readonly 103: "Early Hints";
+        readonly 200: "OK";
+        readonly 201: "Created";
+        readonly 202: "Accepted";
+        readonly 203: "Non-Authoritative Information";
+        readonly 204: "No Content";
+        readonly 205: "Reset Content";
+        readonly 206: "Partial Content";
+        readonly 207: "Multi-Status";
+        readonly 208: "Already Reported";
+        readonly 300: "Multiple Choices";
+        readonly 301: "Moved Permanently";
+        readonly 302: "Found";
+        readonly 303: "See Other";
+        readonly 304: "Not Modified";
+        readonly 307: "Temporary Redirect";
+        readonly 308: "Permanent Redirect";
+        readonly 400: "Bad Request";
+        readonly 401: "Unauthorized";
+        readonly 402: "Payment Required";
+        readonly 403: "Forbidden";
+        readonly 404: "Not Found";
+        readonly 405: "Method Not Allowed";
+        readonly 406: "Not Acceptable";
+        readonly 407: "Proxy Authentication Required";
+        readonly 408: "Request Timeout";
+        readonly 409: "Conflict";
+        readonly 410: "Gone";
+        readonly 411: "Length Required";
+        readonly 412: "Precondition Failed";
+        readonly 413: "Payload Too Large";
+        readonly 414: "URI Too Long";
+        readonly 415: "Unsupported Media Type";
+        readonly 416: "Range Not Satisfiable";
+        readonly 417: "Expectation Failed";
+        readonly 418: "I'm a teapot";
+        readonly 420: "Enhance Your Calm";
+        readonly 421: "Misdirected Request";
+        readonly 422: "Unprocessable Content";
+        readonly 423: "Locked";
+        readonly 424: "Failed Dependency";
+        readonly 425: "Too Early";
+        readonly 426: "Upgrade Required";
+        readonly 428: "Precondition Required";
+        readonly 429: "Too Many Requests";
+        readonly 431: "Request Header Fields Too Large";
+        readonly 451: "Unavailable For Legal Reasons";
+        readonly 500: "Internal Server Error";
+        readonly 501: "Not Implemented";
+        readonly 502: "Bad Gateway";
+        readonly 503: "Service Unavailable";
+        readonly 504: "Gateway Timeout";
+        readonly 505: "HTTP Version Not Supported";
+        readonly 506: "Variant Also Negotiates";
+        readonly 507: "Insufficient Storage";
+        readonly 508: "Loop Detected";
+        readonly 510: "Not Extended";
+        readonly 511: "Network Authentication Required";
+    }[Code] : Code>(code: Code, response?: T) => import("elysia").ElysiaStatus<Code, T, Code extends "Continue" | "Switching Protocols" | "Processing" | "Early Hints" | "OK" | "Created" | "Accepted" | "Non-Authoritative Information" | "No Content" | "Reset Content" | "Partial Content" | "Multi-Status" | "Already Reported" | "Multiple Choices" | "Moved Permanently" | "Found" | "See Other" | "Not Modified" | "Temporary Redirect" | "Permanent Redirect" | "Bad Request" | "Unauthorized" | "Payment Required" | "Forbidden" | "Not Found" | "Method Not Allowed" | "Not Acceptable" | "Proxy Authentication Required" | "Request Timeout" | "Conflict" | "Gone" | "Length Required" | "Precondition Failed" | "Payload Too Large" | "URI Too Long" | "Unsupported Media Type" | "Range Not Satisfiable" | "Expectation Failed" | "I'm a teapot" | "Enhance Your Calm" | "Misdirected Request" | "Unprocessable Content" | "Locked" | "Failed Dependency" | "Too Early" | "Upgrade Required" | "Precondition Required" | "Too Many Requests" | "Request Header Fields Too Large" | "Unavailable For Legal Reasons" | "Internal Server Error" | "Not Implemented" | "Bad Gateway" | "Service Unavailable" | "Gateway Timeout" | "HTTP Version Not Supported" | "Variant Also Negotiates" | "Insufficient Storage" | "Loop Detected" | "Not Extended" | "Network Authentication Required" ? {
+        readonly Continue: 100;
+        readonly "Switching Protocols": 101;
+        readonly Processing: 102;
+        readonly "Early Hints": 103;
+        readonly OK: 200;
+        readonly Created: 201;
+        readonly Accepted: 202;
+        readonly "Non-Authoritative Information": 203;
+        readonly "No Content": 204;
+        readonly "Reset Content": 205;
+        readonly "Partial Content": 206;
+        readonly "Multi-Status": 207;
+        readonly "Already Reported": 208;
+        readonly "Multiple Choices": 300;
+        readonly "Moved Permanently": 301;
+        readonly Found: 302;
+        readonly "See Other": 303;
+        readonly "Not Modified": 304;
+        readonly "Temporary Redirect": 307;
+        readonly "Permanent Redirect": 308;
+        readonly "Bad Request": 400;
+        readonly Unauthorized: 401;
+        readonly "Payment Required": 402;
+        readonly Forbidden: 403;
+        readonly "Not Found": 404;
+        readonly "Method Not Allowed": 405;
+        readonly "Not Acceptable": 406;
+        readonly "Proxy Authentication Required": 407;
+        readonly "Request Timeout": 408;
+        readonly Conflict: 409;
+        readonly Gone: 410;
+        readonly "Length Required": 411;
+        readonly "Precondition Failed": 412;
+        readonly "Payload Too Large": 413;
+        readonly "URI Too Long": 414;
+        readonly "Unsupported Media Type": 415;
+        readonly "Range Not Satisfiable": 416;
+        readonly "Expectation Failed": 417;
+        readonly "I'm a teapot": 418;
+        readonly "Enhance Your Calm": 420;
+        readonly "Misdirected Request": 421;
+        readonly "Unprocessable Content": 422;
+        readonly Locked: 423;
+        readonly "Failed Dependency": 424;
+        readonly "Too Early": 425;
+        readonly "Upgrade Required": 426;
+        readonly "Precondition Required": 428;
+        readonly "Too Many Requests": 429;
+        readonly "Request Header Fields Too Large": 431;
+        readonly "Unavailable For Legal Reasons": 451;
+        readonly "Internal Server Error": 500;
+        readonly "Not Implemented": 501;
+        readonly "Bad Gateway": 502;
+        readonly "Service Unavailable": 503;
+        readonly "Gateway Timeout": 504;
+        readonly "HTTP Version Not Supported": 505;
+        readonly "Variant Also Negotiates": 506;
+        readonly "Insufficient Storage": 507;
+        readonly "Loop Detected": 508;
+        readonly "Not Extended": 510;
+        readonly "Network Authentication Required": 511;
+    }[Code] : Code>;
+    defer: (fn: import("elysia/types").AfterResponseHandler<NoInfer<import("elysia/types").IntersectIfObjectSchema<import("elysia").UnwrapRoute<{}, {}, `/${string}`>, import("elysia/types").MergeScopedSchemas<{}, {}, {}>>>, NoInfer<import("elysia/types").DefaultSingleton & {
+        derive: {};
+    }>>) => import("elysia/types").MaybePromise<void>;
+    readonly path: string;
+    route?: string | undefined;
+    rid?: string | undefined;
+    request: Request;
+    store: {};
+}) => Promise<Response | VoiceTelephonyCarrierMatrix>>;
 export declare const renderVoiceTelephonyCarrierMatrixHTML: (matrix: VoiceTelephonyCarrierMatrix, options?: {
     title?: string;
 }) => string;

package/dist/telephony/plivo.d.ts

@@ -220,22 +220,14 @@ export declare const createVoicePlivoWebhookVerifier: (options: VoicePlivoWebhoo
     request: Request;
 }) => Promise<VoiceTelephonyWebhookVerificationResult>;
 export declare const createVoiceRedisPlivoWebhookNonceStore: (options?: VoiceRedisPlivoWebhookNonceStoreOptions) => VoicePlivoWebhookNonceStore;
-export declare const createPlivoVoiceRoutes: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options?: PlivoVoiceRoutesOptions<TContext, TSession, TResult>) => Elysia<"", {
+export declare const createPlivoVoiceRoutes: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options?: PlivoVoiceRoutesOptions<TContext, TSession, TResult>) => Elysia<"", "local", {
     decorator: {};
     store: {};
     derive: {};
-    resolve: {};
 }, {
     typebox: {};
-    error: {};
-}, {
-    schema: {};
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: {};
-}, {
+    error: [];
+}, import("elysia/types").DefaultMetadata, {
     [x: string]: {
         get: {
             body: unknown;
@@ -245,6 +237,7 @@ export declare const createPlivoVoiceRoutes: <TContext = unknown, TSession exten
             response: {
                 200: Response;
             };
+            error: never;
         };
     };
 } & {
@@ -257,17 +250,12 @@ export declare const createPlivoVoiceRoutes: <TContext = unknown, TSession exten
             response: {
                 200: Response;
             };
+            error: never;
         };
     };
 } & {
     [x: string]: {
-        subscribe: {
-            body: {};
-            params: {};
-            query: {};
-            headers: {};
-            response: {};
-        };
+        subscribe: import("elysia/types").CreateWSEdenResponse<string, import("elysia/types").IntersectIfObjectSchema<import("elysia").UnwrapRoute<import("elysia").InputSchema<never>, {}, `/${string}`>, import("elysia/types").MergeScopedSchemas<{}, {}, {}>>, {}, import("elysia/types").ComposeElysiaResponse<import("elysia/types").IntersectIfObjectSchema<import("elysia").UnwrapRoute<import("elysia").InputSchema<never>, {}, `/${string}`>, import("elysia/types").MergeScopedSchemas<{}, {}, {}>>, void, {}, [], string>>;
     };
 } & {
     [x: string]: {
@@ -279,24 +267,13 @@ export declare const createPlivoVoiceRoutes: <TContext = unknown, TSession exten
             response: {
                 200: Response | import("..").VoiceTelephonyWebhookDecision<TResult>;
             };
+            error: never;
         };
     };
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-} & {
+}, import("elysia/types").DefaultEphemeral, {
     derive: {};
-    resolve: {};
     schema: {};
-    standaloneSchema: {};
+    schemas: {};
     response: {};
+    error: [];
 }>;

package/dist/telephony/security.d.ts

@@ -1,5 +1,4 @@
 import { type VoiceTelephonyWebhookIdempotencyStore, type VoiceTelephonyWebhookProvider, type VoiceTelephonyWebhookVerificationResult } from "../core/telephonyOutcome";
-import { Elysia } from "elysia";
 import { type VoicePostgresClient } from "../core/postgresStore";
 import { type VoiceRedisTelephonyWebhookIdempotencyClient } from "../core/queue";
 import { type VoicePlivoWebhookNonceStore, type VoiceRedisPlivoWebhookNonceClient } from "./plivo";
@@ -139,44 +138,8 @@ export type VoiceTelephonyWebhookSecurityRoutesOptions<TResult = unknown> = {
 export declare const assertVoiceTelephonyWebhookSecurityEvidence: (report: VoiceTelephonyWebhookSecurityReport, input?: VoiceTelephonyWebhookSecurityAssertionInput) => VoiceTelephonyWebhookSecurityAssertionReport;
 export declare const buildVoiceTelephonyWebhookSecurityReport: <TResult = unknown>(options?: VoiceTelephonyWebhookSecurityOptions<TResult>) => VoiceTelephonyWebhookSecurityReport;
 export declare const createVoiceTelephonyWebhookSecurityPreset: <TResult = unknown>(options?: VoiceTelephonyWebhookSecurityOptions<TResult>) => VoiceTelephonyWebhookSecurityPreset<TResult>;
-export declare const createVoiceTelephonyWebhookSecurityRoutes: <TResult = unknown>(options: VoiceTelephonyWebhookSecurityRoutesOptions<TResult>) => Elysia<"", {
-    decorator: {};
-    store: {};
-    derive: {};
-    resolve: {};
-}, {
+export declare const createVoiceTelephonyWebhookSecurityRoutes: <TResult = unknown>(options: VoiceTelephonyWebhookSecurityRoutesOptions<TResult>) => import("elysia/types").AddRoute<"", "local", import("elysia/types").DefaultSingleton, {
     typebox: {};
-    error: {};
-}, {
-    schema: {};
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: {};
-}, {
-    [x: string]: {
-        get: {
-            body: unknown;
-            params: {};
-            query: unknown;
-            headers: unknown;
-            response: {
-                200: VoiceTelephonyWebhookSecurityReport;
-            };
-        };
-    };
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}>;
+    error: [];
+}, import("elysia/types").DefaultMetadata, {}, import("elysia/types").DefaultEphemeral, import("elysia/types").DefaultEphemeral, "get", string, import("elysia/types").IntersectIfObjectSchema<import("elysia").UnwrapRoute<{}, {}, `/${string}`>, import("elysia/types").MergeScopedSchemas<{}, {}, {}>>, {}, () => VoiceTelephonyWebhookSecurityReport>;
 export declare const evaluateVoiceTelephonyWebhookSecurityEvidence: (report: VoiceTelephonyWebhookSecurityReport, input?: VoiceTelephonyWebhookSecurityAssertionInput) => VoiceTelephonyWebhookSecurityAssertionReport;