hyperframes 0.8.181 → 0.8.183

package/dist/warmCheck.js

@@ -0,0 +1,227 @@
+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);
+import "./chunk-TOHA5NAU.js";
+import "./chunk-VAK7A2N6.js";
+import {
+  prelaunchBrowserForCheck
+} from "./chunk-Q6UYKWBG.js";
+import "./chunk-57GN6KWT.js";
+import "./chunk-UNOSCGBG.js";
+import "./chunk-O7N3A7PE.js";
+import "./chunk-VH5KESLX.js";
+import "./chunk-3OLIGYWN.js";
+import "./chunk-KANNRHY7.js";
+import "./chunk-X7MTZ4T2.js";
+import "./chunk-CJYAJ3QM.js";
+import "./chunk-TJB4GAV6.js";
+import "./chunk-Z4R35NJS.js";
+import "./chunk-5OGDBU4G.js";
+import "./chunk-X7MTZ4T2.js";
+import "./chunk-XUHOIDKG.js";
+import "./chunk-NZ3BE2QE.js";
+import "./chunk-EVAQPW6O.js";
+import "./chunk-6JR2XUEE.js";
+import "./chunk-TTVHYD5R.js";
+import "./chunk-U6RXZNZE.js";
+import "./chunk-GPE3WWTO.js";
+import "./chunk-ALVXFXUG.js";
+import "./chunk-XOVHO3TT.js";
+import "./chunk-FH7WODJH.js";
+import "./chunk-GTE5WZAM.js";
+import "./chunk-MOEGCMKI.js";
+import "./chunk-B2SZZFWW.js";
+import "./chunk-DKPNNYBZ.js";
+import "./chunk-F6WHPHLF.js";
+import "./chunk-K2FLNJVB.js";
+import "./chunk-442JNXRM.js";
+import "./chunk-EHSBBBR2.js";
+import "./chunk-DQBY7FRR.js";
+import "./chunk-ZFO3A3QL.js";
+import "./chunk-K2Z5DZBS.js";
+import "./chunk-XT7X6QCP.js";
+import "./chunk-4YYJOFKS.js";
+import "./chunk-HVW7ABXD.js";
+import "./chunk-AKFADCMS.js";
+import "./chunk-JHOCK3DG.js";
+import "./chunk-VDJO4DJ7.js";
+import "./chunk-BP4VNTZL.js";
+import "./chunk-AWDFDFI3.js";
+import "./chunk-P6LJ4Y32.js";
+import "./chunk-GMECXFAN.js";
+import "./chunk-5CS4T6C6.js";
+import "./chunk-EOVYQ3IG.js";
+import "./chunk-DLC2FICN.js";
+import "./chunk-DEORFAWP.js";
+import "./chunk-VWG7OQKU.js";
+import "./chunk-HTIUNMTP.js";
+import "./chunk-S3S4TGEH.js";
+import "./chunk-54HJ63Q2.js";
+import {
+  registerRootExitRequester
+} from "./chunk-JVBRJMOP.js";
+import "./chunk-ZTZA4UWZ.js";
+import "./chunk-KLIKCX6Q.js";
+import "./chunk-EVMY7IPL.js";
+import "./chunk-7FMUTGOH.js";
+import "./chunk-73LTCCZI.js";
+import "./chunk-VFBAKPRC.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-WT4PYV2J.js";
+import "./chunk-GMNHAOMJ.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-UJKQWGFF.js";
+import "./chunk-YMS5FOMC.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import {
+  Frame,
+  encodeFrame,
+  envDigest,
+  frameForwarder,
+  frameReader,
+  keyed,
+  sameProof,
+  warmCheckEndpoint
+} from "./chunk-FG4BBFZI.js";
+import "./chunk-Q5X2B5WT.js";
+import "./chunk-T6AGUTZJ.js";
+import "./chunk-XT6MXC7A.js";
+import "./chunk-4UMPIPCQ.js";
+import "./chunk-ADDHW2FS.js";
+import "./chunk-VAS6HQX3.js";
+import "./chunk-6BNTGNGD.js";
+import "./chunk-OYLO6TYK.js";
+import "./chunk-MMQ52NIZ.js";
+import "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-IXLUTE6N.js";
+import "./chunk-TYXH3EKP.js";
+import "./chunk-W2LGJSEN.js";
+import "./chunk-ANR6WOC3.js";
+import "./chunk-K4WIOZFP.js";
+import "./chunk-XUXGIA7H.js";
+import "./chunk-WERLJGIC.js";
+import "./chunk-ISN5GRYI.js";
+import "./chunk-RZXUQR42.js";
+import "./chunk-KNU5COPB.js";
+import "./chunk-KGPLIH7B.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/warmCheck.ts
+import { randomBytes } from "crypto";
+import { unlinkSync } from "fs";
+import { connect, createServer } from "net";
+var [idleMs = "0", ...checkArgs] = process.argv.slice(2);
+var endpoint = warmCheckEndpoint();
+if (!endpoint) process.exit(0);
+var { address, token } = endpoint;
+var startDigest = envDigest(token, process.env);
+var exit = process.exit.bind(process);
+var idle = setTimeout(() => exit(0), Number(idleMs));
+registerRootExitRequester(exit);
+var listening = false;
+var served;
+process.on("exit", () => {
+  if (listening && process.platform !== "win32") {
+    try {
+      unlinkSync(address);
+    } catch {
+    }
+  }
+});
+var RELAYED_SIGNALS = /* @__PURE__ */ new Set(["SIGINT", "SIGTERM", "SIGHUP"]);
+async function serve(socket, request) {
+  let finished = false;
+  const finish = (code) => {
+    if (finished) return;
+    finished = true;
+    server.close();
+    listening = false;
+    socket.end(encodeFrame(Frame.Exit, String(code)), () => exit(code));
+  };
+  socket.on("close", () => {
+    if (!finished) process.kill(process.pid, "SIGKILL");
+  });
+  process.stdout.write = frameForwarder(socket, Frame.Stdout);
+  process.stderr.write = frameForwarder(socket, Frame.Stderr);
+  process.exit = ((code) => finish(Number(code ?? process.exitCode ?? 0)));
+  process.chdir(request.cwd);
+  process.argv = [process.execPath, request.script, ...request.argv];
+  await import(new URL("./cli.js", import.meta.url).href);
+  setImmediate(() => finish(Number(process.exitCode ?? 0)));
+}
+function decline(socket, yieldToNewEnvironment) {
+  socket.end(encodeFrame(Frame.Declined, "declined"), () => {
+    if (yieldToNewEnvironment) exit(0);
+  });
+}
+function accept(socket, request, nonce) {
+  const fresh = !served && sameProof(keyed(token, "client", nonce), request.proof);
+  if (!fresh || !sameProof(startDigest, request.envDigest)) return decline(socket, fresh);
+  served = socket;
+  clearTimeout(idle);
+  void serve(socket, request);
+}
+function parsedRequest(body) {
+  try {
+    return JSON.parse(body.toString());
+  } catch {
+    return void 0;
+  }
+}
+function relaySignal(socket, signal) {
+  if (socket === served && RELAYED_SIGNALS.has(signal)) {
+    process.kill(process.pid, signal);
+  }
+}
+function handshake(socket, nonce, type, body) {
+  if (type === Frame.Hello) {
+    const proof = keyed(token, "server", body.toString());
+    socket.write(encodeFrame(Frame.Proof, JSON.stringify({ proof, nonce })));
+    return false;
+  }
+  const request = type === Frame.Request ? parsedRequest(body) : void 0;
+  if (request) accept(socket, request, nonce);
+  return request !== void 0;
+}
+var server = createServer((socket) => {
+  const nonce = randomBytes(16).toString("hex");
+  let accepted = false;
+  socket.on("error", () => {
+  });
+  const read = frameReader((type, body) => {
+    if (type === Frame.Signal) relaySignal(socket, body.toString());
+    else if (!accepted) accepted = handshake(socket, nonce, type, body);
+  });
+  socket.on("data", (chunk) => {
+    if (!read(chunk)) socket.destroy();
+  });
+});
+function listen() {
+  server.listen(address, () => {
+    listening = true;
+  });
+}
+server.on("error", (error) => {
+  if (error.code !== "EADDRINUSE" || process.platform === "win32") exit(0);
+  const probe = connect(address, () => {
+    probe.destroy();
+    exit(0);
+  });
+  probe.on("error", () => {
+    try {
+      unlinkSync(address);
+    } catch {
+    }
+    listen();
+  });
+});
+listen();
+void prelaunchBrowserForCheck(checkArgs).catch(() => void 0);

package/dist/warmCheckClient.js

@@ -0,0 +1,139 @@
+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);
+import {
+  Frame,
+  HANDSHAKE_TIMEOUT_MS,
+  WARM_IDLE_MS,
+  encodeFrame,
+  envDigest,
+  frameReader,
+  keyed,
+  sameProof,
+  warmCheckEndpoint
+} from "./chunk-FG4BBFZI.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/warmCheckClient.ts
+import { spawn } from "child_process";
+import { randomBytes } from "crypto";
+import { dirname, join } from "path";
+import { connect } from "net";
+import { constants } from "os";
+import { fileURLToPath } from "url";
+var distDir = dirname(fileURLToPath(import.meta.url));
+var FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+var launchEnv = { ...process.env };
+function warmCheckEligible(argv = process.argv, env = process.env, stdoutTTY = process.stdout.isTTY, stderrTTY = process.stderr.isTTY) {
+  return argv[2] === "check" && !stdoutTTY && !stderrTTY && !env.CI && !argv.includes("--help");
+}
+function warmCheckOutcome(exitCode, wrote, signalled) {
+  if (exitCode !== void 0) return { served: true, exitCode };
+  if (signalled) return { served: true, exitCode: 128 + (constants.signals[signalled] ?? 0) };
+  if (!wrote) return { served: false };
+  return {
+    served: true,
+    exitCode: 1,
+    message: "The warm check process stopped before finishing.\n"
+  };
+}
+function connected(address) {
+  return new Promise((resolveSocket) => {
+    const socket = connect(address);
+    socket.once("connect", () => resolveSocket(socket));
+    socket.once("error", () => resolveSocket(void 0));
+  });
+}
+function parsedProof(type, body) {
+  if (type !== Frame.Proof) return void 0;
+  try {
+    return JSON.parse(body.toString());
+  } catch {
+    return void 0;
+  }
+}
+async function runWarmCheck(endpoint = warmCheckEndpoint(launchEnv)) {
+  if (!endpoint) return false;
+  const socket = await connected(endpoint.address);
+  if (!socket) return false;
+  const nonce = randomBytes(16).toString("hex");
+  let trusted = false;
+  let wrote = false;
+  let signalled;
+  const relay = (signal) => {
+    signalled = signal;
+    if (trusted) socket.write(encodeFrame(Frame.Signal, signal));
+    else socket.destroy();
+  };
+  for (const signal of FORWARDED_SIGNALS) process.on(signal, relay);
+  try {
+    return await new Promise((resolveRun) => {
+      let exitCode;
+      const sinks = /* @__PURE__ */ new Map([
+        [Frame.Stdout, process.stdout],
+        [Frame.Stderr, process.stderr]
+      ]);
+      const handshake = setTimeout(() => socket.destroy(), HANDSHAKE_TIMEOUT_MS);
+      const trust = (type, body) => {
+        const server = parsedProof(type, body);
+        if (!server || !sameProof(keyed(endpoint.token, "server", nonce), server.proof)) {
+          socket.destroy();
+          return;
+        }
+        trusted = true;
+        clearTimeout(handshake);
+        const request = {
+          argv: process.argv.slice(2),
+          script: process.argv[1] ?? "",
+          cwd: process.cwd(),
+          envDigest: envDigest(endpoint.token, launchEnv),
+          proof: keyed(endpoint.token, "client", String(server.nonce))
+        };
+        socket.write(encodeFrame(Frame.Request, JSON.stringify(request)));
+      };
+      const read = frameReader((type, body) => {
+        if (!trusted) return trust(type, body);
+        if (type === Frame.Exit) exitCode = Number(body.toString());
+        const sink = sinks.get(type);
+        if (!sink) return;
+        sink.write(body);
+        wrote = true;
+      });
+      socket.on("data", (chunk) => {
+        if (!read(chunk)) socket.destroy();
+      });
+      socket.on("error", () => {
+      });
+      socket.on("close", () => {
+        clearTimeout(handshake);
+        const outcome = warmCheckOutcome(exitCode, wrote, signalled);
+        if (outcome.message) process.stderr.write(outcome.message);
+        if (outcome.served) process.exitCode = outcome.exitCode;
+        resolveRun(outcome.served);
+      });
+      socket.write(encodeFrame(Frame.Hello, nonce));
+    });
+  } finally {
+    for (const signal of FORWARDED_SIGNALS) process.off(signal, relay);
+  }
+}
+function startNextWarmCheck(endpoint = warmCheckEndpoint(launchEnv)) {
+  if (!endpoint) return;
+  const args = [String(WARM_IDLE_MS), ...process.argv.slice(3)];
+  spawn(process.execPath, [join(distDir, "warmCheck.js"), ...args], {
+    cwd: process.cwd(),
+    env: launchEnv,
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true
+  }).unref();
+}
+export {
+  runWarmCheck,
+  startNextWarmCheck,
+  warmCheckEligible,
+  warmCheckOutcome
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hyperframes",
-  "version": "0.8.181",
+  "version": "0.8.183",
   "description": "HyperFrames CLI — create, preview, and render HTML video compositions",
   "license": "Apache-2.0",
   "repository": {
@@ -52,7 +52,6 @@
     "open": "^10.0.0",
     "postcss": "^8.5.8",
     "puppeteer-core": "^25.10.0",
-    "sharp": "^0.35.0",
     "yauzl": "^3.4.0"
   },
   "devDependencies": {
@@ -80,6 +79,9 @@
     "typescript": "^5.0.0",
     "vitest": "^4.1.11"
   },
+  "optionalDependencies": {
+    "sharp": "^0.35.0"
+  },
   "engines": {
     "node": ">=22"
   }