@volley/recognition-client-sdk 0.1.200

package/dist/index.js

@@ -0,0 +1,2332 @@
+import { z } from 'zod';
+import 'ws';
+import { v4 } from 'uuid';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// ../../libs/types/dist/provider.types.js
+var RecognitionProvider;
+(function(RecognitionProvider2) {
+  RecognitionProvider2["ASSEMBLYAI"] = "assemblyai";
+  RecognitionProvider2["DEEPGRAM"] = "deepgram";
+  RecognitionProvider2["GOOGLE"] = "google";
+  RecognitionProvider2["GEMINI_BATCH"] = "gemini-batch";
+  RecognitionProvider2["OPENAI_BATCH"] = "openai-batch";
+})(RecognitionProvider || (RecognitionProvider = {}));
+var RecognitionMode;
+(function(RecognitionMode2) {
+  RecognitionMode2["STREAMING"] = "streaming";
+  RecognitionMode2["BATCH"] = "batch";
+})(RecognitionMode || (RecognitionMode = {}));
+var DeepgramModel;
+(function(DeepgramModel2) {
+  DeepgramModel2["NOVA_2"] = "nova-2";
+  DeepgramModel2["NOVA_3"] = "nova-3";
+  DeepgramModel2["FLUX_GENERAL_EN"] = "flux-general-en";
+})(DeepgramModel || (DeepgramModel = {}));
+var GoogleModel;
+(function(GoogleModel2) {
+  GoogleModel2["LATEST_LONG"] = "latest_long";
+  GoogleModel2["LATEST_SHORT"] = "latest_short";
+  GoogleModel2["TELEPHONY"] = "telephony";
+  GoogleModel2["TELEPHONY_SHORT"] = "telephony_short";
+  GoogleModel2["MEDICAL_DICTATION"] = "medical_dictation";
+  GoogleModel2["MEDICAL_CONVERSATION"] = "medical_conversation";
+  GoogleModel2["DEFAULT"] = "default";
+  GoogleModel2["COMMAND_AND_SEARCH"] = "command_and_search";
+  GoogleModel2["PHONE_CALL"] = "phone_call";
+  GoogleModel2["VIDEO"] = "video";
+})(GoogleModel || (GoogleModel = {}));
+var RecognitionResultTypeV1;
+(function(RecognitionResultTypeV12) {
+  RecognitionResultTypeV12["TRANSCRIPTION"] = "Transcription";
+  RecognitionResultTypeV12["FUNCTION_CALL"] = "FunctionCall";
+  RecognitionResultTypeV12["METADATA"] = "Metadata";
+  RecognitionResultTypeV12["ERROR"] = "Error";
+  RecognitionResultTypeV12["CLIENT_CONTROL_MESSAGE"] = "ClientControlMessage";
+})(RecognitionResultTypeV1 || (RecognitionResultTypeV1 = {}));
+var TranscriptionResultSchemaV1 = z.object({
+  type: z.literal(RecognitionResultTypeV1.TRANSCRIPTION),
+  audioUtteranceId: z.string(),
+  finalTranscript: z.string(),
+  finalTranscriptConfidence: z.number().min(0).max(1).optional(),
+  pendingTranscript: z.string().optional(),
+  pendingTranscriptConfidence: z.number().min(0).max(1).optional(),
+  is_finished: z.boolean(),
+  voiceStart: z.number().optional(),
+  voiceDuration: z.number().optional(),
+  voiceEnd: z.number().optional(),
+  startTimestamp: z.number().optional(),
+  endTimestamp: z.number().optional(),
+  receivedAtMs: z.number().optional(),
+  accumulatedAudioTimeMs: z.number().optional()
+});
+var FunctionCallResultSchemaV1 = z.object({
+  type: z.literal(RecognitionResultTypeV1.FUNCTION_CALL),
+  audioUtteranceId: z.string(),
+  functionName: z.string(),
+  functionArgJson: z.string()
+});
+var MetadataResultSchemaV1 = z.object({
+  type: z.literal(RecognitionResultTypeV1.METADATA),
+  audioUtteranceId: z.string(),
+  // Timing information
+  recordingStartMs: z.number().optional(),
+  recordingEndMs: z.number().optional(),
+  transcriptEndMs: z.number().optional(),
+  socketCloseAtMs: z.number().optional(),
+  // Audio Quality Metrics
+  duration: z.number().optional(),
+  volume: z.number().optional(),
+  accumulatedAudioTimeMs: z.number().optional(),
+  // Cost Information
+  costInUSD: z.number().default(0).optional(),
+  // ASR configuration as JSON string (no type validation)
+  asrConfig: z.string().optional(),
+  // Raw ASR metadata payload as provided by the provider (stringified if needed)
+  rawAsrMetadata: z.string().optional()
+});
+var ErrorTypeV1;
+(function(ErrorTypeV12) {
+  ErrorTypeV12["AUTHENTICATION_ERROR"] = "authentication_error";
+  ErrorTypeV12["VALIDATION_ERROR"] = "validation_error";
+  ErrorTypeV12["PROVIDER_ERROR"] = "provider_error";
+  ErrorTypeV12["TIMEOUT_ERROR"] = "timeout_error";
+  ErrorTypeV12["QUOTA_EXCEEDED"] = "quota_exceeded";
+  ErrorTypeV12["UNKNOWN_ERROR"] = "unknown_error";
+})(ErrorTypeV1 || (ErrorTypeV1 = {}));
+var ErrorResultSchemaV1 = z.object({
+  type: z.literal(RecognitionResultTypeV1.ERROR),
+  audioUtteranceId: z.string(),
+  errorType: z.nativeEnum(ErrorTypeV1).optional(),
+  message: z.string().optional(),
+  code: z.union([
+    z.string(),
+    z.number()
+  ]).optional(),
+  description: z.string().optional()
+});
+var ClientControlActionV1;
+(function(ClientControlActionV12) {
+  ClientControlActionV12["READY_FOR_UPLOADING_RECORDING"] = "ready_for_uploading_recording";
+  ClientControlActionV12["STOP_RECORDING"] = "stop_recording";
+})(ClientControlActionV1 || (ClientControlActionV1 = {}));
+var ClientControlActionsV1 = z.nativeEnum(ClientControlActionV1);
+var ClientControlMessageSchemaV1 = z.object({
+  type: z.literal(RecognitionResultTypeV1.CLIENT_CONTROL_MESSAGE),
+  audioUtteranceId: z.string(),
+  action: ClientControlActionsV1
+});
+z.discriminatedUnion("type", [
+  // P0
+  TranscriptionResultSchemaV1,
+  MetadataResultSchemaV1,
+  ErrorResultSchemaV1,
+  // P1 - P2
+  FunctionCallResultSchemaV1,
+  ClientControlMessageSchemaV1
+]);
+
+// ../../libs/types/dist/provider-transcription.types.js
+var ProviderMessageType;
+(function(ProviderMessageType2) {
+  ProviderMessageType2["TRANSCRIPT"] = "Transcript";
+  ProviderMessageType2["VAD_END_SIGNAL"] = "UtteranceEnd";
+  ProviderMessageType2["METADATA"] = "Metadata";
+  ProviderMessageType2["ERROR"] = "Error";
+  ProviderMessageType2["TIMER"] = "Timer";
+  ProviderMessageType2["RAW"] = "Raw";
+})(ProviderMessageType || (ProviderMessageType = {}));
+var RecognitionAlternativeSchema = z.object({
+  /**
+   * The transcribed text
+   * @example "hello world"
+   */
+  transcript: z.string(),
+  /**
+   * Confidence score (0-1)
+   * Note: Google only provides confidence for final results
+   * @example 0.95
+   */
+  confidence: z.number().min(0).max(1)
+});
+z.object({
+  /**
+   * Array of transcription alternatives, ordered by confidence
+   */
+  alternatives: z.array(RecognitionAlternativeSchema)
+});
+z.object({
+  name: z.string(),
+  canonical_name: z.string(),
+  architecture: z.string(),
+  languages: z.array(z.string()).optional(),
+  version: z.string(),
+  uuid: z.string(),
+  batch: z.boolean(),
+  streaming: z.boolean()
+});
+var TranscriptMessageSchema = z.object({
+  type: z.literal(ProviderMessageType.TRANSCRIPT),
+  /**
+   * Provider that generated this message
+   * @example "deepgram"
+   */
+  provider: z.nativeEnum(RecognitionProvider).optional(),
+  /**
+   * The transcribed text (extracted from first alternative)
+   * @example "hello world"
+   */
+  text: z.string(),
+  /**
+   * Confidence score for the transcript (0-1)
+   * @example 0.95
+   */
+  confidence: z.number().min(0).max(1),
+  /**
+   * Voice start time identified by ASR (in milliseconds from stream start)
+   * @example 500 (voice starts at 0.5 seconds)
+   */
+  voiceStart: z.number().optional(),
+  /**
+   * Voice end time identified by ASR (in milliseconds from stream start)
+   * @example 2000 (voice ends at 2.0 seconds)
+   */
+  voiceEnd: z.number().optional(),
+  /**
+   * Voice duration identified by ASR (in milliseconds)
+   * @example 1500 (1.5 seconds of speech, calculated as voiceEnd - voiceStart)
+   */
+  voiceDuration: z.number().optional(),
+  /**
+   * Server timestamp when this transcript was received (in milliseconds)
+   * @example 1704096005500
+   */
+  receivedAtMs: z.number().optional(),
+  /**
+   * Accumulated audio time watermark (in milliseconds)
+   * Total duration of all audio chunks sent to this provider session
+   * @example 2500 (2.5 seconds of audio has been sent)
+   */
+  accumulatedAudioTimeMs: z.number().optional(),
+  /**
+   * Whether this transcript is finalized (won't change)
+   * @example true
+   */
+  is_final: z.boolean()
+});
+var VADEndSignalSchema = z.object({
+  type: z.literal(ProviderMessageType.VAD_END_SIGNAL),
+  /**
+   * Provider that generated this message
+   */
+  provider: z.nativeEnum(RecognitionProvider).optional(),
+  /**
+   * Time when the last word ended (in milliseconds)
+   * @example 2500 (2.5 seconds)
+   */
+  last_word_end: z.number().optional()
+});
+var MetadataMessageSchema = z.object({
+  type: z.literal(ProviderMessageType.METADATA),
+  provider: z.nativeEnum(RecognitionProvider),
+  asrConfig: z.string().optional(),
+  data: z.string().optional()
+});
+var ErrorMessageSchema = z.object({
+  type: z.literal(ProviderMessageType.ERROR),
+  /**
+   * Provider that generated this message
+   */
+  provider: z.nativeEnum(RecognitionProvider).optional(),
+  /**
+   * Categorized error type
+   * Defaults to UNKNOWN_ERROR if not specified by provider
+   * @example ErrorTypeV1.PROVIDER_ERROR
+   */
+  errorType: z.nativeEnum(ErrorTypeV1),
+  /**
+   * Error message
+   * @example "Stream quota exceeded"
+   */
+  provider_error: z.string(),
+  /**
+   * Provider-specific error code
+   * @example "QUOTA_EXCEEDED"
+   */
+  provider_error_code: z.union([
+    z.string(),
+    z.number()
+  ]).optional(),
+  /**
+   * Additional error description
+   */
+  description: z.string().optional(),
+  /**
+   * Whether the error can be immediately recovered by retrying
+   * true = transient error, retry may succeed (e.g., UNAVAILABLE, INTERNAL)
+   * false = permanent error, retry will fail (e.g., INVALID_ARGUMENT, PERMISSION_DENIED)
+   * @example true
+   */
+  is_immediately_recoverable: z.boolean().optional()
+});
+var TimerSchema = z.object({
+  type: z.literal(ProviderMessageType.TIMER),
+  /**
+   * Provider that generated this message
+   */
+  provider: z.nativeEnum(RecognitionProvider).optional(),
+  /**
+   * Timestamp when recording started (in milliseconds)
+   * @example 1704096000000
+   */
+  recordingStartMs: z.number().optional(),
+  /**
+   * Timestamp when recording ended (in milliseconds)
+   * @example 1704096005000
+   */
+  recordingEndMs: z.number().optional(),
+  /**
+   * Timestamp when final transcript was received (in milliseconds)
+   * @example 1704096005500
+   */
+  transcriptEndMs: z.number().optional(),
+  /**
+   * Timestamp when socket/grpc connection was closed (in milliseconds)
+   * @example 1704096006000
+   */
+  socketCloseAtMs: z.number().optional(),
+  /**
+   * Accumulated audio time watermark (in milliseconds)
+   * Total duration of all audio chunks sent to this provider session
+   * @example 2500 (2.5 seconds of audio has been sent)
+   */
+  accumulatedAudioTimeMs: z.number().optional(),
+  /**
+   * Estimated cost in USD for this session
+   * Calculated by the job based on audio duration and provider pricing
+   * @example 0.0025 (quarter of a cent)
+   */
+  costInUSD: z.number().optional().default(0)
+});
+var RawMessageSchema = z.object({
+  type: z.literal(ProviderMessageType.RAW),
+  provider: z.string(),
+  data: z.any()
+});
+z.discriminatedUnion("type", [
+  TranscriptMessageSchema,
+  VADEndSignalSchema,
+  MetadataMessageSchema,
+  ErrorMessageSchema,
+  TimerSchema,
+  RawMessageSchema
+]);
+var BaseRecognitionExceptionSchema = z.object({
+  /** Error type category */
+  errorType: z.nativeEnum(ErrorTypeV1),
+  /** Error message for logging/debugging */
+  message: z.string(),
+  /** Optional error code from provider or system */
+  code: z.union([
+    z.string(),
+    z.number()
+  ]).optional(),
+  /** Detailed description for debugging */
+  description: z.string().optional(),
+  /**
+   * Whether this error can be immediately shown to user.
+   * true = Show to user immediately (clear actionable error)
+   * false = Log for investigation, show generic error to user
+   */
+  isImmediatelyAvailable: z.boolean(),
+  /** Recognition provider that generated this error */
+  provider: z.nativeEnum(RecognitionProvider).optional(),
+  /** Audio utterance ID this error relates to */
+  audioUtteranceId: z.string().optional(),
+  /** Timestamp when error occurred */
+  timestamp: z.number().optional()
+});
+var AuthenticationExceptionSchema = BaseRecognitionExceptionSchema.extend({
+  errorType: z.literal(ErrorTypeV1.AUTHENTICATION_ERROR),
+  isImmediatelyAvailable: z.literal(false),
+  /** Which service failed authentication (e.g., 'deepgram', 'google') */
+  service: z.string().optional(),
+  /** Authentication method that failed (e.g., 'api_key', 'oauth') */
+  authMethod: z.string().optional()
+});
+var ValidationExceptionSchema = BaseRecognitionExceptionSchema.extend({
+  errorType: z.literal(ErrorTypeV1.VALIDATION_ERROR),
+  isImmediatelyAvailable: z.literal(true),
+  /** Field name that failed validation */
+  field: z.string().optional(),
+  /** Expected value format/type */
+  expected: z.string().optional(),
+  /** Actual value received (sanitized) */
+  received: z.string().optional()
+});
+var ProviderExceptionSchema = BaseRecognitionExceptionSchema.extend({
+  errorType: z.literal(ErrorTypeV1.PROVIDER_ERROR),
+  isImmediatelyAvailable: z.literal(false),
+  /** Provider name (e.g., 'deepgram', 'assemblyai', 'google') */
+  provider: z.string().optional(),
+  /** Provider-specific error code */
+  providerErrorCode: z.union([
+    z.string(),
+    z.number()
+  ]).optional(),
+  /** Whether this provider error might be transient (should retry) */
+  isTransient: z.boolean().optional()
+});
+var TimeoutExceptionSchema = BaseRecognitionExceptionSchema.extend({
+  errorType: z.literal(ErrorTypeV1.TIMEOUT_ERROR),
+  isImmediatelyAvailable: z.literal(true),
+  /** Timeout duration in milliseconds */
+  timeoutMs: z.number().optional(),
+  /** What operation timed out (e.g., 'connection', 'transcription', 'response') */
+  operation: z.string().optional()
+});
+var QuotaExceededExceptionSchema = BaseRecognitionExceptionSchema.extend({
+  errorType: z.literal(ErrorTypeV1.QUOTA_EXCEEDED),
+  isImmediatelyAvailable: z.literal(true),
+  /** Quota type that was exceeded (e.g., 'rate_limit', 'daily_quota', 'concurrent_requests') */
+  quotaType: z.string().optional(),
+  /** When quota resets (Unix timestamp in ms) */
+  resetAt: z.number().optional(),
+  /** How long to wait in seconds before retry */
+  retryAfterSeconds: z.number().optional()
+});
+var UnknownExceptionSchema = BaseRecognitionExceptionSchema.extend({
+  errorType: z.literal(ErrorTypeV1.UNKNOWN_ERROR),
+  isImmediatelyAvailable: z.literal(false),
+  /** Stack trace for debugging (sanitized) */
+  stack: z.string().optional(),
+  /** Additional context for debugging */
+  context: z.record(z.unknown()).optional()
+});
+z.discriminatedUnion("errorType", [
+  AuthenticationExceptionSchema,
+  ValidationExceptionSchema,
+  ProviderExceptionSchema,
+  TimeoutExceptionSchema,
+  QuotaExceededExceptionSchema,
+  UnknownExceptionSchema
+]);
+var RecognitionContextTypeV1;
+(function(RecognitionContextTypeV12) {
+  RecognitionContextTypeV12["GAME_CONTEXT"] = "GameContext";
+  RecognitionContextTypeV12["CONTROL_SIGNAL"] = "ControlSignal";
+  RecognitionContextTypeV12["ASR_REQUEST"] = "ASRRequest";
+})(RecognitionContextTypeV1 || (RecognitionContextTypeV1 = {}));
+var ControlSignalTypeV1;
+(function(ControlSignalTypeV12) {
+  ControlSignalTypeV12["START_RECORDING"] = "start_recording";
+  ControlSignalTypeV12["STOP_RECORDING"] = "stop_recording";
+})(ControlSignalTypeV1 || (ControlSignalTypeV1 = {}));
+var SlotMapSchema = z.record(z.string(), z.array(z.string()));
+var GameContextSchemaV1 = z.object({
+  type: z.literal(RecognitionContextTypeV1.GAME_CONTEXT),
+  gameId: z.string(),
+  gamePhase: z.string(),
+  // Prompt fields for different processing stages
+  promptSTT: z.string().optional(),
+  promptSTF: z.string().optional(),
+  promptTTF: z.string().optional(),
+  // Slot map for entity extraction
+  slotMap: SlotMapSchema.optional()
+});
+var ControlSignalSchemaV1 = z.object({
+  type: z.literal(RecognitionContextTypeV1.CONTROL_SIGNAL),
+  signal: z.nativeEnum(ControlSignalTypeV1)
+});
+var RequestDebugCommandSchema = z.object({
+  // Enable verbose debug logging for this request
+  enableDebugLog: z.boolean().optional().default(false),
+  // Enable audio storage to database/filesystem for debugging
+  enableAudioStorage: z.boolean().optional().default(true),
+  // Enable validation that song quiz session ID exists before processing
+  enableSongQuizSessionIdCheck: z.boolean().optional().default(true),
+  // Enable experimental pilot models for testing new features
+  enablePilotModels: z.boolean().optional().default(false)
+}).optional();
+var ASRRequestSchemaV1 = z.object({
+  type: z.literal(RecognitionContextTypeV1.ASR_REQUEST),
+  // Session identification
+  audioUtteranceId: z.string().optional(),
+  // ASR configuration
+  provider: z.string(),
+  model: z.string().optional(),
+  language: z.string(),
+  sampleRate: z.number(),
+  encoding: z.number(),
+  // Recognition options
+  interimResults: z.boolean().optional().default(false),
+  useContext: z.boolean().optional().default(false),
+  // Debug options (FOR DEBUG/TESTING ONLY - not for production use)
+  debugCommand: RequestDebugCommandSchema
+});
+z.discriminatedUnion("type", [
+  GameContextSchemaV1,
+  ControlSignalSchemaV1,
+  ASRRequestSchemaV1
+]);
+var RecognitionGameInfoSchema = z.object({
+  userId: z.string().optional(),
+  gameSessionId: z.string().optional(),
+  deviceId: z.string().optional(),
+  accountId: z.string().optional(),
+  gameId: z.string().optional(),
+  gamePhase: z.string().optional(),
+  questionAnswerId: z.string().optional(),
+  platform: z.string().optional()
+});
+z.object({
+  audioUtteranceId: z.string(),
+  recognitionGameInfo: RecognitionGameInfoSchema.optional()
+});
+z.object({
+  audioUtteranceId: z.string(),
+  results: z.array(z.any())
+});
+
+// ../../libs/types/dist/audio.types.js
+var AudioFormat;
+(function(AudioFormat2) {
+  AudioFormat2[AudioFormat2["WAV"] = 1] = "WAV";
+  AudioFormat2[AudioFormat2["MP3"] = 2] = "MP3";
+  AudioFormat2[AudioFormat2["FLAC"] = 3] = "FLAC";
+  AudioFormat2[AudioFormat2["M4A"] = 4] = "M4A";
+  AudioFormat2[AudioFormat2["OPUS"] = 5] = "OPUS";
+  AudioFormat2[AudioFormat2["PCM"] = 6] = "PCM";
+})(AudioFormat || (AudioFormat = {}));
+(function(AudioFormat2) {
+  const ID_TO_ENUM = /* @__PURE__ */ new Map([
+    [
+      1,
+      AudioFormat2.WAV
+    ],
+    [
+      2,
+      AudioFormat2.MP3
+    ],
+    [
+      3,
+      AudioFormat2.FLAC
+    ],
+    [
+      4,
+      AudioFormat2.M4A
+    ],
+    [
+      5,
+      AudioFormat2.OPUS
+    ],
+    [
+      6,
+      AudioFormat2.PCM
+    ]
+  ]);
+  const NAME_TO_ENUM = /* @__PURE__ */ new Map([
+    [
+      "WAV",
+      AudioFormat2.WAV
+    ],
+    [
+      "MP3",
+      AudioFormat2.MP3
+    ],
+    [
+      "FLAC",
+      AudioFormat2.FLAC
+    ],
+    [
+      "M4A",
+      AudioFormat2.M4A
+    ],
+    [
+      "OPUS",
+      AudioFormat2.OPUS
+    ],
+    [
+      "PCM",
+      AudioFormat2.PCM
+    ]
+  ]);
+  const ENUM_TO_NAME = /* @__PURE__ */ new Map([
+    [
+      AudioFormat2.WAV,
+      "WAV"
+    ],
+    [
+      AudioFormat2.MP3,
+      "MP3"
+    ],
+    [
+      AudioFormat2.FLAC,
+      "FLAC"
+    ],
+    [
+      AudioFormat2.M4A,
+      "M4A"
+    ],
+    [
+      AudioFormat2.OPUS,
+      "OPUS"
+    ],
+    [
+      AudioFormat2.PCM,
+      "PCM"
+    ]
+  ]);
+  function fromId(id) {
+    return ID_TO_ENUM.get(id);
+  }
+  __name(fromId, "fromId");
+  AudioFormat2.fromId = fromId;
+  function fromName(nameStr) {
+    return NAME_TO_ENUM.get(nameStr.toUpperCase());
+  }
+  __name(fromName, "fromName");
+  AudioFormat2.fromName = fromName;
+  function toId(format) {
+    return format;
+  }
+  __name(toId, "toId");
+  AudioFormat2.toId = toId;
+  function toName(format) {
+    return ENUM_TO_NAME.get(format) ?? AudioFormat2[format];
+  }
+  __name(toName, "toName");
+  AudioFormat2.toName = toName;
+  function isIdValid(id) {
+    return ID_TO_ENUM.has(id);
+  }
+  __name(isIdValid, "isIdValid");
+  AudioFormat2.isIdValid = isIdValid;
+  function isNameValid(nameStr) {
+    return NAME_TO_ENUM.has(nameStr.toUpperCase());
+  }
+  __name(isNameValid, "isNameValid");
+  AudioFormat2.isNameValid = isNameValid;
+})(AudioFormat || (AudioFormat = {}));
+var AudioEncoding;
+(function(AudioEncoding2) {
+  AudioEncoding2[AudioEncoding2["ENCODING_UNSPECIFIED"] = 0] = "ENCODING_UNSPECIFIED";
+  AudioEncoding2[AudioEncoding2["LINEAR16"] = 1] = "LINEAR16";
+  AudioEncoding2[AudioEncoding2["OGG_OPUS"] = 2] = "OGG_OPUS";
+  AudioEncoding2[AudioEncoding2["FLAC"] = 3] = "FLAC";
+  AudioEncoding2[AudioEncoding2["MULAW"] = 4] = "MULAW";
+  AudioEncoding2[AudioEncoding2["ALAW"] = 5] = "ALAW";
+})(AudioEncoding || (AudioEncoding = {}));
+(function(AudioEncoding2) {
+  const ID_TO_ENUM = /* @__PURE__ */ new Map([
+    [
+      0,
+      AudioEncoding2.ENCODING_UNSPECIFIED
+    ],
+    [
+      1,
+      AudioEncoding2.LINEAR16
+    ],
+    [
+      2,
+      AudioEncoding2.OGG_OPUS
+    ],
+    [
+      3,
+      AudioEncoding2.FLAC
+    ],
+    [
+      4,
+      AudioEncoding2.MULAW
+    ],
+    [
+      5,
+      AudioEncoding2.ALAW
+    ]
+  ]);
+  const NAME_TO_ENUM = /* @__PURE__ */ new Map([
+    [
+      "ENCODING_UNSPECIFIED",
+      AudioEncoding2.ENCODING_UNSPECIFIED
+    ],
+    [
+      "LINEAR16",
+      AudioEncoding2.LINEAR16
+    ],
+    [
+      "OGG_OPUS",
+      AudioEncoding2.OGG_OPUS
+    ],
+    [
+      "FLAC",
+      AudioEncoding2.FLAC
+    ],
+    [
+      "MULAW",
+      AudioEncoding2.MULAW
+    ],
+    [
+      "ALAW",
+      AudioEncoding2.ALAW
+    ]
+  ]);
+  const ENUM_TO_NAME = /* @__PURE__ */ new Map([
+    [
+      AudioEncoding2.ENCODING_UNSPECIFIED,
+      "ENCODING_UNSPECIFIED"
+    ],
+    [
+      AudioEncoding2.LINEAR16,
+      "LINEAR16"
+    ],
+    [
+      AudioEncoding2.OGG_OPUS,
+      "OGG_OPUS"
+    ],
+    [
+      AudioEncoding2.FLAC,
+      "FLAC"
+    ],
+    [
+      AudioEncoding2.MULAW,
+      "MULAW"
+    ],
+    [
+      AudioEncoding2.ALAW,
+      "ALAW"
+    ]
+  ]);
+  function fromId(id) {
+    return ID_TO_ENUM.get(id);
+  }
+  __name(fromId, "fromId");
+  AudioEncoding2.fromId = fromId;
+  function fromName(nameStr) {
+    return NAME_TO_ENUM.get(nameStr.toUpperCase());
+  }
+  __name(fromName, "fromName");
+  AudioEncoding2.fromName = fromName;
+  function toId(encoding) {
+    return encoding;
+  }
+  __name(toId, "toId");
+  AudioEncoding2.toId = toId;
+  function toName(encoding) {
+    return ENUM_TO_NAME.get(encoding) ?? AudioEncoding2[encoding];
+  }
+  __name(toName, "toName");
+  AudioEncoding2.toName = toName;
+  function isIdValid(id) {
+    return ID_TO_ENUM.has(id);
+  }
+  __name(isIdValid, "isIdValid");
+  AudioEncoding2.isIdValid = isIdValid;
+  function isNameValid(nameStr) {
+    return NAME_TO_ENUM.has(nameStr.toUpperCase());
+  }
+  __name(isNameValid, "isNameValid");
+  AudioEncoding2.isNameValid = isNameValid;
+})(AudioEncoding || (AudioEncoding = {}));
+var SampleRate;
+(function(SampleRate2) {
+  SampleRate2[SampleRate2["RATE_8000"] = 8e3] = "RATE_8000";
+  SampleRate2[SampleRate2["RATE_16000"] = 16e3] = "RATE_16000";
+  SampleRate2[SampleRate2["RATE_22050"] = 22050] = "RATE_22050";
+  SampleRate2[SampleRate2["RATE_24000"] = 24e3] = "RATE_24000";
+  SampleRate2[SampleRate2["RATE_32000"] = 32e3] = "RATE_32000";
+  SampleRate2[SampleRate2["RATE_44100"] = 44100] = "RATE_44100";
+  SampleRate2[SampleRate2["RATE_48000"] = 48e3] = "RATE_48000";
+})(SampleRate || (SampleRate = {}));
+(function(SampleRate2) {
+  const HZ_TO_ENUM = /* @__PURE__ */ new Map([
+    [
+      8e3,
+      SampleRate2.RATE_8000
+    ],
+    [
+      16e3,
+      SampleRate2.RATE_16000
+    ],
+    [
+      22050,
+      SampleRate2.RATE_22050
+    ],
+    [
+      24e3,
+      SampleRate2.RATE_24000
+    ],
+    [
+      32e3,
+      SampleRate2.RATE_32000
+    ],
+    [
+      44100,
+      SampleRate2.RATE_44100
+    ],
+    [
+      48e3,
+      SampleRate2.RATE_48000
+    ]
+  ]);
+  const NAME_TO_ENUM = /* @__PURE__ */ new Map([
+    [
+      "RATE_8000",
+      SampleRate2.RATE_8000
+    ],
+    [
+      "RATE_16000",
+      SampleRate2.RATE_16000
+    ],
+    [
+      "RATE_22050",
+      SampleRate2.RATE_22050
+    ],
+    [
+      "RATE_24000",
+      SampleRate2.RATE_24000
+    ],
+    [
+      "RATE_32000",
+      SampleRate2.RATE_32000
+    ],
+    [
+      "RATE_44100",
+      SampleRate2.RATE_44100
+    ],
+    [
+      "RATE_48000",
+      SampleRate2.RATE_48000
+    ]
+  ]);
+  const ENUM_TO_NAME = /* @__PURE__ */ new Map([
+    [
+      SampleRate2.RATE_8000,
+      "RATE_8000"
+    ],
+    [
+      SampleRate2.RATE_16000,
+      "RATE_16000"
+    ],
+    [
+      SampleRate2.RATE_22050,
+      "RATE_22050"
+    ],
+    [
+      SampleRate2.RATE_24000,
+      "RATE_24000"
+    ],
+    [
+      SampleRate2.RATE_32000,
+      "RATE_32000"
+    ],
+    [
+      SampleRate2.RATE_44100,
+      "RATE_44100"
+    ],
+    [
+      SampleRate2.RATE_48000,
+      "RATE_48000"
+    ]
+  ]);
+  function fromHz(hz) {
+    return HZ_TO_ENUM.get(hz);
+  }
+  __name(fromHz, "fromHz");
+  SampleRate2.fromHz = fromHz;
+  function fromName(nameStr) {
+    return NAME_TO_ENUM.get(nameStr.toUpperCase());
+  }
+  __name(fromName, "fromName");
+  SampleRate2.fromName = fromName;
+  function toHz(rate) {
+    return rate;
+  }
+  __name(toHz, "toHz");
+  SampleRate2.toHz = toHz;
+  function toName(rate) {
+    return ENUM_TO_NAME.get(rate) ?? SampleRate2[rate];
+  }
+  __name(toName, "toName");
+  SampleRate2.toName = toName;
+  function isHzValid(hz) {
+    return HZ_TO_ENUM.has(hz);
+  }
+  __name(isHzValid, "isHzValid");
+  SampleRate2.isHzValid = isHzValid;
+  function isNameValid(nameStr) {
+    return NAME_TO_ENUM.has(nameStr.toUpperCase());
+  }
+  __name(isNameValid, "isNameValid");
+  SampleRate2.isNameValid = isNameValid;
+})(SampleRate || (SampleRate = {}));
+var Language;
+(function(Language2) {
+  Language2["ENGLISH_US"] = "en-US";
+  Language2["ENGLISH_GB"] = "en-GB";
+  Language2["SPANISH_ES"] = "es-ES";
+  Language2["SPANISH_MX"] = "es-MX";
+  Language2["FRENCH_FR"] = "fr-FR";
+  Language2["GERMAN_DE"] = "de-DE";
+  Language2["ITALIAN_IT"] = "it-IT";
+  Language2["PORTUGUESE_BR"] = "pt-BR";
+  Language2["JAPANESE_JP"] = "ja-JP";
+  Language2["KOREAN_KR"] = "ko-KR";
+  Language2["CHINESE_CN"] = "zh-CN";
+  Language2["CHINESE_TW"] = "zh-TW";
+})(Language || (Language = {}));
+
+// ../../libs/types/dist/plumbing-types.js
+var PlumbingType;
+(function(PlumbingType2) {
+  PlumbingType2["AUDIO"] = "audio";
+  PlumbingType2["CONTROL"] = "control";
+  PlumbingType2["RESULT"] = "result";
+  PlumbingType2["RECOGNITION_CONTEXT"] = "recognition_context";
+  PlumbingType2["PROVIDER_TRANSCRIPT_RESULT"] = "provider_transcript_result";
+  PlumbingType2["PROVIDER_METADATA_RESULT"] = "provider_metadata_result";
+  PlumbingType2["PROVIDER_ERROR_RESULT"] = "provider_error_result";
+  PlumbingType2["PROVIDER_VAD_SIGNAL"] = "provider_vad_signal";
+  PlumbingType2["PROVIDER_TIMER_SIGNAL"] = "provider_timer_signal";
+  PlumbingType2["PROVIDER_RAW_MESSAGE"] = "provider_raw_message";
+})(PlumbingType || (PlumbingType = {}));
+
+// ../../libs/types/dist/game-id.types.js
+var GameId;
+(function(GameId2) {
+  GameId2["UNKNOWN"] = "unknown";
+  GameId2["HUB"] = "hub";
+  GameId2["JEOPARDY"] = "jeopardy";
+  GameId2["WHEEL_OF_FORTUNE"] = "wheel-of-fortune";
+  GameId2["SONG_QUIZ"] = "song-quiz";
+  GameId2["KARAOKE"] = "karaoke";
+  GameId2["TWENTY_QUESTIONS"] = "twenty-questions";
+  GameId2["GUESS_THE_EMOJI"] = "emoji";
+})(GameId || (GameId = {}));
+({
+  "unknown": GameId.UNKNOWN,
+  "hub": GameId.HUB,
+  "jeopardy": GameId.JEOPARDY,
+  "wheel-of-fortune": GameId.WHEEL_OF_FORTUNE,
+  "song-quiz": GameId.SONG_QUIZ,
+  "karaoke": GameId.KARAOKE,
+  "twenty-questions": GameId.TWENTY_QUESTIONS,
+  "emoji": GameId.GUESS_THE_EMOJI
+});
+
+// ../../libs/types/dist/gemini-types.js
+var GeminiModel;
+(function(GeminiModel2) {
+  GeminiModel2["GEMINI_2_5_PRO"] = "gemini-2.5-pro";
+  GeminiModel2["GEMINI_2_5_FLASH"] = "gemini-2.5-flash";
+  GeminiModel2["GEMINI_2_5_FLASH_LITE"] = "gemini-2.5-flash-lite";
+  GeminiModel2["GEMINI_2_0_FLASH_LATEST"] = "gemini-2.0-flash-latest";
+  GeminiModel2["GEMINI_2_0_FLASH"] = "gemini-2.0-flash-002";
+  GeminiModel2["GEMINI_2_0_FLASH_EXP"] = "gemini-2.0-flash-exp";
+  GeminiModel2["GEMINI_1_5_FLASH"] = "gemini-1.5-flash";
+  GeminiModel2["GEMINI_1_5_PRO"] = "gemini-1.5-pro";
+})(GeminiModel || (GeminiModel = {}));
+var GeminiApiVersion;
+(function(GeminiApiVersion2) {
+  GeminiApiVersion2["V1"] = "v1";
+  GeminiApiVersion2["V1BETA"] = "v1beta";
+})(GeminiApiVersion || (GeminiApiVersion = {}));
+
+// ../../libs/types/dist/openai-types.js
+var OpenAIModel;
+(function(OpenAIModel2) {
+  OpenAIModel2["WHISPER_1"] = "whisper-1";
+})(OpenAIModel || (OpenAIModel = {}));
+
+// ../../libs/types/dist/conductor.types.js
+var StatsIncrementType;
+(function(StatsIncrementType2) {
+  StatsIncrementType2["CALL"] = "call";
+  StatsIncrementType2["SUCCESS"] = "success";
+  StatsIncrementType2["FAIL"] = "fail";
+})(StatsIncrementType || (StatsIncrementType = {}));
+
+// ../../libs/types/dist/stages.types.js
+var STAGES = {
+  LOCAL: "local",
+  DEV: "dev",
+  STAGING: "staging",
+  PRODUCTION: "production"
+};
+
+// ../../libs/websocket/dist/core/audio-upload-websocket-protocol.js
+var WebSocketCloseCode;
+(function(WebSocketCloseCode2) {
+  WebSocketCloseCode2[WebSocketCloseCode2["NORMAL_CLOSURE"] = 1e3] = "NORMAL_CLOSURE";
+  WebSocketCloseCode2[WebSocketCloseCode2["GOING_AWAY"] = 1001] = "GOING_AWAY";
+  WebSocketCloseCode2[WebSocketCloseCode2["PROTOCOL_ERROR"] = 1002] = "PROTOCOL_ERROR";
+  WebSocketCloseCode2[WebSocketCloseCode2["UNSUPPORTED_DATA"] = 1003] = "UNSUPPORTED_DATA";
+  WebSocketCloseCode2[WebSocketCloseCode2["RESERVED_1004"] = 1004] = "RESERVED_1004";
+  WebSocketCloseCode2[WebSocketCloseCode2["NO_STATUS_RECEIVED"] = 1005] = "NO_STATUS_RECEIVED";
+  WebSocketCloseCode2[WebSocketCloseCode2["ABNORMAL_CLOSURE"] = 1006] = "ABNORMAL_CLOSURE";
+  WebSocketCloseCode2[WebSocketCloseCode2["INVALID_FRAME_PAYLOAD"] = 1007] = "INVALID_FRAME_PAYLOAD";
+  WebSocketCloseCode2[WebSocketCloseCode2["POLICY_VIOLATION"] = 1008] = "POLICY_VIOLATION";
+  WebSocketCloseCode2[WebSocketCloseCode2["MESSAGE_TOO_BIG"] = 1009] = "MESSAGE_TOO_BIG";
+  WebSocketCloseCode2[WebSocketCloseCode2["MANDATORY_EXTENSION"] = 1010] = "MANDATORY_EXTENSION";
+  WebSocketCloseCode2[WebSocketCloseCode2["INTERNAL_SERVER_ERROR"] = 1011] = "INTERNAL_SERVER_ERROR";
+  WebSocketCloseCode2[WebSocketCloseCode2["SERVICE_RESTART"] = 1012] = "SERVICE_RESTART";
+  WebSocketCloseCode2[WebSocketCloseCode2["TRY_AGAIN_LATER"] = 1013] = "TRY_AGAIN_LATER";
+  WebSocketCloseCode2[WebSocketCloseCode2["BAD_GATEWAY"] = 1014] = "BAD_GATEWAY";
+  WebSocketCloseCode2[WebSocketCloseCode2["TLS_HANDSHAKE"] = 1015] = "TLS_HANDSHAKE";
+  WebSocketCloseCode2[WebSocketCloseCode2["AUTH_REQUIRED"] = 4e3] = "AUTH_REQUIRED";
+  WebSocketCloseCode2[WebSocketCloseCode2["AUTH_FAILED"] = 4001] = "AUTH_FAILED";
+  WebSocketCloseCode2[WebSocketCloseCode2["RATE_LIMIT_EXCEEDED"] = 4002] = "RATE_LIMIT_EXCEEDED";
+  WebSocketCloseCode2[WebSocketCloseCode2["INVALID_SESSION"] = 4003] = "INVALID_SESSION";
+  WebSocketCloseCode2[WebSocketCloseCode2["SESSION_EXPIRED"] = 4004] = "SESSION_EXPIRED";
+})(WebSocketCloseCode || (WebSocketCloseCode = {}));
+function packHeader(h, payload, versionSerializer) {
+  if (h.e < 0 || h.e > 255 || !Number.isInteger(h.e)) {
+    throw new Error(`Encoding ID must be an integer between 0-255, got: ${h.e}`);
+  }
+  if (h.sr < 0 || h.sr > 65535 || !Number.isInteger(h.sr)) {
+    throw new Error(`Sample rate must be an integer between 0-65535, got: ${h.sr}`);
+  }
+  if (h.seq < 0 || h.seq > 4294967295 || !Number.isInteger(h.seq)) {
+    throw new Error(`Sequence number must be an integer between 0-4294967295, got: ${h.seq}`);
+  }
+  const out = new ArrayBuffer(8 + payload.byteLength);
+  const dv = new DataView(out);
+  dv.setUint8(0, versionSerializer(h.v));
+  dv.setUint8(1, h.e);
+  dv.setUint16(2, h.sr, true);
+  dv.setUint32(4, h.seq, true);
+  new Uint8Array(out, 8).set(new Uint8Array(payload));
+  return out;
+}
+__name(packHeader, "packHeader");
+var numericVersionSerializer = {
+  serialize: /* @__PURE__ */ __name((v) => v, "serialize"),
+  deserialize: /* @__PURE__ */ __name((byte) => byte, "deserialize")
+};
+
+// ../../libs/websocket/dist/core/audio-upload-websocket-client.js
+var WebSocketAudioClient = class {
+  static {
+    __name(this, "WebSocketAudioClient");
+  }
+  constructor(cfg, versionSerializer = numericVersionSerializer) {
+    this.cfg = cfg;
+    this.versionSerializer = versionSerializer;
+    this.seq = 0;
+    this.HWM = cfg.highWM ?? 512e3;
+    this.LWM = cfg.lowWM ?? 128e3;
+  }
+  // ========================================================================
+  // OPTIONAL HOOKS - Override if needed
+  // ========================================================================
+  /**
+   * Hook: Called when downward message arrives from server
+   * Override this to handle messages (optional - default does nothing)
+   */
+  onMessage(msg) {
+  }
+  // ========================================================================
+  // PUBLIC API
+  // ========================================================================
+  connect() {
+    this.ws = new WebSocket(this.cfg.url);
+    this.ws.binaryType = "arraybuffer";
+    this.ws.onopen = () => {
+      this.onConnected();
+    };
+    this.ws.onclose = (event) => {
+      this.onDisconnected(event.code, event.reason);
+    };
+    this.ws.onerror = (error) => {
+      this.onError(error);
+    };
+    this.ws.onmessage = (ev) => {
+      if (typeof ev.data === "string") {
+        const msg = JSON.parse(ev.data);
+        this.onMessage(msg);
+      }
+    };
+  }
+  /**
+   * Send JSON message to server
+   * @param version - Message version
+   * @param type - Message type (developer defined)
+   * @param data - Message payload (typed)
+   */
+  sendMessage(version, type, data) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify({
+        v: version,
+        type,
+        data
+      }));
+    }
+  }
+  /**
+   * Send audio frame with specified encoding and sample rate
+   * @param audioData - Audio data (any format: Int16Array, Uint8Array, ArrayBuffer, etc.)
+   * @param version - Audio frame version
+   * @param encodingId - Audio encoding ID (0-5, e.g., AudioEncoding.LINEAR16)
+   * @param sampleRate - Sample rate in Hz (e.g., 16000)
+   */
+  sendAudio(audioData, version, encodingId, sampleRate) {
+    if (!this.canSend()) return;
+    const buffer = ArrayBuffer.isView(audioData) ? audioData.buffer.slice(audioData.byteOffset, audioData.byteOffset + audioData.byteLength) : audioData;
+    const hdr = {
+      v: version,
+      e: encodingId,
+      sr: sampleRate,
+      seq: this.seq++
+    };
+    this.ws.send(packHeader(hdr, buffer, this.versionSerializer.serialize));
+  }
+  /**
+   * Get current WebSocket buffer size
+   */
+  getBufferedAmount() {
+    return this.ws?.bufferedAmount ?? 0;
+  }
+  /**
+   * Check if local buffer is backpressured
+   */
+  isLocalBackpressured() {
+    return this.getBufferedAmount() > this.HWM;
+  }
+  /**
+   * Check if ready to send audio
+   * Verifies: connection open, no local buffer pressure
+   */
+  canSend() {
+    return this.ws?.readyState === WebSocket.OPEN && !this.isLocalBackpressured();
+  }
+  /**
+   * Check if connection is open
+   */
+  isOpen() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Get current connection state
+   */
+  getReadyState() {
+    return this.ws?.readyState ?? WebSocket.CLOSED;
+  }
+};
+
+// src/recognition-client.types.ts
+var ClientState = /* @__PURE__ */ (function(ClientState2) {
+  ClientState2["INITIAL"] = "initial";
+  ClientState2["CONNECTING"] = "connecting";
+  ClientState2["CONNECTED"] = "connected";
+  ClientState2["READY"] = "ready";
+  ClientState2["STOPPING"] = "stopping";
+  ClientState2["STOPPED"] = "stopped";
+  ClientState2["FAILED"] = "failed";
+  return ClientState2;
+})({});
+
+// ../../libs/config/dist/service-endpoints.js
+var KNOWN_STAGE_VALUES = Object.values(STAGES);
+var RECOGNITION_SERVICE_HOST_BY_STAGE = {
+  [STAGES.LOCAL]: "localhost:3101",
+  [STAGES.DEV]: "recognition-service-dev.volley-services.net",
+  [STAGES.STAGING]: "recognition-service-staging.volley-services.net",
+  [STAGES.PRODUCTION]: "recognition-service.volley-services.net"
+};
+var RECOGNITION_CONDUCTOR_HOST_BY_STAGE = {
+  [STAGES.LOCAL]: "localhost:3100",
+  [STAGES.DEV]: "recognition-conductor-dev.volley-services.net",
+  [STAGES.STAGING]: "recognition-conductor-staging.volley-services.net",
+  [STAGES.PRODUCTION]: "recognition-conductor.volley-services.net"
+};
+var getProtocolsForStage = /* @__PURE__ */ __name((stage) => {
+  if (stage === STAGES.LOCAL) {
+    return {
+      http: "http",
+      ws: "ws"
+    };
+  }
+  return {
+    http: "https",
+    ws: "wss"
+  };
+}, "getProtocolsForStage");
+var buildBaseUrls = /* @__PURE__ */ __name((stage, host) => {
+  const { http, ws } = getProtocolsForStage(stage);
+  return {
+    httpBase: `${http}://${host}`,
+    wsBase: `${ws}://${host}`
+  };
+}, "buildBaseUrls");
+var RECOGNITION_SERVICE_BASES = KNOWN_STAGE_VALUES.reduce((acc, stage) => {
+  acc[stage] = buildBaseUrls(stage, RECOGNITION_SERVICE_HOST_BY_STAGE[stage]);
+  return acc;
+}, {});
+var RECOGNITION_CONDUCTOR_BASES = KNOWN_STAGE_VALUES.reduce((acc, stage) => {
+  acc[stage] = buildBaseUrls(stage, RECOGNITION_CONDUCTOR_HOST_BY_STAGE[stage]);
+  return acc;
+}, {});
+function normalizeStage(input) {
+  if (typeof input !== "string") {
+    return STAGES.LOCAL;
+  }
+  const normalized = input.trim().toLowerCase();
+  const match = KNOWN_STAGE_VALUES.find((stage) => stage === normalized);
+  return match ?? STAGES.LOCAL;
+}
+__name(normalizeStage, "normalizeStage");
+function getRecognitionServiceBase(stage) {
+  const normalizedStage = normalizeStage(stage);
+  return RECOGNITION_SERVICE_BASES[normalizedStage];
+}
+__name(getRecognitionServiceBase, "getRecognitionServiceBase");
+function getRecognitionServiceHttpBase(stage) {
+  return getRecognitionServiceBase(stage).httpBase;
+}
+__name(getRecognitionServiceHttpBase, "getRecognitionServiceHttpBase");
+function getRecognitionServiceWsBase(stage) {
+  return getRecognitionServiceBase(stage).wsBase;
+}
+__name(getRecognitionServiceWsBase, "getRecognitionServiceWsBase");
+function getRecognitionServiceHost(stage) {
+  const normalizedStage = normalizeStage(stage);
+  return RECOGNITION_SERVICE_HOST_BY_STAGE[normalizedStage];
+}
+__name(getRecognitionServiceHost, "getRecognitionServiceHost");
+function getRecognitionConductorBase(stage) {
+  const normalizedStage = normalizeStage(stage);
+  return RECOGNITION_CONDUCTOR_BASES[normalizedStage];
+}
+__name(getRecognitionConductorBase, "getRecognitionConductorBase");
+function getRecognitionConductorHttpBase(stage) {
+  return getRecognitionConductorBase(stage).httpBase;
+}
+__name(getRecognitionConductorHttpBase, "getRecognitionConductorHttpBase");
+function getRecognitionConductorWsBase(stage) {
+  return getRecognitionConductorBase(stage).wsBase;
+}
+__name(getRecognitionConductorWsBase, "getRecognitionConductorWsBase");
+function getRecognitionConductorHost(stage) {
+  const normalizedStage = normalizeStage(stage);
+  return RECOGNITION_CONDUCTOR_HOST_BY_STAGE[normalizedStage];
+}
+__name(getRecognitionConductorHost, "getRecognitionConductorHost");
+
+// src/utils/url-builder.ts
+function buildWebSocketUrl(config) {
+  const defaultBase = getRecognitionServiceBase("production");
+  const baseUrl = config.url || `${defaultBase.wsBase}/ws/v1/recognize`;
+  const url = new URL(baseUrl);
+  url.searchParams.set("audioUtteranceId", config.audioUtteranceId);
+  if (config.callbackUrls && config.callbackUrls.length > 0) {
+    url.searchParams.set("callbackUrls", JSON.stringify(config.callbackUrls));
+  }
+  if (config.userId) {
+    url.searchParams.set("userId", config.userId);
+  }
+  if (config.gameSessionId) {
+    url.searchParams.set("gameSessionId", config.gameSessionId);
+  }
+  if (config.deviceId) {
+    url.searchParams.set("deviceId", config.deviceId);
+  }
+  if (config.accountId) {
+    url.searchParams.set("accountId", config.accountId);
+  }
+  if (config.questionAnswerId) {
+    url.searchParams.set("questionAnswerId", config.questionAnswerId);
+  }
+  if (config.platform) {
+    url.searchParams.set("platform", config.platform);
+  }
+  if (config.gameContext) {
+    url.searchParams.set("gameId", config.gameContext.gameId);
+    url.searchParams.set("gamePhase", config.gameContext.gamePhase);
+  }
+  return url.toString();
+}
+__name(buildWebSocketUrl, "buildWebSocketUrl");
+
+// src/utils/audio-ring-buffer.ts
+var AudioRingBuffer = class {
+  static {
+    __name(this, "AudioRingBuffer");
+  }
+  buffer = [];
+  bufferSize;
+  writeIndex = 0;
+  readIndex = 0;
+  hasWrapped = false;
+  totalBufferedBytes = 0;
+  overflowCount = 0;
+  chunksBuffered = 0;
+  logger;
+  constructor(config) {
+    this.bufferSize = config.maxBufferDurationSec * config.chunksPerSecond;
+    this.buffer = new Array(this.bufferSize);
+    if (config.logger) {
+      this.logger = config.logger;
+    }
+  }
+  /**
+  * Write audio chunk to ring buffer with overflow detection
+  */
+  write(audioData) {
+    const bytes = ArrayBuffer.isView(audioData) ? audioData.byteLength : audioData.byteLength;
+    this.buffer[this.writeIndex] = {
+      data: audioData,
+      timestamp: Date.now()
+    };
+    const nextWriteIndex = (this.writeIndex + 1) % this.bufferSize;
+    if (nextWriteIndex === this.readIndex && this.writeIndex !== this.readIndex) {
+      this.hasWrapped = true;
+      this.overflowCount++;
+      if (this.logger) {
+        this.logger("debug", "Buffer overflow detected", {
+          bufferSize: this.bufferSize,
+          totalOverflows: this.overflowCount,
+          droppedChunk: this.buffer[this.readIndex]?.timestamp
+        });
+      }
+      this.readIndex = (this.readIndex + 1) % this.bufferSize;
+    }
+    this.writeIndex = nextWriteIndex;
+    this.chunksBuffered++;
+    this.totalBufferedBytes += bytes;
+  }
+  /**
+  * Read next chunk from buffer
+  */
+  read() {
+    if (this.isEmpty()) {
+      return null;
+    }
+    const chunk = this.buffer[this.readIndex];
+    this.readIndex = (this.readIndex + 1) % this.bufferSize;
+    return chunk || null;
+  }
+  /**
+  * Read all buffered chunks without removing them
+  */
+  readAll() {
+    const chunks = [];
+    let index = this.readIndex;
+    while (index !== this.writeIndex) {
+      const chunk = this.buffer[index];
+      if (chunk) {
+        chunks.push(chunk);
+      }
+      index = (index + 1) % this.bufferSize;
+    }
+    return chunks;
+  }
+  /**
+  * Flush all buffered data and advance read pointer
+  */
+  flush() {
+    const chunks = this.readAll();
+    this.readIndex = this.writeIndex;
+    return chunks;
+  }
+  /**
+  * Get count of buffered chunks
+  */
+  getBufferedCount() {
+    if (this.writeIndex >= this.readIndex) {
+      return this.writeIndex - this.readIndex;
+    } else {
+      return this.bufferSize - this.readIndex + this.writeIndex;
+    }
+  }
+  /**
+  * Check if buffer is empty
+  */
+  isEmpty() {
+    return this.readIndex === this.writeIndex;
+  }
+  /**
+  * Check if buffer has overflowed
+  */
+  isOverflowing() {
+    return this.hasWrapped;
+  }
+  /**
+  * Clear the buffer and reset all counters
+  * Frees memory by releasing all stored audio chunks
+  */
+  clear() {
+    this.buffer = [];
+    this.writeIndex = 0;
+    this.readIndex = 0;
+    this.hasWrapped = false;
+    this.overflowCount = 0;
+    this.chunksBuffered = 0;
+    this.totalBufferedBytes = 0;
+    if (this.logger) {
+      this.logger("debug", "Audio buffer cleared");
+    }
+  }
+  /**
+  * Get buffer statistics
+  */
+  getStats() {
+    return {
+      chunksBuffered: this.chunksBuffered,
+      currentBufferedChunks: this.getBufferedCount(),
+      overflowCount: this.overflowCount,
+      hasWrapped: this.hasWrapped,
+      totalBufferedBytes: this.totalBufferedBytes
+    };
+  }
+};
+
+// src/utils/message-handler.ts
+var MessageHandler = class {
+  static {
+    __name(this, "MessageHandler");
+  }
+  firstTranscriptTime = null;
+  sessionStartTime = null;
+  callbacks;
+  constructor(callbacks) {
+    this.callbacks = callbacks;
+  }
+  /**
+  * Set session start time for performance tracking
+  */
+  setSessionStartTime(time) {
+    this.sessionStartTime = time;
+  }
+  /**
+  * Handle incoming WebSocket message
+  */
+  handleMessage(msg) {
+    if (this.callbacks.logger) {
+      this.callbacks.logger("debug", "Received WebSocket message", {
+        msgType: msg.type,
+        msgDataType: msg.data && typeof msg.data === "object" && "type" in msg.data ? msg.data.type : "N/A",
+        fullMessage: msg
+      });
+    }
+    if (msg.data && typeof msg.data !== "object") {
+      if (this.callbacks.logger) {
+        this.callbacks.logger("error", "Received primitive msg.data from server", {
+          dataType: typeof msg.data,
+          data: msg.data,
+          fullMessage: msg
+        });
+      }
+    }
+    const msgType = (msg.data && typeof msg.data === "object" && "type" in msg.data ? msg.data.type : void 0) || msg.type;
+    const msgData = msg.data || msg;
+    switch (msgType) {
+      case RecognitionResultTypeV1.TRANSCRIPTION:
+        this.handleTranscription(msgData);
+        break;
+      case RecognitionResultTypeV1.FUNCTION_CALL:
+        this.callbacks.onFunctionCall(msgData);
+        break;
+      case RecognitionResultTypeV1.METADATA:
+        this.callbacks.onMetadata(msgData);
+        break;
+      case RecognitionResultTypeV1.ERROR:
+        this.callbacks.onError(msgData);
+        break;
+      case RecognitionResultTypeV1.CLIENT_CONTROL_MESSAGE:
+        this.callbacks.onControlMessage(msgData);
+        break;
+      default:
+        if (this.callbacks.logger) {
+          this.callbacks.logger("debug", "Unknown message type", {
+            type: msgType
+          });
+        }
+    }
+  }
+  /**
+  * Handle transcript message and track performance metrics
+  * @param result - The transcription result from the server
+  */
+  handleTranscription(result) {
+    if (!this.firstTranscriptTime && this.sessionStartTime) {
+      this.firstTranscriptTime = Date.now();
+      const timeToFirstTranscript = this.firstTranscriptTime - this.sessionStartTime;
+      if (this.callbacks.logger) {
+        this.callbacks.logger("debug", "First transcript received", {
+          timeToFirstTranscriptMs: timeToFirstTranscript
+        });
+      }
+    }
+    this.callbacks.onTranscript(result);
+  }
+  /**
+  * Get performance metrics
+  */
+  getMetrics() {
+    return {
+      sessionStartTime: this.sessionStartTime,
+      firstTranscriptTime: this.firstTranscriptTime,
+      timeToFirstTranscript: this.firstTranscriptTime && this.sessionStartTime ? this.firstTranscriptTime - this.sessionStartTime : null
+    };
+  }
+};
+
+// src/recognition-client.ts
+function isNormalDisconnection(code) {
+  return code === 1e3;
+}
+__name(isNormalDisconnection, "isNormalDisconnection");
+var RealTimeTwoWayWebSocketRecognitionClient = class _RealTimeTwoWayWebSocketRecognitionClient extends WebSocketAudioClient {
+  static {
+    __name(this, "RealTimeTwoWayWebSocketRecognitionClient");
+  }
+  static PROTOCOL_VERSION = 1;
+  config;
+  audioBuffer;
+  messageHandler;
+  state = ClientState.INITIAL;
+  connectionPromise;
+  // Debug control (internal state, controlled by debugCommand in ASRRequest)
+  isDebugLogEnabled = false;
+  // Stats
+  audioBytesSent = 0;
+  audioChunksSent = 0;
+  audioStatsLogInterval = 100;
+  lastAudioStatsLog = 0;
+  constructor(config) {
+    const audioUtteranceId = config.audioUtteranceId || v4();
+    const url = buildWebSocketUrl({
+      audioUtteranceId,
+      ...config.url && {
+        url: config.url
+      },
+      ...config.callbackUrls && {
+        callbackUrls: config.callbackUrls
+      },
+      ...config.userId && {
+        userId: config.userId
+      },
+      ...config.gameSessionId && {
+        gameSessionId: config.gameSessionId
+      },
+      ...config.deviceId && {
+        deviceId: config.deviceId
+      },
+      ...config.accountId && {
+        accountId: config.accountId
+      },
+      ...config.questionAnswerId && {
+        questionAnswerId: config.questionAnswerId
+      },
+      ...config.platform && {
+        platform: config.platform
+      },
+      ...config.gameContext && {
+        gameContext: config.gameContext
+      }
+    });
+    super({
+      url,
+      highWM: config.highWaterMark ?? 512e3,
+      lowWM: config.lowWaterMark ?? 128e3
+    });
+    this.config = {
+      url,
+      audioUtteranceId,
+      ...config.asrRequestConfig && {
+        asrRequestConfig: config.asrRequestConfig
+      },
+      ...config.gameContext && {
+        gameContext: config.gameContext
+      },
+      ...config.callbackUrls && {
+        callbackUrls: config.callbackUrls
+      },
+      onTranscript: config.onTranscript || (() => {
+      }),
+      onFunctionCall: config.onFunctionCall || (() => {
+      }),
+      onMetadata: config.onMetadata || (() => {
+      }),
+      onError: config.onError || (() => {
+      }),
+      onConnected: config.onConnected || (() => {
+      }),
+      onDisconnected: config.onDisconnected || (() => {
+      }),
+      highWaterMark: config.highWaterMark ?? 512e3,
+      lowWaterMark: config.lowWaterMark ?? 128e3,
+      maxBufferDurationSec: config.maxBufferDurationSec ?? 60,
+      chunksPerSecond: config.chunksPerSecond ?? 100,
+      ...config.logger && {
+        logger: config.logger
+      }
+    };
+    this.audioBuffer = new AudioRingBuffer({
+      maxBufferDurationSec: this.config.maxBufferDurationSec,
+      chunksPerSecond: this.config.chunksPerSecond,
+      ...this.config.logger && {
+        logger: this.config.logger
+      }
+    });
+    this.messageHandler = new MessageHandler({
+      onTranscript: this.config.onTranscript,
+      onFunctionCall: this.config.onFunctionCall,
+      onMetadata: this.config.onMetadata,
+      onError: this.config.onError,
+      onControlMessage: this.handleControlMessage.bind(this),
+      ...this.config.logger && {
+        logger: this.config.logger
+      }
+    });
+  }
+  // ==========================================================================
+  // PRIVATE HELPERS
+  // ==========================================================================
+  /**
+  * Internal logging helper - only logs if a logger was provided in config
+  * Debug logs are additionally gated by isDebugLogEnabled flag
+  * @param level - Log level: debug, info, warn, or error
+  * @param message - Message to log
+  * @param data - Optional additional data to log
+  */
+  log(level, message, data) {
+    if (level === "debug" && !this.isDebugLogEnabled) {
+      return;
+    }
+    if (this.config.logger) {
+      this.config.logger(level, `[SDK] ${message}`, data);
+    }
+  }
+  /**
+  * Clean up internal resources to free memory
+  * Called when connection closes (normally or abnormally)
+  */
+  cleanup() {
+    this.log("debug", "Cleaning up resources");
+    this.audioBuffer.clear();
+    this.audioBytesSent = 0;
+    this.audioChunksSent = 0;
+    this.lastAudioStatsLog = 0;
+    this.connectionPromise = void 0;
+  }
+  // ==========================================================================
+  // PUBLIC API
+  // ==========================================================================
+  async connect() {
+    if (this.connectionPromise) {
+      this.log("debug", "Returning existing connection promise", {
+        state: this.state,
+        hasPromise: true
+      });
+      return this.connectionPromise;
+    }
+    if (this.state !== ClientState.INITIAL && this.state !== ClientState.FAILED && this.state !== ClientState.STOPPED) {
+      this.log("debug", "Already connected or in wrong state", {
+        state: this.state
+      });
+      return Promise.resolve();
+    }
+    this.log("debug", "Creating new connection to WebSocket", {
+      url: this.config.url
+    });
+    this.state = ClientState.CONNECTING;
+    const connectionStartTime = Date.now();
+    this.connectionPromise = new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.log("warn", "Connection timeout", {
+          timeout: 1e4
+        });
+        this.state = ClientState.FAILED;
+        reject(new Error("Timeout"));
+      }, 1e4);
+      const originalOnConnected = this.onConnected.bind(this);
+      this.onConnected = () => {
+        clearTimeout(timeout);
+        const connectionTime = Date.now() - connectionStartTime;
+        this.log("debug", "Connection established successfully", {
+          connectionTimeMs: connectionTime,
+          url: this.config.url
+        });
+        this.state = ClientState.CONNECTED;
+        originalOnConnected();
+        resolve();
+      };
+      const originalOnError = this.onError.bind(this);
+      this.onError = (error) => {
+        clearTimeout(timeout);
+        this.log("warn", "Connection error", error);
+        this.state = ClientState.FAILED;
+        originalOnError(error);
+        reject(error);
+      };
+      super.connect();
+    });
+    return this.connectionPromise;
+  }
+  sendAudio(audioData) {
+    const bytes = ArrayBuffer.isView(audioData) ? audioData.byteLength : audioData.byteLength;
+    if (bytes === 0) return;
+    this.audioBuffer.write(audioData);
+    if (this.state === ClientState.READY && !super.isLocalBackpressured()) {
+      this.log("debug", "Sending audio immediately", {
+        bytes
+      });
+      this.sendAudioNow(audioData);
+      this.audioBuffer.read();
+    } else {
+      this.log("debug", "Buffering audio", {
+        bytes,
+        state: this.state,
+        backpressured: super.isLocalBackpressured()
+      });
+    }
+    if (this.isDebugLogEnabled) {
+      const totalChunks = this.audioChunksSent + this.audioBuffer.getStats().chunksBuffered;
+      if (totalChunks - this.lastAudioStatsLog >= this.audioStatsLogInterval) {
+        const stats = this.audioBuffer.getStats();
+        this.log("debug", "Audio statistics", {
+          totalBytesSent: this.audioBytesSent,
+          totalChunksSent: this.audioChunksSent,
+          ...stats
+        });
+        this.lastAudioStatsLog = totalChunks;
+      }
+    }
+  }
+  async stopRecording() {
+    if (this.state !== ClientState.READY) {
+      this.log("warn", "Cannot stop recording - not in READY state", {
+        state: this.state
+      });
+      return;
+    }
+    this.log("debug", "Stopping recording");
+    this.state = ClientState.STOPPING;
+    super.sendMessage(_RealTimeTwoWayWebSocketRecognitionClient.PROTOCOL_VERSION, "message", {
+      type: RecognitionContextTypeV1.CONTROL_SIGNAL,
+      signal: ControlSignalTypeV1.STOP_RECORDING
+    });
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        this.state = ClientState.STOPPED;
+        resolve();
+      }, 5e3);
+      const original = this.config.onTranscript;
+      this.config.onTranscript = (result) => {
+        original(result);
+        if (result.is_finished) {
+          clearTimeout(timeout);
+          this.state = ClientState.STOPPED;
+          resolve();
+        }
+      };
+      this.messageHandler.callbacks.onTranscript = this.config.onTranscript;
+    });
+  }
+  getAudioUtteranceId() {
+    return this.config.audioUtteranceId;
+  }
+  getState() {
+    return this.state;
+  }
+  isConnected() {
+    return this.state === ClientState.READY;
+  }
+  isConnecting() {
+    return this.state === ClientState.CONNECTING;
+  }
+  isStopping() {
+    return this.state === ClientState.STOPPING;
+  }
+  isTranscriptionFinished() {
+    return this.state === ClientState.STOPPED;
+  }
+  isBufferOverflowing() {
+    return this.audioBuffer.isOverflowing();
+  }
+  getStats() {
+    const bufferStats = this.audioBuffer.getStats();
+    return {
+      audioBytesSent: this.audioBytesSent,
+      audioChunksSent: this.audioChunksSent,
+      audioChunksBuffered: bufferStats.chunksBuffered,
+      bufferOverflowCount: bufferStats.overflowCount,
+      currentBufferedChunks: bufferStats.currentBufferedChunks,
+      hasWrapped: bufferStats.hasWrapped
+    };
+  }
+  // ==========================================================================
+  // WEBSOCKET HOOKS (from WebSocketAudioClient)
+  // ==========================================================================
+  onConnected() {
+    this.log("debug", "WebSocket onConnected callback");
+    if (this.config.asrRequestConfig) {
+      const debugCommand = this.config.asrRequestConfig.debugCommand;
+      if (debugCommand?.enableDebugLog) {
+        this.isDebugLogEnabled = true;
+        this.log("debug", "Debug logging enabled via debugCommand");
+      }
+      if (this.isDebugLogEnabled) {
+        this.log("debug", "Sending ASR request", this.config.asrRequestConfig);
+      }
+      const asrRequest = {
+        type: RecognitionContextTypeV1.ASR_REQUEST,
+        audioUtteranceId: this.config.audioUtteranceId,
+        provider: this.config.asrRequestConfig.provider.toString(),
+        model: this.config.asrRequestConfig.model,
+        language: this.config.asrRequestConfig.language?.toString() || "en",
+        sampleRate: typeof this.config.asrRequestConfig.sampleRate === "number" ? this.config.asrRequestConfig.sampleRate : SampleRate.RATE_16000,
+        encoding: typeof this.config.asrRequestConfig.encoding === "number" ? this.config.asrRequestConfig.encoding : AudioEncoding.LINEAR16,
+        interimResults: this.config.asrRequestConfig.interimResults ?? false,
+        // Auto-enable useContext if gameContext is provided, or use explicit value if set
+        useContext: this.config.asrRequestConfig.useContext ?? !!this.config.gameContext,
+        ...debugCommand && {
+          debugCommand
+        }
+      };
+      super.sendMessage(_RealTimeTwoWayWebSocketRecognitionClient.PROTOCOL_VERSION, "message", asrRequest);
+    }
+    if (this.config.gameContext) {
+      if (this.isDebugLogEnabled) {
+        this.log("debug", "Sending game context", this.config.gameContext);
+      }
+      super.sendMessage(_RealTimeTwoWayWebSocketRecognitionClient.PROTOCOL_VERSION, "message", this.config.gameContext);
+    }
+    this.log("debug", "Waiting for server ready signal");
+    this.config.onConnected();
+  }
+  onDisconnected(code, reason) {
+    this.log("debug", "WebSocket disconnected", {
+      code,
+      reason,
+      previousState: this.state
+    });
+    if (this.state === ClientState.STOPPING) {
+      this.state = ClientState.STOPPED;
+    } else if (this.state === ClientState.CONNECTED || this.state === ClientState.READY || this.state === ClientState.CONNECTING) {
+      this.log("error", "Unexpected disconnection", {
+        code,
+        reason
+      });
+      this.state = ClientState.FAILED;
+    }
+    this.cleanup();
+    this.config.onDisconnected(code, reason);
+  }
+  onError(error) {
+    this.state = ClientState.FAILED;
+    const errorResult = {
+      type: RecognitionResultTypeV1.ERROR,
+      audioUtteranceId: "",
+      message: "WebSocket error",
+      description: error.type || "Connection error"
+    };
+    this.config.onError(errorResult);
+  }
+  onMessage(msg) {
+    this.messageHandler.handleMessage(msg);
+  }
+  // ==========================================================================
+  // INTERNAL HELPERS
+  // ==========================================================================
+  /**
+  * Handle control messages from server
+  * @param msg - Control message containing server actions
+  */
+  handleControlMessage(msg) {
+    switch (msg.action) {
+      case ClientControlActionV1.READY_FOR_UPLOADING_RECORDING: {
+        this.log("debug", "Server ready for audio upload");
+        this.state = ClientState.READY;
+        this.messageHandler.setSessionStartTime(Date.now());
+        const bufferedChunks = this.audioBuffer.flush();
+        if (bufferedChunks.length > 0) {
+          this.log("debug", "Flushing buffered audio", {
+            chunks: bufferedChunks.length
+          });
+          bufferedChunks.forEach((chunk) => this.sendAudioNow(chunk.data));
+        }
+        break;
+      }
+      case ClientControlActionV1.STOP_RECORDING:
+        this.log("debug", "Received stop recording signal from server");
+        break;
+      default:
+        this.log("warn", "Unknown control action", {
+          action: msg.action
+        });
+    }
+  }
+  /**
+  * Send audio immediately to the server (without buffering)
+  * @param audioData - Audio data to send
+  */
+  sendAudioNow(audioData) {
+    const byteLength = ArrayBuffer.isView(audioData) ? audioData.byteLength : audioData.byteLength;
+    const encodingId = this.config.asrRequestConfig?.encoding || AudioEncoding.LINEAR16;
+    const sampleRate = typeof this.config.asrRequestConfig?.sampleRate === "number" ? this.config.asrRequestConfig.sampleRate : SampleRate.RATE_16000;
+    super.sendAudio(audioData, _RealTimeTwoWayWebSocketRecognitionClient.PROTOCOL_VERSION, encodingId, sampleRate);
+    this.audioBytesSent += byteLength;
+    this.audioChunksSent++;
+  }
+};
+
+// src/config-builder.ts
+var ConfigBuilder = class {
+  static {
+    __name(this, "ConfigBuilder");
+  }
+  config = {};
+  /**
+  * Set the WebSocket URL
+  */
+  url(url) {
+    this.config.url = url;
+    return this;
+  }
+  /**
+  * Set ASR request configuration
+  */
+  asrRequestConfig(config) {
+    this.config.asrRequestConfig = config;
+    return this;
+  }
+  /**
+  * Set game context
+  */
+  gameContext(context) {
+    this.config.gameContext = context;
+    return this;
+  }
+  /**
+  * Set audio utterance ID
+  */
+  audioUtteranceId(id) {
+    this.config.audioUtteranceId = id;
+    return this;
+  }
+  /**
+  * Set callback URLs
+  */
+  callbackUrls(urls) {
+    this.config.callbackUrls = urls;
+    return this;
+  }
+  /**
+  * Set user ID
+  */
+  userId(id) {
+    this.config.userId = id;
+    return this;
+  }
+  /**
+  * Set game session ID
+  */
+  gameSessionId(id) {
+    this.config.gameSessionId = id;
+    return this;
+  }
+  /**
+  * Set device ID
+  */
+  deviceId(id) {
+    this.config.deviceId = id;
+    return this;
+  }
+  /**
+  * Set account ID
+  */
+  accountId(id) {
+    this.config.accountId = id;
+    return this;
+  }
+  /**
+  * Set question answer ID
+  */
+  questionAnswerId(id) {
+    this.config.questionAnswerId = id;
+    return this;
+  }
+  /**
+  * Set platform
+  */
+  platform(platform) {
+    this.config.platform = platform;
+    return this;
+  }
+  /**
+  * Set transcript callback
+  */
+  onTranscript(callback) {
+    this.config.onTranscript = callback;
+    return this;
+  }
+  /**
+  * Set metadata callback
+  */
+  onMetadata(callback) {
+    this.config.onMetadata = callback;
+    return this;
+  }
+  /**
+  * Set error callback
+  */
+  onError(callback) {
+    this.config.onError = callback;
+    return this;
+  }
+  /**
+  * Set connected callback
+  */
+  onConnected(callback) {
+    this.config.onConnected = callback;
+    return this;
+  }
+  /**
+  * Set disconnected callback
+  */
+  onDisconnected(callback) {
+    this.config.onDisconnected = callback;
+    return this;
+  }
+  /**
+  * Set high water mark
+  */
+  highWaterMark(bytes) {
+    this.config.highWaterMark = bytes;
+    return this;
+  }
+  /**
+  * Set low water mark
+  */
+  lowWaterMark(bytes) {
+    this.config.lowWaterMark = bytes;
+    return this;
+  }
+  /**
+  * Set max buffer duration in seconds
+  */
+  maxBufferDurationSec(seconds) {
+    this.config.maxBufferDurationSec = seconds;
+    return this;
+  }
+  /**
+  * Set chunks per second
+  */
+  chunksPerSecond(chunks) {
+    this.config.chunksPerSecond = chunks;
+    return this;
+  }
+  /**
+  * Set logger function
+  */
+  logger(logger) {
+    this.config.logger = logger;
+    return this;
+  }
+  /**
+  * Build the configuration
+  */
+  build() {
+    return this.config;
+  }
+};
+
+// src/factory.ts
+function createClient(config) {
+  return new RealTimeTwoWayWebSocketRecognitionClient(config);
+}
+__name(createClient, "createClient");
+function createClientWithBuilder(configure) {
+  const builder = new ConfigBuilder();
+  const config = configure(builder).build();
+  return new RealTimeTwoWayWebSocketRecognitionClient(config);
+}
+__name(createClientWithBuilder, "createClientWithBuilder");
+var RecognitionVGFStateSchema = z.object({
+  // Core STT state
+  audioUtteranceId: z.string(),
+  startRecordingStatus: z.string().optional(),
+  // Streaming should only start when "READY". Other states control mic UI and recording.
+  transcriptionStatus: z.string().optional(),
+  finalTranscript: z.string().optional(),
+  finalConfidence: z.number().optional(),
+  // Tracking-only metadata
+  asrConfig: z.string().optional(),
+  startRecordingTimestamp: z.string().optional(),
+  finalRecordingTimestamp: z.string().optional(),
+  finalTranscriptionTimestamp: z.string().optional(),
+  // STEP 2: Support for mic auto-stop upon correct answer
+  pendingTranscript: z.string().optional().default(""),
+  pendingConfidence: z.number().optional(),
+  // STEP 3: Support for semantic/function-call outcomes
+  functionCallMetadata: z.string().optional(),
+  functionCallConfidence: z.number().optional(),
+  finalFunctionCallTimestamp: z.string().optional(),
+  // Support for prompt slot mapping - passed to recognition context when present
+  promptSlotMap: z.record(z.string(), z.array(z.string())).optional()
+});
+var RecordingStatus = {
+  NOT_READY: "NOT_READY",
+  READY: "READY",
+  RECORDING: "RECORDING",
+  FINISHED: "FINISHED"
+};
+var TranscriptionStatus = {
+  NOT_STARTED: "NOT_STARTED",
+  IN_PROGRESS: "IN_PROGRESS",
+  FINALIZED: "FINALIZED",
+  ERROR: "ERROR"
+};
+function createInitialRecognitionState(audioUtteranceId) {
+  return {
+    audioUtteranceId,
+    startRecordingStatus: RecordingStatus.NOT_READY,
+    transcriptionStatus: TranscriptionStatus.NOT_STARTED,
+    pendingTranscript: ""
+  };
+}
+__name(createInitialRecognitionState, "createInitialRecognitionState");
+function isValidRecordingStatusTransition(from, to) {
+  const statusOrder = [
+    RecordingStatus.NOT_READY,
+    RecordingStatus.READY,
+    RecordingStatus.RECORDING,
+    RecordingStatus.FINISHED
+  ];
+  const fromIndex = from ? statusOrder.indexOf(from) : -1;
+  const toIndex = statusOrder.indexOf(to);
+  return toIndex > fromIndex && toIndex !== -1;
+}
+__name(isValidRecordingStatusTransition, "isValidRecordingStatusTransition");
+
+// src/vgf-recognition-mapper.ts
+function mapTranscriptionResultToState(currentState, result, isRecording) {
+  const newState = {
+    ...currentState
+  };
+  if (isRecording && currentState.startRecordingStatus !== RecordingStatus.FINISHED) {
+    newState.startRecordingStatus = RecordingStatus.RECORDING;
+    if (!newState.startRecordingTimestamp) {
+      newState.startRecordingTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  if (!result.is_finished) {
+    newState.transcriptionStatus = TranscriptionStatus.IN_PROGRESS;
+    newState.pendingTranscript = result.pendingTranscript || "";
+    if (result.pendingTranscriptConfidence !== void 0) {
+      newState.pendingConfidence = result.pendingTranscriptConfidence;
+    }
+    if (result.finalTranscript) {
+      newState.finalTranscript = result.finalTranscript;
+      if (result.finalTranscriptConfidence !== void 0) {
+        newState.finalConfidence = result.finalTranscriptConfidence;
+      }
+    }
+  } else {
+    newState.transcriptionStatus = TranscriptionStatus.FINALIZED;
+    newState.finalTranscript = result.finalTranscript || "";
+    if (result.finalTranscriptConfidence !== void 0) {
+      newState.finalConfidence = result.finalTranscriptConfidence;
+    }
+    newState.finalTranscriptionTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+    newState.pendingTranscript = "";
+    newState.pendingConfidence = void 0;
+  }
+  return newState;
+}
+__name(mapTranscriptionResultToState, "mapTranscriptionResultToState");
+function mapMetadataToState(currentState, metadata) {
+  const newState = {
+    ...currentState
+  };
+  if (!newState.finalRecordingTimestamp) {
+    newState.finalRecordingTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  newState.startRecordingStatus = RecordingStatus.FINISHED;
+  return newState;
+}
+__name(mapMetadataToState, "mapMetadataToState");
+function mapErrorToState(currentState, error) {
+  return {
+    ...currentState,
+    transcriptionStatus: TranscriptionStatus.ERROR,
+    startRecordingStatus: RecordingStatus.FINISHED,
+    finalRecordingTimestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+__name(mapErrorToState, "mapErrorToState");
+function createVGFStateFromConfig(config) {
+  const audioUtteranceId = config.audioUtteranceId || generateUUID();
+  const state = createInitialRecognitionState(audioUtteranceId);
+  if (config.asrRequestConfig) {
+    state.asrConfig = JSON.stringify(config.asrRequestConfig);
+  }
+  return state;
+}
+__name(createVGFStateFromConfig, "createVGFStateFromConfig");
+function updateStateOnStop(currentState) {
+  return {
+    ...currentState,
+    startRecordingStatus: RecordingStatus.FINISHED,
+    finalRecordingTimestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+__name(updateStateOnStop, "updateStateOnStop");
+function generateUUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+__name(generateUUID, "generateUUID");
+
+// src/simplified-vgf-recognition-client.ts
+var SimplifiedVGFRecognitionClient = class {
+  static {
+    __name(this, "SimplifiedVGFRecognitionClient");
+  }
+  client;
+  state;
+  isRecordingAudio = false;
+  stateChangeCallback;
+  constructor(config) {
+    const { onStateChange, initialState, ...clientConfig } = config;
+    this.stateChangeCallback = onStateChange;
+    if (initialState) {
+      this.state = initialState;
+      if (initialState.audioUtteranceId && !clientConfig.audioUtteranceId) {
+        clientConfig.audioUtteranceId = initialState.audioUtteranceId;
+      }
+    } else {
+      this.state = createVGFStateFromConfig(clientConfig);
+    }
+    this.state = {
+      ...this.state,
+      startRecordingStatus: "READY"
+    };
+    if (this.state.promptSlotMap) {
+      if (clientConfig.asrRequestConfig) {
+        clientConfig.asrRequestConfig.useContext = true;
+      }
+      if (!clientConfig.gameContext) {
+        if (clientConfig.logger) {
+          clientConfig.logger("warn", "[VGF] promptSlotMap found but no gameContext provided. SlotMap will not be sent.");
+        }
+      } else {
+        clientConfig.gameContext.slotMap = this.state.promptSlotMap;
+      }
+    }
+    this.client = new RealTimeTwoWayWebSocketRecognitionClient({
+      ...clientConfig,
+      // These callbacks ONLY update the VGF state sink
+      onTranscript: /* @__PURE__ */ __name((result) => {
+        this.state = mapTranscriptionResultToState(this.state, result, this.isRecordingAudio);
+        this.notifyStateChange();
+        if (clientConfig.onTranscript) {
+          clientConfig.onTranscript(result);
+        }
+      }, "onTranscript"),
+      onMetadata: /* @__PURE__ */ __name((metadata) => {
+        this.state = mapMetadataToState(this.state);
+        this.notifyStateChange();
+        if (clientConfig.onMetadata) {
+          clientConfig.onMetadata(metadata);
+        }
+      }, "onMetadata"),
+      onFunctionCall: /* @__PURE__ */ __name((result) => {
+        if (clientConfig.onFunctionCall) {
+          clientConfig.onFunctionCall(result);
+        }
+      }, "onFunctionCall"),
+      onError: /* @__PURE__ */ __name((error) => {
+        this.isRecordingAudio = false;
+        this.state = mapErrorToState(this.state);
+        this.notifyStateChange();
+        if (clientConfig.onError) {
+          clientConfig.onError(error);
+        }
+      }, "onError"),
+      onConnected: /* @__PURE__ */ __name(() => {
+        if (clientConfig.onConnected) {
+          clientConfig.onConnected();
+        }
+      }, "onConnected"),
+      onDisconnected: /* @__PURE__ */ __name((code, reason) => {
+        this.isRecordingAudio = false;
+        if (clientConfig.onDisconnected) {
+          clientConfig.onDisconnected(code, reason);
+        }
+      }, "onDisconnected")
+    });
+  }
+  // DELEGATE ALL METHODS TO UNDERLYING CLIENT
+  // The wrapper ONLY updates VGF state, doesn't use it for decisions
+  async connect() {
+    await this.client.connect();
+  }
+  sendAudio(audioData) {
+    if (!this.isRecordingAudio) {
+      this.isRecordingAudio = true;
+      this.state = {
+        ...this.state,
+        startRecordingStatus: "RECORDING",
+        startRecordingTimestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.notifyStateChange();
+    }
+    this.client.sendAudio(audioData);
+  }
+  async stopRecording() {
+    this.isRecordingAudio = false;
+    this.state = updateStateOnStop(this.state);
+    this.notifyStateChange();
+    await this.client.stopRecording();
+  }
+  // Pure delegation methods - no state logic
+  getAudioUtteranceId() {
+    return this.client.getAudioUtteranceId();
+  }
+  getState() {
+    return this.client.getState();
+  }
+  isConnected() {
+    return this.client.isConnected();
+  }
+  isConnecting() {
+    return this.client.isConnecting();
+  }
+  isStopping() {
+    return this.client.isStopping();
+  }
+  isTranscriptionFinished() {
+    return this.client.isTranscriptionFinished();
+  }
+  isBufferOverflowing() {
+    return this.client.isBufferOverflowing();
+  }
+  // VGF State access (read-only for consumers)
+  getVGFState() {
+    return {
+      ...this.state
+    };
+  }
+  notifyStateChange() {
+    if (this.stateChangeCallback) {
+      this.stateChangeCallback({
+        ...this.state
+      });
+    }
+  }
+};
+function createSimplifiedVGFClient(config) {
+  return new SimplifiedVGFRecognitionClient(config);
+}
+__name(createSimplifiedVGFClient, "createSimplifiedVGFClient");
+
+export { AudioEncoding, ClientState, ConfigBuilder, ControlSignalTypeV1 as ControlSignal, ControlSignalTypeV1, DeepgramModel, GeminiModel, GoogleModel, Language, OpenAIModel, RECOGNITION_CONDUCTOR_BASES, RECOGNITION_SERVICE_BASES, RealTimeTwoWayWebSocketRecognitionClient, RecognitionContextTypeV1, RecognitionProvider, RecognitionResultTypeV1, RecognitionVGFStateSchema, RecordingStatus, SampleRate, SimplifiedVGFRecognitionClient, TranscriptionStatus, createClient, createClientWithBuilder, createInitialRecognitionState, createSimplifiedVGFClient, getRecognitionConductorBase, getRecognitionConductorHost, getRecognitionConductorHttpBase, getRecognitionConductorWsBase, getRecognitionServiceBase, getRecognitionServiceHost, getRecognitionServiceHttpBase, getRecognitionServiceWsBase, isNormalDisconnection, isValidRecordingStatusTransition, normalizeStage };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map