hyperframes 0.8.186 → 0.8.189

package/dist/{chunk-5ZMIVTHN.js → chunk-BZQLTNMB.js}

@@ -13,7 +13,7 @@ import {
   formatPreviewProxyBox,
   hdrToSdrToneMapFilter,
   parseFirstFrameColour
-} from "./chunk-RNZEQTWZ.js";
+} from "./chunk-WYCFMNU3.js";
 import {
   decodeAuthoredAttribute,
   scanHtmlOpeningTags
@@ -36,7 +36,7 @@ import {
   rewriteAssetPath
 } from "./chunk-BSQ7XANM.js";
 
-// ../studio-server/dist/chunk-OVOXGASQ.js
+// ../studio-server/dist/chunk-XMNHDWQI.js
 import { statSync } from "fs";
 import { sep } from "path";
 import { execFile } from "child_process";
@@ -139,7 +139,7 @@ async function probeMediaMetadata(filePath, runner = execFileRunner) {
       "-v",
       "error",
       "-show_entries",
-      "stream=codec_type,codec_name,profile,pix_fmt,color_space,color_transfer,color_primaries,bits_per_raw_sample:stream_disposition=attached_pic:stream_tags=alpha_mode",
+      "stream=codec_type,codec_name,profile,pix_fmt,color_space,color_transfer,color_primaries,bits_per_raw_sample:stream_disposition=attached_pic:stream_tags=alpha_mode:format=duration",
       "-of",
       "json",
       "--",
@@ -163,6 +163,8 @@ async function probeMediaMetadata(filePath, runner = execFileRunner) {
     if (kind === "video") {
       metadata.hasAudio = (parsed.streams ?? []).some((item) => item.codec_type === "audio");
       metadata.hasAlpha = stream !== void 0 && videoStreamHasAlpha(stream);
+      const duration = Number(parsed.format?.duration);
+      if (Number.isFinite(duration) && duration > 0) metadata.durationSeconds = duration;
     }
     return metadata;
   } catch {
@@ -338,13 +340,23 @@ async function scanProjectMediaCodecMap(projectDir, htmlSources, options = {}) {
   return map;
 }
 
-// ../studio-server/dist/chunk-25IT6FMR.js
+// ../studio-server/dist/chunk-N2HH4SGD.js
 import { spawn } from "child_process";
 import { createHash, randomUUID } from "crypto";
-import { existsSync as existsSync2, renameSync, statSync as statSync2, unlinkSync as unlinkSync2, utimesSync } from "fs";
-import { basename, dirname, isAbsolute, join as join2, relative, resolve, sep as sep2 } from "path";
+import {
+  existsSync as existsSync2,
+  mkdtempSync,
+  renameSync,
+  rmSync,
+  statSync as statSync2,
+  unlinkSync as unlinkSync2,
+  utimesSync,
+  writeFileSync
+} from "fs";
+import { tmpdir } from "os";
+import { basename, dirname, extname as extname2, isAbsolute, join as join2, relative, resolve, sep as sep2 } from "path";
 import { existsSync, readdirSync, statSync as statSync3, unlinkSync } from "fs";
-import { extname as extname2, join } from "path";
+import { extname as extname3, join } from "path";
 var DEFAULT_MAX_BYTES = 10 * 1024 * 1024 * 1024;
 var DEFAULT_STALE_TEMP_MS = 60 * 60 * 1e3;
 var DEFAULT_MIN_SWEEP_INTERVAL_MS = 5 * 60 * 1e3;
@@ -352,7 +364,9 @@ var PROXY_EXTENSIONS = new Set(
   Object.values(PROXY_VARIANT_CONFIG).map(({ extension }) => extension)
 );
 var TRANSCODER_PROXY_NAME = /^[0-9a-f]{64}\.\w+$/;
-var TRANSCODER_TEMP_NAME = /^\.tmp-[0-9a-f-]{36}-[0-9a-f]{64}\.\w+$/;
+var TRANSCODER_TEMP_NAME = /^\.tmp-[0-9a-f-]{36}-(?:\.part-[0-9a-f]{64}-\d+|[0-9a-f]{64})\.\w+$/;
+var TRANSCODER_PIECE_NAME = /^\.part-([0-9a-f]{64})-\d+(\.\w+)$/;
+var STALE_PIECE_MS = 60 * 60 * 1e3;
 var lastSweepAt = /* @__PURE__ */ new Map();
 function positiveEnvNumber(name, fallback) {
   const parsed = Number(process.env[name]);
@@ -375,6 +389,15 @@ function shouldSkipSweep(cacheDir, now, minSweepIntervalMs) {
   lastSweepAt.set(cacheDir, now);
   return false;
 }
+function isLeftoverName(name) {
+  return TRANSCODER_TEMP_NAME.test(name) || TRANSCODER_PIECE_NAME.test(name);
+}
+function leftoverIsDead(cacheDir, name, modifiedAt, protectedPaths, now, staleTempMs) {
+  const piece = TRANSCODER_PIECE_NAME.exec(name);
+  if (!piece) return now - modifiedAt >= staleTempMs;
+  const copyIsRunning = protectedPaths.has(join(cacheDir, `${piece[1]}${piece[2]}`));
+  return !copyIsRunning && now - modifiedAt >= STALE_PIECE_MS;
+}
 function readCacheInventory(cacheDir, protectedPaths, now, staleTempMs) {
   const entries = [];
   const staleTemps = [];
@@ -388,9 +411,11 @@ function readCacheInventory(cacheDir, protectedPaths, now, staleTempMs) {
       modifiedAt: stat.mtimeMs,
       protected: protectedPaths.has(path)
     };
-    if (TRANSCODER_TEMP_NAME.test(dirent.name)) {
-      if (now - stat.mtimeMs >= staleTempMs) staleTemps.push(entry);
-    } else if (TRANSCODER_PROXY_NAME.test(dirent.name) && PROXY_EXTENSIONS.has(extname2(dirent.name))) {
+    if (isLeftoverName(dirent.name)) {
+      if (leftoverIsDead(cacheDir, dirent.name, stat.mtimeMs, protectedPaths, now, staleTempMs)) {
+        staleTemps.push(entry);
+      }
+    } else if (TRANSCODER_PROXY_NAME.test(dirent.name) && PROXY_EXTENSIONS.has(extname3(dirent.name))) {
       entries.push(entry);
     }
   }
@@ -452,11 +477,15 @@ var MAX_CONCURRENT_TRANSCODES = boundedEnvInteger("HYPERFRAMES_PROXY_MAX_CONCURR
 var MAX_QUEUED_TRANSCODES = boundedEnvInteger("HYPERFRAMES_PROXY_MAX_QUEUE", 8, 0, 256);
 var STDERR_TAIL_MAX_CHARS = 4e3;
 var TRANSCODE_TIMEOUT_MS = 15 * 60 * 1e3;
+var PROXY_CHUNK_SECONDS = 60;
+var CHUNK_PREFIX = ".part-";
+var CONCAT_TIMEOUT_MS = 2 * 60 * 1e3;
 var FAILURE_CACHE_TTL_MS = 60 * 1e3;
 var PROXY_PENDING_RETRY_AFTER_SECONDS = 2;
 var ENVIRONMENT_FAILURE_TTL_MS = 5 * PROXY_PENDING_RETRY_AFTER_SECONDS * 1e3;
 var MAX_FAILURE_CACHE_ENTRIES = 128;
 var DEFAULT_PROXY_WAIT_TIMEOUT_MS = 2 * 60 * 1e3;
+var UNTOUCHED_TEMP_IS_DEAD_MS = 10 * 60 * 1e3;
 var ProxyTranscodeError = class extends Error {
   exitCode;
   stderrTail;
@@ -624,9 +653,9 @@ var inFlight = /* @__PURE__ */ new Map();
 function forget(job) {
   if (inFlight.get(job.cachePath)?.job === job) inFlight.delete(job.cachePath);
 }
-function maintainProxyCache(cacheDir) {
+function maintainProxyCache(cacheDir, staleTempMs) {
   try {
-    cleanupProxyCache(cacheDir, { protectedPaths: new Set(inFlight.keys()) });
+    cleanupProxyCache(cacheDir, { protectedPaths: new Set(inFlight.keys()), staleTempMs });
   } catch (error) {
     console.warn(
       `[media-proxy] cache cleanup failed: ${error instanceof Error ? error.message : String(error)}`
@@ -688,83 +717,173 @@ function stderrReason(stderrTail) {
   const line = errorLines.at(-1) ?? lines.at(-1);
   return line ? `: ${line.replace(/[.!]+$/, "")}` : "";
 }
-async function runFfmpeg(sourcePath, outputPath, variant, box, signal) {
-  const metadata = await probeMediaMetadata(sourcePath);
-  const ffmpegPath = findFfBinary("ffmpeg", { configuredMustExist: true });
-  if (!ffmpegPath) {
-    throw new FfmpegUnavailableError();
+function chunkRanges(durationSeconds) {
+  if (!durationSeconds || durationSeconds <= PROXY_CHUNK_SECONDS * 1.5) return null;
+  const count = Math.floor(durationSeconds / PROXY_CHUNK_SECONDS);
+  return Array.from({ length: count }, (_, index) => ({
+    startSeconds: index * PROXY_CHUNK_SECONDS,
+    lengthSeconds: index === count - 1 ? durationSeconds - index * PROXY_CHUNK_SECONDS : PROXY_CHUNK_SECONDS
+  }));
+}
+function ffmpegBudgetError(chunksKept, chunkCount) {
+  return new ProxyTranscodeError(
+    `ffmpeg ran out of its ${TRANSCODE_TIMEOUT_MS}ms budget with ${chunksKept}/${chunkCount} pieces done; the finished pieces are kept and the next attempt continues from them`,
+    null,
+    ""
+  );
+}
+async function encodeInChunks(ranges, chunkPrefix, tempPath, encode, concat) {
+  const extension = extname2(tempPath);
+  const deadline = Date.now() + TRANSCODE_TIMEOUT_MS;
+  const pieces = ranges.map((_, index) => `${chunkPrefix}${index}${extension}`);
+  for (const [index, range] of ranges.entries()) {
+    const piece = pieces[index];
+    if (existsSync2(piece)) continue;
+    const timeoutMs = deadline - Date.now();
+    if (timeoutMs <= 0) throw ffmpegBudgetError(index, ranges.length);
+    const pieceTemp = join2(dirname(piece), `.tmp-${randomUUID()}-${basename(piece)}`);
+    try {
+      await encode(pieceTemp, timeoutMs, range);
+      renameSync(pieceTemp, piece);
+    } finally {
+      if (existsSync2(pieceTemp)) unlinkSync2(pieceTemp);
+    }
   }
-  const keepsAlpha = variant === "vp8";
+  const listDir = mkdtempSync(join2(tmpdir(), "hf-proxy-join-"));
+  try {
+    const listPath = join2(listDir, "pieces.txt");
+    writeFileSync(
+      listPath,
+      pieces.map((piece) => `file '${piece.replace(/\\/g, "/").replace(/'/g, "'\\''")}'
+`).join("")
+    );
+    await concat(listPath, tempPath);
+  } finally {
+    rmSync(listDir, { recursive: true, force: true });
+  }
+  for (const piece of pieces) if (existsSync2(piece)) unlinkSync2(piece);
+}
+var H264_ARGS = [
+  "-c:v",
+  "libx264",
+  "-profile:v",
+  "high",
+  "-pix_fmt",
+  "yuv420p",
+  "-colorspace",
+  "bt709",
+  "-color_primaries",
+  "bt709",
+  "-color_trc",
+  "bt709",
+  "-crf",
+  "18",
+  "-preset",
+  "veryfast",
+  "-c:a",
+  "aac",
+  "-movflags",
+  "+faststart"
+];
+var VP8_ARGS = [
+  "-c:v",
+  "libvpx",
+  "-b:v",
+  "0",
+  "-crf",
+  "23",
+  "-deadline",
+  "good",
+  "-pix_fmt",
+  "yuva420p",
+  "-colorspace",
+  "bt709",
+  "-color_primaries",
+  "bt709",
+  "-color_trc",
+  "bt709",
+  "-cpu-used",
+  "4",
+  "-auto-alt-ref",
+  "0",
+  "-metadata:s:v:0",
+  "alpha_mode=1",
+  "-ac",
+  "2",
+  "-c:a",
+  "libopus"
+];
+async function buildVideoFilter(ffmpegPath, sourcePath, metadata, keepsAlpha, box) {
   const { hdrTransfer } = metadata.color;
   const toneMap = (hdrTransfer === "pq" || hdrTransfer === "hlg") && !keepsAlpha;
   if (toneMap) await ensureHdrFilters(ffmpegPath);
   const firstFrame = toneMap ? await probeFirstFrameColour(sourcePath) : {};
   const evenScale = proxyScaleFilter(box);
   const pixelFormat = keepsAlpha ? "yuva420p" : "yuv420p";
-  const videoFilter = toneMap ? [
+  return toneMap ? [
     hdrToSdrToneMapFilter(metadata.color, firstFrame),
     `${evenScale}:out_color_matrix=bt709:out_range=tv`,
     `format=${pixelFormat}`
   ].join(",") : [evenScale, `format=${pixelFormat}`].join(",");
+}
+async function runFfmpeg(sourcePath, outputPath, chunkPrefix, variant, box, signal) {
+  const metadata = await probeMediaMetadata(sourcePath);
+  const ffmpegPath = findFfBinary("ffmpeg", { configuredMustExist: true });
+  if (!ffmpegPath) {
+    throw new FfmpegUnavailableError();
+  }
+  const keepsAlpha = variant === "vp8";
+  const videoFilter = await buildVideoFilter(ffmpegPath, sourcePath, metadata, keepsAlpha, box);
+  const alphaDecoder = keepsAlpha ? alphaDecoderFor(metadata.color.codecName) : null;
+  const decoderArgs = alphaDecoder ? ["-c:v", alphaDecoder] : [];
+  const encode = (target, timeoutMs, range) => spawnFfmpeg(
+    ffmpegPath,
+    [
+      "-y",
+      ...range ? ["-ss", String(range.startSeconds)] : [],
+      ...decoderArgs,
+      "-i",
+      sourcePath,
+      ...range ? ["-t", String(range.lengthSeconds)] : [],
+      "-vf",
+      videoFilter,
+      ...variant === "vp8" ? VP8_ARGS : H264_ARGS,
+      target
+    ],
+    timeoutMs,
+    signal
+  );
+  const ranges = chunkRanges(metadata.durationSeconds);
+  if (!ranges) return encode(outputPath, TRANSCODE_TIMEOUT_MS);
+  await encodeInChunks(
+    ranges,
+    chunkPrefix,
+    outputPath,
+    encode,
+    (listPath, target) => spawnFfmpeg(ffmpegPath, concatArgs(listPath, target, variant), CONCAT_TIMEOUT_MS, signal)
+  );
+}
+function concatArgs(listPath, target, variant) {
+  return [
+    "-y",
+    "-f",
+    "concat",
+    "-safe",
+    "0",
+    "-i",
+    listPath,
+    "-c",
+    "copy",
+    ...variant === "h264" ? ["-movflags", "+faststart"] : [],
+    target
+  ];
+}
+function spawnFfmpeg(ffmpegPath, args, timeoutMs, signal) {
   return new Promise((resolvePromise, reject) => {
-    const alphaDecoder = keepsAlpha ? alphaDecoderFor(metadata.color.codecName) : null;
-    const decoderArgs = alphaDecoder ? ["-c:v", alphaDecoder] : [];
-    const commonArgs = ["-y", ...decoderArgs, "-i", sourcePath, "-vf", videoFilter];
-    const h264Args = [
-      "-c:v",
-      "libx264",
-      "-profile:v",
-      "high",
-      "-pix_fmt",
-      "yuv420p",
-      "-colorspace",
-      "bt709",
-      "-color_primaries",
-      "bt709",
-      "-color_trc",
-      "bt709",
-      "-crf",
-      "18",
-      "-preset",
-      "veryfast",
-      "-c:a",
-      "aac",
-      "-movflags",
-      "+faststart"
-    ];
-    const vp8Args = [
-      "-c:v",
-      "libvpx",
-      "-b:v",
-      "0",
-      "-crf",
-      "23",
-      "-deadline",
-      "good",
-      "-pix_fmt",
-      "yuva420p",
-      "-colorspace",
-      "bt709",
-      "-color_primaries",
-      "bt709",
-      "-color_trc",
-      "bt709",
-      "-cpu-used",
-      "4",
-      "-auto-alt-ref",
-      "0",
-      "-metadata:s:v:0",
-      "alpha_mode=1",
-      "-ac",
-      "2",
-      "-c:a",
-      "libopus"
-    ];
-    const args = [...commonArgs, ...variant === "vp8" ? vp8Args : h264Args, outputPath];
     signal.throwIfAborted();
     const proc = spawn(ffmpegPath, args, {
       stdio: ["ignore", "ignore", "pipe"],
-      timeout: TRANSCODE_TIMEOUT_MS,
+      timeout: timeoutMs,
       killSignal: "SIGKILL",
       signal,
       windowsHide: true
@@ -783,7 +902,7 @@ async function runFfmpeg(sourcePath, outputPath, variant, box, signal) {
       } else if (signal2) {
         reject(
           new ProxyTranscodeError(
-            `ffmpeg killed by ${signal2} (timeout ${TRANSCODE_TIMEOUT_MS}ms or external kill)`,
+            `ffmpeg killed by ${signal2} (timeout ${timeoutMs}ms or external kill)`,
             null,
             stderrTail
           )
@@ -808,7 +927,18 @@ async function transcodeToCache(job, projectDir, absoluteSourcePath, cachePath,
     mkdirWithinProject(projectDir, cacheDir);
     const tempPath = join2(cacheDir, `.tmp-${randomUUID()}-${basename(cachePath)}`);
     try {
-      await runFfmpeg(absoluteSourcePath, tempPath, variant, box, job.abandoned.signal);
+      const chunkPrefix = join2(
+        cacheDir,
+        `${CHUNK_PREFIX}${basename(cachePath, extname2(cachePath))}-`
+      );
+      await runFfmpeg(
+        absoluteSourcePath,
+        tempPath,
+        chunkPrefix,
+        variant,
+        box,
+        job.abandoned.signal
+      );
       renameSync(tempPath, cachePath);
       maintainProxyCache(cacheDir);
       return cachePath;
@@ -876,13 +1006,23 @@ async function resolveProxy(projectDir, absoluteSourcePath, variant = "h264", bo
 }
 async function resolveProxies(projectDir, sources, onSettled = () => {
 }) {
+  const first = sources[0];
+  if (first) {
+    maintainProxyCache(
+      dirname(getProxyCachePath(projectDir, first.sourcePath, first.variant)),
+      Math.min(
+        Number(process.env.HYPERFRAMES_PROXY_CACHE_STALE_TEMP_MS) || UNTOUCHED_TEMP_IS_DEAD_MS,
+        UNTOUCHED_TEMP_IS_DEAD_MS
+      )
+    );
+  }
   const results = [];
   let next = 0;
   const worker = async () => {
     for (let index = next++; index < sources.length; index = next++) {
-      const { sourcePath, variant } = sources[index];
+      const { sourcePath, variant, box } = sources[index];
       results[index] = await waitForProxy(
-        resolveProxy(projectDir, sourcePath, variant),
+        resolveProxy(projectDir, sourcePath, variant, box),
         TRANSCODE_TIMEOUT_MS
       ).then(
         (value) => ({ status: "fulfilled", value }),

package/dist/{chunk-MY6CVBDD.js → chunk-CE7EQUBV.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   HyperframesApiError
-} from "./chunk-5UBZPG74.js";
+} from "./chunk-6A45RKAK.js";
 
 // src/cloud/upload.ts
 import { createHash } from "crypto";

package/dist/{chunk-ZVBEGBII.js → chunk-CSYSEPWL.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 import {
   getMimeType,
   injectMediaCodecMapIntoHtml
-} from "./chunk-2PZZMAME.js";
+} from "./chunk-ZPMF6GAQ.js";
 import {
   PROXY_VARIANT_CONFIG,
   ProxyCapacityError,
@@ -18,10 +18,17 @@ import {
   recordProxyRequest,
   resolveProxy,
   resolveProxyVariantRequest
-} from "./chunk-5ZMIVTHN.js";
+} from "./chunk-BZQLTNMB.js";
+import {
+  findStageProxyBox
+} from "./chunk-SGFMCNLY.js";
 import {
   resolveAutoProxy
-} from "./chunk-RPUIMFHF.js";
+} from "./chunk-Z2BW2WJS.js";
+import {
+  PREVIEW_PROXY_BOX_PARAM,
+  parsePreviewProxyBox
+} from "./chunk-WYCFMNU3.js";
 import {
   decodeWellFormedEscapes
 } from "./chunk-BSQ7XANM.js";
@@ -141,7 +148,7 @@ function writeProxyError(err, res) {
   res.writeHead(500);
   res.end();
 }
-async function serveProxyRequest(projectDir, filePath, request, autoProxy, rangeHeader, res, signal) {
+async function serveProxyRequest(projectDir, filePath, request, box, autoProxy, rangeHeader, res, signal) {
   const contentType = getMimeType(filePath);
   if (!autoProxy || !contentType.startsWith("video/")) {
     res.writeHead(404);
@@ -168,7 +175,7 @@ async function serveProxyRequest(projectDir, filePath, request, autoProxy, range
       return;
     }
     recordProxyRequest();
-    const proxyPath = await resolveProxy(projectDir, filePath, variant, void 0, { signal });
+    const proxyPath = await resolveProxy(projectDir, filePath, variant, box, { signal });
     if (res.writableEnded || res.destroyed) return;
     serveFileWithRange(proxyPath, rangeHeader, res, PROXY_VARIANT_CONFIG[variant].contentType);
   } catch (err) {
@@ -179,7 +186,15 @@ async function serveStaticProjectHtml(projectDir, html, bindErrorMessage = "Fail
   const roots = [projectDir, ...assetRoots];
   const autoProxy = resolveAutoProxy(projectDir, autoProxyOverride);
   const copies = new AbortController();
-  const servedHtml = autoProxy ? await injectMediaCodecMapIntoHtml(html, projectDir, [{ html }], void 0, true, copies.signal) : html;
+  const servedHtml = autoProxy ? await injectMediaCodecMapIntoHtml(
+    html,
+    projectDir,
+    [{ html }],
+    void 0,
+    true,
+    copies.signal,
+    findStageProxyBox(html)
+  ) : html;
   const server = createServer((req, res) => {
     const url = req.url ?? "/";
     if (url === "/" || url === "/index.html") {
@@ -189,8 +204,16 @@ async function serveStaticProjectHtml(projectDir, html, bindErrorMessage = "Fail
     }
     const queryIndex = url.indexOf("?");
     const pathOnly = queryIndex === -1 ? url : url.slice(0, queryIndex);
-    const proxyParam = queryIndex === -1 ? null : new URLSearchParams(url.slice(queryIndex + 1)).get("hf-proxy");
+    const query = new URLSearchParams(queryIndex === -1 ? "" : url.slice(queryIndex + 1));
+    const proxyParam = query.get("hf-proxy");
     const proxyRequest = proxyParam !== null && isProxyVariantRequest(proxyParam) ? proxyParam : null;
+    const boxParam = query.get(PREVIEW_PROXY_BOX_PARAM);
+    const proxyBox = boxParam === null ? void 0 : parsePreviewProxyBox(boxParam);
+    if (proxyBox === null || proxyBox && !proxyRequest) {
+      res.writeHead(404);
+      res.end();
+      return;
+    }
     const requestPath = decodeWellFormedEscapes(pathOnly).replace(/^\//, "");
     for (const root of roots) {
       const filePath = resolve(root, requestPath);
@@ -202,6 +225,7 @@ async function serveStaticProjectHtml(projectDir, html, bindErrorMessage = "Fail
             projectDir,
             filePath,
             proxyRequest,
+            proxyBox,
             autoProxy,
             req.headers.range,
             res,

package/dist/{chunk-EZINX6HH.js → chunk-CTF7BYCV.js}

@@ -7,14 +7,14 @@ var __dirname = __hf_dirname(__filename);
 import {
   trackLintReport,
   trackLintRuleStreak
-} from "./chunk-77QM6YRQ.js";
+} from "./chunk-IPEP346Y.js";
 import {
   shouldTrack
-} from "./chunk-6IOBAOU7.js";
+} from "./chunk-T37XXYRK.js";
 import {
   LINT_RULE_COUNT,
   LINT_RULE_GROUP_COUNTS
-} from "./chunk-Q447CX26.js";
+} from "./chunk-TSFA2Y5C.js";
 
 // src/telemetry/lintStreaks.ts
 import { createHash } from "crypto";