@absolutejs/voice 0.0.22-beta.463 → 0.0.22-beta.464

package/dist/angular/index.js

@@ -2009,6 +2009,8 @@ var serverMessageToAction = (message) => {
 };
 
 // node_modules/@absolutejs/media/dist/index.js
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
 var formatLabel = (format) => `${format.container}/${format.encoding}/${String(format.sampleRateHz)}hz/${String(format.channels)}ch`;
 var formatMatches = (actual, expected) => actual.container === expected.container && actual.encoding === expected.encoding && actual.sampleRateHz === expected.sampleRateHz && actual.channels === expected.channels;
 var pushIssue = (issues, severity, code, message) => {
@@ -2669,6 +2671,269 @@ var buildMediaPipelineCalibrationReport = (input = {}) => {
     turnCommitFrames: turnCommitFrames.length
   };
 };
+var DEFAULT_METADATA_DENY = [
+  "audioPayload",
+  "auth",
+  "authorization",
+  "cookie",
+  "email",
+  "phone",
+  "phoneNumber",
+  "rawPayload",
+  "secret",
+  "token",
+  "transcript",
+  "utterance"
+];
+var DEFAULT_TRUNCATE = 8;
+var issueCodes = (issues) => Array.from(new Set(issues.map((issue) => issue.code)));
+var lastEventKind = (events) => events[events.length - 1]?.kind;
+var formatOptionalMs = (value) => value === undefined ? "n/a" : `${String(Math.round(value))}ms`;
+var formatRatio = (value) => `${(value * 100).toFixed(1)}%`;
+var escapeMarkdownCell = (value) => value.replace(/\|/g, "\\|").replace(/\n/g, " ");
+var renderIssuesTable = (issues) => {
+  if (issues.length === 0) {
+    return `- No issues.
+`;
+  }
+  const rows = issues.map((issue) => `| ${issue.severity} | ${escapeMarkdownCell(issue.code)} | ${escapeMarkdownCell(issue.message)} |`).join(`
+`);
+  return `| Severity | Code | Message |
+| --- | --- | --- |
+${rows}
+`;
+};
+var summarizeMediaQualityReport = (report) => ({
+  backpressureEvents: report.backpressureEvents,
+  description: `${report.totalFrames} frame(s), ${report.gapCount} gap(s), speech ${formatRatio(report.speechRatio)}, status ${report.status}.`,
+  driftMs: report.timestampDriftMs,
+  frameCount: report.totalFrames,
+  gapCount: report.gapCount,
+  issueCodes: issueCodes(report.issues),
+  issueCount: report.issues.length,
+  jitterMs: report.jitterMs,
+  silenceRatio: report.silenceRatio,
+  speechRatio: report.speechRatio,
+  status: report.status
+});
+var summarizeMediaTransportReport = (report) => ({
+  backpressureEvents: report.backpressureEvents,
+  description: `${report.name}: ${report.state}, in ${report.inputFrames}, out ${report.outputFrames}, backpressure ${report.backpressureEvents}.`,
+  errors: report.events.filter((event) => event.kind === "error").length,
+  inputFrames: report.inputFrames,
+  lastEventKind: lastEventKind(report.events),
+  name: report.name,
+  outputFrames: report.outputFrames,
+  state: report.state,
+  status: report.status
+});
+var summarizeMediaProcessorGraphReport = (report) => {
+  const errorIssueCodes = Array.from(new Set(report.errors.map((event) => event.kind)));
+  return {
+    backpressureEvents: report.backpressure.events.length,
+    description: `${report.name}: ${report.state}, ${report.nodes.length} node(s), in ${report.inputFrames}, out ${report.emittedFrames}, dropped ${report.droppedFrames}.`,
+    droppedFrames: report.droppedFrames,
+    edgeCount: report.edges.length,
+    edgeEventCount: report.edgeEvents.length,
+    emittedFrames: report.emittedFrames,
+    errorCount: report.errors.length,
+    inputFrames: report.inputFrames,
+    issueCodes: errorIssueCodes,
+    lifecycleEventCount: report.lifecycleEvents.length,
+    name: report.name,
+    nodeCount: report.nodes.length,
+    state: report.state,
+    status: report.status,
+    timingMaxMs: report.timing.maxNodeMs
+  };
+};
+var renderMediaQualityMarkdown = (report, options = {}) => {
+  const title = options.title ?? "Media Quality Report";
+  const lines = [
+    `# ${title}`,
+    "",
+    `Status: **${report.status}**`,
+    "",
+    "| Metric | Value |",
+    "| --- | ---: |",
+    `| Total frames | ${report.totalFrames} |`,
+    `| Input audio | ${report.inputAudioFrames} |`,
+    `| Assistant audio | ${report.assistantAudioFrames} |`,
+    `| Gaps | ${report.gapCount} |`,
+    `| Jitter | ${formatOptionalMs(report.jitterMs)} |`,
+    `| Timestamp drift | ${formatOptionalMs(report.timestampDriftMs)} |`,
+    `| Speech ratio | ${formatRatio(report.speechRatio)} |`,
+    `| Silence ratio | ${formatRatio(report.silenceRatio)} |`,
+    `| Backpressure events | ${report.backpressureEvents} |`,
+    "",
+    "## Issues",
+    "",
+    renderIssuesTable(report.issues).trimEnd()
+  ];
+  return `${lines.join(`
+`)}
+`;
+};
+var renderMediaTransportMarkdown = (report, options = {}) => {
+  const title = options.title ?? `Media Transport: ${report.name}`;
+  const limit = options.redact?.truncateArraysAt ?? DEFAULT_TRUNCATE;
+  const events = report.events.slice(-limit);
+  const eventRows = events.length === 0 ? "- No transport events recorded." : ["| At | Kind | State | Buffered | Error |", "| --- | --- | --- | ---: | --- |"].concat(events.map((event) => `| ${event.at} | ${event.kind} | ${event.state} | ${event.bufferedFrames ?? ""} | ${escapeMarkdownCell(event.error ?? "")} |`)).join(`
+`);
+  const lines = [
+    `# ${title}`,
+    "",
+    `Status: **${report.status}** \xB7 State: **${report.state}**`,
+    "",
+    "| Metric | Value |",
+    "| --- | ---: |",
+    `| Input frames | ${report.inputFrames} |`,
+    `| Output frames | ${report.outputFrames} |`,
+    `| Backpressure events | ${report.backpressureEvents} |`,
+    `| Connected | ${report.connected ? "yes" : "no"} |`,
+    `| Closed | ${report.closed ? "yes" : "no"} |`,
+    `| Failed | ${report.failed ? "yes" : "no"} |`,
+    "",
+    `## Last ${events.length} event(s)`,
+    "",
+    eventRows
+  ];
+  return `${lines.join(`
+`)}
+`;
+};
+var renderMediaProcessorGraphMarkdown = (report, options = {}) => {
+  const title = options.title ?? `Media Processor Graph: ${report.name}`;
+  const limit = options.redact?.truncateArraysAt ?? DEFAULT_TRUNCATE;
+  const nodeRows = report.nodes.map((node) => `| ${escapeMarkdownCell(node.name)} | ${node.kind} | ${node.status} | ${node.inputFrames} | ${node.emittedFrames} | ${node.droppedFrames} | ${node.errors.length} |`).join(`
+`);
+  const edgeRows = report.edges.slice(0, limit).map((edge) => `| ${escapeMarkdownCell(edge.from)} | ${escapeMarkdownCell(edge.to)} | ${edge.status} | ${edge.emittedFrames} |`).join(`
+`);
+  const issues = report.errors.map((event) => ({
+    code: event.kind,
+    message: event.error ?? `Processor graph ${event.kind} (state ${event.state}).`,
+    severity: "error"
+  }));
+  const lines = [
+    `# ${title}`,
+    "",
+    `Status: **${report.status}** \xB7 State: **${report.state}**`,
+    "",
+    "| Metric | Value |",
+    "| --- | ---: |",
+    `| Nodes | ${report.nodes.length} |`,
+    `| Input frames | ${report.inputFrames} |`,
+    `| Emitted frames | ${report.emittedFrames} |`,
+    `| Dropped frames | ${report.droppedFrames} |`,
+    `| Lifecycle events | ${report.lifecycleEvents.length} |`,
+    `| Edge events | ${report.edgeEvents.length} |`,
+    `| Backpressure events | ${report.backpressure.events.length} |`,
+    `| Timing max | ${formatOptionalMs(report.timing.maxNodeMs)} |`,
+    `| Timing average | ${formatOptionalMs(report.timing.averageNodeMs)} |`,
+    "",
+    "## Nodes",
+    "",
+    nodeRows ? `| Node | Kind | Status | In | Out | Dropped | Errors |
+| --- | --- | --- | ---: | ---: | ---: | ---: |
+${nodeRows}` : "- No nodes.",
+    "",
+    `## Edges (showing up to ${limit})`,
+    "",
+    edgeRows ? `| From | To | Status | Frames |
+| --- | --- | --- | ---: |
+${edgeRows}` : "- No edges.",
+    "",
+    "## Errors",
+    "",
+    renderIssuesTable(issues).trimEnd()
+  ];
+  return `${lines.join(`
+`)}
+`;
+};
+var truncateArrays = (value, limit, seen) => {
+  if (Array.isArray(value)) {
+    const head = value.slice(0, limit).map((entry) => truncateArrays(entry, limit, seen));
+    if (value.length > limit) {
+      return [...head, { truncated: value.length - limit }];
+    }
+    return head;
+  }
+  if (value && typeof value === "object") {
+    if (seen.has(value))
+      return value;
+    seen.add(value);
+    const next = {};
+    for (const [key, entry] of Object.entries(value)) {
+      next[key] = truncateArrays(entry, limit, seen);
+    }
+    return next;
+  }
+  return value;
+};
+var applyRedaction = (value, options, seen) => {
+  const mode = options.mode ?? "omit";
+  const maskValue = options.maskValue ?? "[redacted]";
+  const allow = new Set(options.metadataAllow ?? []);
+  const deny = new Set(options.metadataDeny ?? DEFAULT_METADATA_DENY);
+  const walk = (input) => {
+    if (Array.isArray(input)) {
+      return input.map((entry) => walk(entry));
+    }
+    if (input && typeof input === "object") {
+      if (seen.has(input))
+        return input;
+      seen.add(input);
+      const next = {};
+      for (const [key, entry] of Object.entries(input)) {
+        if (allow.has(key)) {
+          next[key] = entry;
+          continue;
+        }
+        if (deny.has(key)) {
+          if (mode === "mask")
+            next[key] = maskValue;
+          continue;
+        }
+        next[key] = walk(entry);
+      }
+      return next;
+    }
+    return input;
+  };
+  return walk(value);
+};
+var redactMediaReport = (report, options = {}) => {
+  const limit = options.truncateArraysAt ?? DEFAULT_TRUNCATE;
+  const truncated = truncateArrays(report, limit, new WeakSet);
+  return applyRedaction(truncated, options, new WeakSet);
+};
+var buildArtifactPair = (report, summary, markdown, options) => {
+  const jsonValue = options.redact ? redactMediaReport(report, options.redact) : report;
+  return {
+    json: JSON.stringify(jsonValue, null, 2),
+    jsonValue,
+    markdown,
+    summary
+  };
+};
+var buildMediaQualityArtifact = (report, options = {}) => buildArtifactPair(report, summarizeMediaQualityReport(report), renderMediaQualityMarkdown(report, options), options);
+var buildMediaTransportArtifact = (report, options = {}) => buildArtifactPair(report, summarizeMediaTransportReport(report), renderMediaTransportMarkdown(report, options), options);
+var buildMediaProcessorGraphArtifact = (report, options = {}) => buildArtifactPair(report, summarizeMediaProcessorGraphReport(report), renderMediaProcessorGraphMarkdown(report, options), options);
+var writeMediaArtifact = async (input) => {
+  await mkdir(input.dir, { recursive: true });
+  const jsonPath = join(input.dir, `${input.slug}.json`);
+  const markdownPath = join(input.dir, `${input.slug}.md`);
+  await Promise.all([
+    writeFile(jsonPath, input.json, "utf8"),
+    writeFile(markdownPath, input.markdown, "utf8")
+  ]);
+  return {
+    jsonPath,
+    markdownPath,
+    summary: input.summary
+  };
+};
 
 // src/client/browserMedia.ts
 var DEFAULT_BROWSER_MEDIA_PATH = "/api/voice/browser-media";

package/dist/client/htmxBootstrap.js

@@ -244,6 +244,329 @@ var serverMessageToAction = (message) => {
   }
 };
 
+// node_modules/@absolutejs/media/dist/index.js
+var {mkdir, writeFile} = (() => ({}));
+
+// node:path
+function assertPath(path) {
+  if (typeof path !== "string")
+    throw TypeError("Path must be a string. Received " + JSON.stringify(path));
+}
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, code;
+  for (var i = 0;i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47)
+      break;
+    else
+      code = 47;
+    if (code === 47) {
+      if (lastSlash === i - 1 || dots === 1)
+        ;
+      else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1)
+                res = "", lastSegmentLength = 0;
+              else
+                res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              lastSlash = i, dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "", lastSegmentLength = 0, lastSlash = i, dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += "/..";
+          else
+            res = "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += "/" + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i, dots = 0;
+    } else if (code === 46 && dots !== -1)
+      ++dots;
+    else
+      dots = -1;
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root, base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir)
+    return base;
+  if (dir === pathObject.root)
+    return dir + base;
+  return dir + sep + base;
+}
+function resolve() {
+  var resolvedPath = "", resolvedAbsolute = false, cwd;
+  for (var i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+    var path;
+    if (i >= 0)
+      path = arguments[i];
+    else {
+      if (cwd === undefined)
+        cwd = process.cwd();
+      path = cwd;
+    }
+    if (assertPath(path), path.length === 0)
+      continue;
+    resolvedPath = path + "/" + resolvedPath, resolvedAbsolute = path.charCodeAt(0) === 47;
+  }
+  if (resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute), resolvedAbsolute)
+    if (resolvedPath.length > 0)
+      return "/" + resolvedPath;
+    else
+      return "/";
+  else if (resolvedPath.length > 0)
+    return resolvedPath;
+  else
+    return ".";
+}
+function normalize(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var isAbsolute = path.charCodeAt(0) === 47, trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+  if (path = normalizeStringPosix(path, !isAbsolute), path.length === 0 && !isAbsolute)
+    path = ".";
+  if (path.length > 0 && trailingSeparator)
+    path += "/";
+  if (isAbsolute)
+    return "/" + path;
+  return path;
+}
+function isAbsolute(path) {
+  return assertPath(path), path.length > 0 && path.charCodeAt(0) === 47;
+}
+function join() {
+  if (arguments.length === 0)
+    return ".";
+  var joined;
+  for (var i = 0;i < arguments.length; ++i) {
+    var arg = arguments[i];
+    if (assertPath(arg), arg.length > 0)
+      if (joined === undefined)
+        joined = arg;
+      else
+        joined += "/" + arg;
+  }
+  if (joined === undefined)
+    return ".";
+  return normalize(joined);
+}
+function relative(from, to) {
+  if (assertPath(from), assertPath(to), from === to)
+    return "";
+  if (from = resolve(from), to = resolve(to), from === to)
+    return "";
+  var fromStart = 1;
+  for (;fromStart < from.length; ++fromStart)
+    if (from.charCodeAt(fromStart) !== 47)
+      break;
+  var fromEnd = from.length, fromLen = fromEnd - fromStart, toStart = 1;
+  for (;toStart < to.length; ++toStart)
+    if (to.charCodeAt(toStart) !== 47)
+      break;
+  var toEnd = to.length, toLen = toEnd - toStart, length = fromLen < toLen ? fromLen : toLen, lastCommonSep = -1, i = 0;
+  for (;i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === 47)
+          return to.slice(toStart + i + 1);
+        else if (i === 0)
+          return to.slice(toStart + i);
+      } else if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === 47)
+          lastCommonSep = i;
+        else if (i === 0)
+          lastCommonSep = 0;
+      }
+      break;
+    }
+    var fromCode = from.charCodeAt(fromStart + i), toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode)
+      break;
+    else if (fromCode === 47)
+      lastCommonSep = i;
+  }
+  var out = "";
+  for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i)
+    if (i === fromEnd || from.charCodeAt(i) === 47)
+      if (out.length === 0)
+        out += "..";
+      else
+        out += "/..";
+  if (out.length > 0)
+    return out + to.slice(toStart + lastCommonSep);
+  else {
+    if (toStart += lastCommonSep, to.charCodeAt(toStart) === 47)
+      ++toStart;
+    return to.slice(toStart);
+  }
+}
+function _makeLong(path) {
+  return path;
+}
+function dirname(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var code = path.charCodeAt(0), hasRoot = code === 47, end = -1, matchedSlash = true;
+  for (var i = path.length - 1;i >= 1; --i)
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else
+      matchedSlash = false;
+  if (end === -1)
+    return hasRoot ? "/" : ".";
+  if (hasRoot && end === 1)
+    return "//";
+  return path.slice(0, end);
+}
+function basename(path, ext) {
+  if (ext !== undefined && typeof ext !== "string")
+    throw TypeError('"ext" argument must be a string');
+  assertPath(path);
+  var start = 0, end = -1, matchedSlash = true, i;
+  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path)
+      return "";
+    var extIdx = ext.length - 1, firstNonSlashEnd = -1;
+    for (i = path.length - 1;i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1)
+          matchedSlash = false, firstNonSlashEnd = i + 1;
+        if (extIdx >= 0)
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1)
+              end = i;
+          } else
+            extIdx = -1, end = firstNonSlashEnd;
+      }
+    }
+    if (start === end)
+      end = firstNonSlashEnd;
+    else if (end === -1)
+      end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (i = path.length - 1;i >= 0; --i)
+      if (path.charCodeAt(i) === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1)
+        matchedSlash = false, end = i + 1;
+    if (end === -1)
+      return "";
+    return path.slice(start, end);
+  }
+}
+function extname(path) {
+  assertPath(path);
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, preDotState = 0;
+  for (var i = path.length - 1;i >= 0; --i) {
+    var code = path.charCodeAt(i);
+    if (code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+    return "";
+  return path.slice(startDot, end);
+}
+function format(pathObject) {
+  if (pathObject === null || typeof pathObject !== "object")
+    throw TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+  return _format("/", pathObject);
+}
+function parse(path) {
+  assertPath(path);
+  var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+  if (path.length === 0)
+    return ret;
+  var code = path.charCodeAt(0), isAbsolute2 = code === 47, start;
+  if (isAbsolute2)
+    ret.root = "/", start = 1;
+  else
+    start = 0;
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, i = path.length - 1, preDotState = 0;
+  for (;i >= start; --i) {
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    if (end !== -1)
+      if (startPart === 0 && isAbsolute2)
+        ret.base = ret.name = path.slice(1, end);
+      else
+        ret.base = ret.name = path.slice(startPart, end);
+  } else {
+    if (startPart === 0 && isAbsolute2)
+      ret.name = path.slice(1, startDot), ret.base = path.slice(1, end);
+    else
+      ret.name = path.slice(startPart, startDot), ret.base = path.slice(startPart, end);
+    ret.ext = path.slice(startDot, end);
+  }
+  if (startPart > 0)
+    ret.dir = path.slice(0, startPart - 1);
+  else if (isAbsolute2)
+    ret.dir = "/";
+  return ret;
+}
+var sep = "/";
+var delimiter = ":";
+var posix = ((p) => (p.posix = p, p))({ resolve, normalize, isAbsolute, join, relative, _makeLong, dirname, basename, extname, format, parse, sep, delimiter, win32: null, posix: null });
+
 // node_modules/@absolutejs/media/dist/index.js
 var pushIssue = (issues, severity, code, message) => {
   issues.push({ code, message, severity });
@@ -1518,15 +1841,15 @@ var getAudioContextCtor = () => {
   return window.AudioContext ?? window.webkitAudioContext;
 };
 var decodePCM16LEChunk = (audioContext, chunk) => {
-  const format = chunk.format;
-  if (format.container !== "raw" || format.encoding !== "pcm_s16le") {
-    throw new Error(`Unsupported assistant audio format: ${format.container}/${format.encoding}`);
+  const format2 = chunk.format;
+  if (format2.container !== "raw" || format2.encoding !== "pcm_s16le") {
+    throw new Error(`Unsupported assistant audio format: ${format2.container}/${format2.encoding}`);
   }
   const bytes = chunk.chunk;
-  const channels = Math.max(1, format.channels);
+  const channels = Math.max(1, format2.channels);
   const sampleCount = Math.floor(bytes.byteLength / 2);
   const frameCount = Math.max(1, Math.floor(sampleCount / channels));
-  const audioBuffer = audioContext.createBuffer(channels, frameCount, format.sampleRateHz);
+  const audioBuffer = audioContext.createBuffer(channels, frameCount, format2.sampleRateHz);
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   for (let channelIndex = 0;channelIndex < channels; channelIndex += 1) {
     const channelData = audioBuffer.getChannelData(channelIndex);
@@ -1769,8 +2092,8 @@ var createVoiceAudioPlayer = (source, options = {}) => {
         return;
       }
       if (!interruptPromise) {
-        interruptPromise = new Promise((resolve) => {
-          resolveInterruptPromise = resolve;
+        interruptPromise = new Promise((resolve2) => {
+          resolveInterruptPromise = resolve2;
         });
       }
       clearInterruptTimer();