hyperframes 0.8.138 → 0.8.140

package/dist/{chunk-IC5L6L7K.js → chunk-TYT2TLJR.js}

@@ -15,7 +15,7 @@ import {
 } from "./chunk-PBN6GBJE.js";
 import {
   parseFps
-} from "./chunk-RLNB3JCY.js";
+} from "./chunk-QP3BRKGF.js";
 
 // src/browser/windowsCrash.ts
 var STATUS_STACK_BUFFER_OVERRUN_DEC = "3221225595";

package/dist/{chunk-ASPTQ6DT.js → chunk-U7E736AJ.js}

@@ -8,7 +8,7 @@ import {
   MAX_AUDIO_GAIN_DB,
   formatAudioGain,
   isAudibleVideoElement
-} from "./chunk-UINDCCO7.js";
+} from "./chunk-YA62XGXS.js";
 import {
   findFfBinary
 } from "./chunk-PJ3HDUCY.js";

package/dist/chunk-UOFAE5RF.js

@@ -0,0 +1,42 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+
+// src/whisper/wav.ts
+import { readFileSync } from "fs";
+function findWavChunk(buf, want) {
+  if (buf.length < 12) return null;
+  let pos = 12;
+  while (pos + 8 <= buf.length) {
+    const id = buf.toString("ascii", pos, pos + 4);
+    const size = buf.readUInt32LE(pos + 4);
+    if (id === want) return { offset: pos + 8, size: Math.min(size, buf.length - pos - 8) };
+    pos += 8 + size;
+    if (size % 2 !== 0) pos++;
+  }
+  return null;
+}
+var PCM = 1;
+var EXTENSIBLE = 65534;
+function readWav(path) {
+  const buf = readFileSync(path);
+  const riff = buf.toString("ascii", 0, 4) === "RIFF" && buf.toString("ascii", 8, 12) === "WAVE";
+  const fmt = riff ? findWavChunk(buf, "fmt ") : null;
+  const data = fmt && findWavChunk(buf, "data");
+  const format = fmt && buf.readUInt16LE(fmt.offset);
+  if (!fmt || !data || format !== PCM && format !== EXTENSIBLE || buf.readUInt16LE(fmt.offset + 2) !== 1 || buf.readUInt16LE(fmt.offset + 14) !== 16) {
+    throw new Error(`${path} is not a 16-bit mono PCM WAV`);
+  }
+  const samples = new Float32Array(data.size >> 1);
+  for (let i = 0; i < samples.length; i++)
+    samples[i] = buf.readInt16LE(data.offset + 2 * i) / 32768;
+  return { samples, sampleRate: buf.readUInt32LE(fmt.offset + 4) };
+}
+
+export {
+  findWavChunk,
+  readWav
+};

package/dist/chunk-USDEMXXL.js

@@ -0,0 +1,110 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+
+// ../engine/src/services/systemMemory.ts
+import { readFileSync } from "fs";
+import { totalmem } from "os";
+var BYTES_PER_MIB = 1024 * 1024;
+var BYTES_PER_MIB_BIGINT = BigInt(BYTES_PER_MIB);
+var CGROUP_V2_MEMORY_MAX_PATH = "/sys/fs/cgroup/memory.max";
+var CGROUP_V1_MEMORY_LIMIT_PATH = "/sys/fs/cgroup/memory/memory.limit_in_bytes";
+var CGROUP_V1_NO_LIMIT_CUTOFF_BYTES = 2n ** 60n;
+var _cachedCgroupLimitMb;
+var _warnedCgroupReadFailure = false;
+function parseCgroupLimitMb(v2Content, v1Content) {
+  if (v2Content !== null) {
+    return parseCgroupV2LimitMb(v2Content);
+  }
+  return parseCgroupV1LimitMb(v1Content);
+}
+function parseCgroupV2LimitMb(content) {
+  const trimmed = content.trim();
+  if (trimmed === "max") {
+    return null;
+  }
+  return parsePositiveByteLimitMb(trimmed);
+}
+function parseCgroupV1LimitMb(content) {
+  if (content === null) {
+    return null;
+  }
+  return parsePositiveByteLimitMb(content.trim(), CGROUP_V1_NO_LIMIT_CUTOFF_BYTES);
+}
+function parsePositiveByteLimitMb(content, noLimitCutoffBytes) {
+  if (!/^\d+$/.test(content)) {
+    return null;
+  }
+  const bytes = BigInt(content);
+  if (bytes <= 0n) {
+    return null;
+  }
+  if (noLimitCutoffBytes !== void 0 && bytes >= noLimitCutoffBytes) {
+    return null;
+  }
+  return Number(bytes / BYTES_PER_MIB_BIGINT);
+}
+function getCgroupMemoryLimitMb() {
+  if (_cachedCgroupLimitMb !== void 0) return _cachedCgroupLimitMb;
+  if (process.platform !== "linux") {
+    _cachedCgroupLimitMb = null;
+    return null;
+  }
+  const v2Content = readCgroupFile(CGROUP_V2_MEMORY_MAX_PATH);
+  const v1Content = v2Content === null ? readCgroupFile(CGROUP_V1_MEMORY_LIMIT_PATH) : null;
+  _cachedCgroupLimitMb = parseCgroupLimitMb(v2Content, v1Content);
+  if (_cachedCgroupLimitMb !== null) {
+    console.warn(
+      `[SystemMemory] cgroup memory limit detected: ${_cachedCgroupLimitMb} MiB \u2014 it governs memory-adaptive render behaviour instead of host RAM.`
+    );
+  }
+  return _cachedCgroupLimitMb;
+}
+function readCgroupFile(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch (error) {
+    const code = getErrorCode(error);
+    if (code !== "ENOENT" && code !== "ENOTDIR") {
+      warnCgroupReadFailure(path, error);
+    }
+    return null;
+  }
+}
+function getErrorCode(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) {
+    return void 0;
+  }
+  return typeof error.code === "string" ? error.code : void 0;
+}
+function formatCgroupReadError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const code = getErrorCode(error);
+  return code ? `${code}: ${message}` : message;
+}
+function warnCgroupReadFailure(path, error) {
+  if (_warnedCgroupReadFailure) return;
+  _warnedCgroupReadFailure = true;
+  console.warn(
+    `[SystemMemory] Unable to read cgroup memory limit at ${path} (${formatCgroupReadError(error)}); falling back to host RAM.`
+  );
+}
+function getSystemTotalMb() {
+  const hostTotalMb = Math.floor(totalmem() / BYTES_PER_MIB);
+  const cgroupLimitMb = getCgroupMemoryLimitMb();
+  return cgroupLimitMb === null ? hostTotalMb : Math.min(hostTotalMb, cgroupLimitMb);
+}
+var LOW_MEMORY_TOTAL_MB_THRESHOLD = 8192;
+function isLowMemorySystem(totalMb = getSystemTotalMb()) {
+  return totalMb <= LOW_MEMORY_TOTAL_MB_THRESHOLD;
+}
+
+export {
+  getCgroupMemoryLimitMb,
+  getSystemTotalMb,
+  LOW_MEMORY_TOTAL_MB_THRESHOLD,
+  isLowMemorySystem
+};

package/dist/{chunk-5K33TNUJ.js → chunk-VVJFZU6B.js}

@@ -8,14 +8,14 @@ import {
   DEFAULT_REGISTRY_URL,
   fetchItemFile,
   validRegistryItem
-} from "./chunk-KRLYIT22.js";
+} from "./chunk-5IKJONRY.js";
 import {
   publishRegistryFile,
   registryTargetPath
 } from "./chunk-GMECXFAN.js";
 import {
   validateVariables
-} from "./chunk-RLNB3JCY.js";
+} from "./chunk-QP3BRKGF.js";
 import {
   realProjectRoot
 } from "./chunk-OFQWTKPW.js";

package/dist/{chunk-XQODEVF3.js → chunk-WKTHUC2R.js}

@@ -1278,7 +1278,7 @@ async function withFigmaErrors(command, fn) {
   } catch (err) {
     if (err instanceof Error) {
       try {
-        const { trackCommandFailure } = await import("./events-RCGWL4LI.js");
+        const { trackCommandFailure } = await import("./events-7VJJGC3D.js");
         trackCommandFailure(
           command,
           err,

package/dist/{chunk-7OLMGFDN.js → chunk-WQBA3MH4.js}

@@ -7,14 +7,14 @@ var __dirname = __hf_dirname(__filename);
 import {
   trackLintReport,
   trackLintRuleStreak
-} from "./chunk-WH6PRFNX.js";
+} from "./chunk-JSGANFFH.js";
 import {
   shouldTrack
-} from "./chunk-VR5UQWGV.js";
+} from "./chunk-C2JUHIG5.js";
 import {
   LINT_RULE_COUNT,
   LINT_RULE_GROUP_COUNTS
-} from "./chunk-STA43FMY.js";
+} from "./chunk-WY5OODN5.js";
 
 // src/telemetry/lintStreaks.ts
 import { createHash } from "crypto";