hyperframes 0.8.181 → 0.8.184

package/dist/{chunk-32GKETR7.js → chunk-MMQ52NIZ.js}

@@ -830,6 +830,72 @@ function validateColorGradingContract(value) {
   return issues;
 }
 
+// ../parsers/dist/mediaTiming.js
+var COMPOSITION_ATTRIBUTES2 = Object.freeze({
+  start: "data-start",
+  duration: "data-duration",
+  trackIndex: "data-track-index",
+  derivedEnd: "data-end",
+  legacyTrack: "data-layer"
+});
+var CANONICAL_AUTHORED_TIMING_ATTRIBUTES2 = Object.freeze([
+  COMPOSITION_ATTRIBUTES2.start,
+  COMPOSITION_ATTRIBUTES2.duration,
+  COMPOSITION_ATTRIBUTES2.trackIndex
+]);
+var DERIVED_TIMING_ATTRIBUTES2 = Object.freeze([
+  COMPOSITION_ATTRIBUTES2.derivedEnd
+]);
+var LEGACY_TIMING_ATTRIBUTES2 = Object.freeze([
+  COMPOSITION_ATTRIBUTES2.derivedEnd,
+  COMPOSITION_ATTRIBUTES2.legacyTrack
+]);
+function parseNumeric2(value) {
+  if (value == null || value.trim() === "") return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+var nonNegative = (raw) => {
+  const value = parseNumeric2(raw);
+  return value !== null && value >= 0 ? value : null;
+};
+function readMediaOffsetSeconds(getAttr) {
+  return nonNegative(getAttr("data-playback-start")) ?? nonNegative(getAttr("data-media-start")) ?? 0;
+}
+var MEDIA_START_BASIS_ATTR = "data-hf-media-start-basis";
+function readMediaStartBasis(value) {
+  return value?.trim().toLowerCase() === "global" ? "global" : "local";
+}
+function resolveAbsoluteMediaStartSeconds(input) {
+  return readMediaStartBasis(input.basis) === "global" ? input.authoredStart : input.hostStart + input.authoredStart;
+}
+function resolveMediaStartSeconds(input) {
+  if (!hasLiteralNestedStart(input)) return input.ordinaryStart();
+  return resolveAbsoluteMediaStartSeconds({
+    authoredStart: input.authoredStart,
+    hostStart: input.hostStart,
+    basis: input.basis
+  });
+}
+function isRootGlobalMediaStart(input) {
+  return hasLiteralNestedStart(input) && readMediaStartBasis(input.basis) === "global";
+}
+function hasLiteralNestedStart(input) {
+  return !input.hasAutoStart && input.authoredStart != null && input.hostStart !== 0;
+}
+function hostInPointSeconds(host) {
+  return readMediaOffsetSeconds((name) => host.getAttribute(name));
+}
+function compositionOriginSeconds(hostStart, host) {
+  return hostStart - hostInPointSeconds(host);
+}
+function cutToHostSlots(span, hosts) {
+  return hosts.reduce((kept, host) => {
+    const start = Math.max(kept.start, host.start);
+    return { start, end: Math.max(start, Math.min(kept.end, host.end)) };
+  }, span);
+}
+
 // ../parsers/dist/timeSpans.js
 var instantTolerance = (time) => 4 * Number.EPSILON * Math.max(1, Math.abs(time));
 function sameInstant(a, b) {
@@ -875,6 +941,14 @@ export {
   COLOR_GRADING_LUT_KEYS,
   isColorGradingVariableRef,
   validateColorGradingContract,
+  MEDIA_START_BASIS_ATTR,
+  readMediaStartBasis,
+  resolveAbsoluteMediaStartSeconds,
+  resolveMediaStartSeconds,
+  isRootGlobalMediaStart,
+  hostInPointSeconds,
+  compositionOriginSeconds,
+  cutToHostSlots,
   sameInstant,
   spansOverlap,
   spansShareTime,

package/dist/chunk-MOEGCMKI.js

@@ -0,0 +1,180 @@
+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 {
+  isDegradableEvaluateTimeoutError,
+  isNavigationTimeoutError,
+  withRemainingBudget
+} from "./chunk-EHSBBBR2.js";
+
+// src/capture/navigateForCapture.ts
+var NETWORK_IDLE_ATTEMPT_MS = 3e4;
+function networkIdleAttemptTimeoutMs(totalTimeoutMs) {
+  return Math.min(NETWORK_IDLE_ATTEMPT_MS, Math.max(0, totalTimeoutMs));
+}
+async function navigateForCapture(page, url, totalTimeoutMs) {
+  const networkIdleTimeoutMs = networkIdleAttemptTimeoutMs(totalTimeoutMs);
+  try {
+    const response2 = await page.goto(url, {
+      waitUntil: "networkidle2",
+      timeout: networkIdleTimeoutMs
+    });
+    return {
+      response: response2,
+      waitUntil: "networkidle2",
+      networkIdleTimeoutMs,
+      fellBackFromNetworkIdle: false
+    };
+  } catch (err) {
+    if (!isNavigationTimeoutError(err) || networkIdleTimeoutMs >= totalTimeoutMs) {
+      throw err;
+    }
+  }
+  const fallbackTimeoutMs = totalTimeoutMs - networkIdleTimeoutMs;
+  const response = await page.goto(url, {
+    waitUntil: "domcontentloaded",
+    timeout: fallbackTimeoutMs
+  });
+  return {
+    response,
+    waitUntil: "domcontentloaded",
+    networkIdleTimeoutMs,
+    fellBackFromNetworkIdle: true
+  };
+}
+async function waitForPageReady(page, options = {}) {
+  const { timeoutMs = 15e3, networkIdle = "always" } = options;
+  const deadline = Date.now() + timeoutMs;
+  const remaining = () => Math.max(0, deadline - Date.now());
+  const idle = async () => {
+    try {
+      await page.waitForNetworkIdle?.({
+        idleTime: 500,
+        timeout: remaining(),
+        concurrency: 2
+      });
+    } catch {
+    }
+  };
+  if (networkIdle === "always" && remaining() > 0) await idle();
+  let waitedOutLoad = false;
+  while (remaining() > 0) {
+    let timer;
+    const loading = await Promise.race([
+      page.evaluate(() => document.readyState === "loading").catch((err) => {
+        if (isDegradableEvaluateTimeoutError(err)) throw err;
+        return true;
+      }),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(true), Math.max(1, remaining()));
+      })
+    ]).finally(() => {
+      if (timer !== void 0) clearTimeout(timer);
+    });
+    if (loading !== true) break;
+    waitedOutLoad = true;
+    if (remaining() > 0) {
+      await new Promise((resolve) => setTimeout(resolve, Math.min(500, remaining())));
+    }
+  }
+  if (waitedOutLoad && remaining() > 0) await idle();
+}
+var PUPPETEER_LAUNCH_DEFAULT_TIMEOUT_MS = 3e4;
+var PAGE_LOAD_BLOCKING_TYPES = /* @__PURE__ */ new Set(["Document", "Script", "Stylesheet"]);
+var NAMED_BLOCKING_REQUESTS = 3;
+var SENT_OR_ANSWERED_WITHOUT_NETWORK = [
+  "Network.requestWillBeSentExtraInfo",
+  "Network.responseReceived"
+];
+async function gotoWhenSent(page, url, timeoutMs, coldChromeFirstRequestTimeoutMs = PUPPETEER_LAUNCH_DEFAULT_TIMEOUT_MS) {
+  const { TimeoutError } = await import("puppeteer-core");
+  const cdp = await page.createCDPSession();
+  try {
+    await cdp.send("Network.enable");
+    const sent = documentRequestSent(cdp);
+    const unfinished = unfinishedPageLoadRequests(cdp);
+    const navigation = page.goto(url, { waitUntil: "domcontentloaded", timeout: 0 });
+    const navigationAwaitedBelow = navigation.catch(() => void 0);
+    await withRemainingBudget(
+      Promise.race([sent, navigationAwaitedBelow]),
+      coldChromeFirstRequestTimeoutMs,
+      "sending the page request",
+      () => new TimeoutError(
+        `Navigation timeout: Chrome did not send the page request within ${coldChromeFirstRequestTimeoutMs} ms`
+      )
+    );
+    return await withRemainingBudget(
+      navigation,
+      timeoutMs,
+      "loading the page",
+      () => new TimeoutError(pageLoadTimeoutMessage(timeoutMs, url, unfinished()))
+    );
+  } finally {
+    await cdp.detach().catch(() => void 0);
+  }
+}
+function documentRequestSent(cdp) {
+  const documents = /* @__PURE__ */ new Set();
+  const sent = /* @__PURE__ */ new Set();
+  return new Promise((resolve) => {
+    const settle = (requestId) => {
+      if (documents.has(requestId) && sent.has(requestId)) resolve();
+    };
+    cdp.on("Network.requestWillBeSent", ({ requestId, type }) => {
+      if (type === "Document") documents.add(requestId);
+      settle(requestId);
+    });
+    for (const event of SENT_OR_ANSWERED_WITHOUT_NETWORK) {
+      cdp.on(event, ({ requestId }) => {
+        sent.add(requestId);
+        settle(requestId);
+      });
+    }
+  });
+}
+function unfinishedPageLoadRequests(cdp) {
+  const unfinished = /* @__PURE__ */ new Map();
+  cdp.on("Network.requestWillBeSent", ({ requestId, request, type }) => {
+    if (type && PAGE_LOAD_BLOCKING_TYPES.has(type)) unfinished.set(requestId, request.url);
+  });
+  for (const event of ["Network.loadingFinished", "Network.loadingFailed"]) {
+    cdp.on(event, ({ requestId }) => unfinished.delete(requestId));
+  }
+  return () => [...unfinished.values()];
+}
+function urlWithoutSecrets(raw) {
+  try {
+    const url = new URL(raw);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return `${url.protocol}\u2026`;
+    return `${url.origin}${url.pathname}${url.search ? "?\u2026" : ""}`;
+  } catch {
+    return "(unreadable URL)";
+  }
+}
+function originOf(raw) {
+  try {
+    return new URL(raw).origin;
+  } catch {
+    return null;
+  }
+}
+function pageLoadTimeoutMessage(timeoutMs, pageUrl, waitingOn) {
+  const exceeded = `Navigation timeout of ${timeoutMs} ms exceeded`;
+  if (waitingOn.length === 0) return exceeded;
+  const named = waitingOn.slice(0, NAMED_BLOCKING_REQUESTS).map(urlWithoutSecrets).join(", ");
+  const unnamed = waitingOn.length - NAMED_BLOCKING_REQUESTS;
+  const more = unnamed > 0 ? ` and ${unnamed} more` : "";
+  const pageOrigin = new URL(pageUrl).origin;
+  const fromAnotherServer = waitingOn.some((request) => originOf(request) !== pageOrigin);
+  const advice = fromAnotherServer ? " A <script> or stylesheet from another server holds the page until it arrives; serve it from the project instead." : "";
+  return `${exceeded} while the page was still loading ${named}${more}.${advice}`;
+}
+
+export {
+  navigateForCapture,
+  waitForPageReady,
+  gotoWhenSent
+};

package/dist/{chunk-E6RPWJVC.js → chunk-NAUKCKCJ.js}

@@ -7,9 +7,11 @@ var __dirname = __hf_dirname(__filename);
 import {
   writeCaptureFileSync
 } from "./chunk-MRF4AMKD.js";
+import {
+  loadSharp
+} from "./chunk-QH3T4WI2.js";
 
 // src/capture/contactSheet.ts
-import sharp from "sharp";
 import { readdirSync, readFileSync, unlinkSync, existsSync } from "fs";
 import { join, extname, basename, dirname } from "path";
 async function createContactSheet(imagePaths, outputPath, opts = {}) {
@@ -25,6 +27,7 @@ async function createContactSheet(imagePaths, outputPath, opts = {}) {
   if ((opts.remainingMs?.() ?? 1) <= 0) return null;
   const files = imagePaths.slice(0, maxImages);
   if (files.length === 0) return null;
+  const sharp = await loadSharp("contact sheets");
   const firstMeta = await sharp(files[0]).metadata();
   const srcW = firstMeta.width || 1920;
   const srcH = firstMeta.height || 1080;
@@ -157,6 +160,7 @@ async function createSvgContactSheet(svgsDir, outputPath, assetsRootDir, budget
     }
   }
   if (svgPaths.length === 0) return [];
+  const sharp = await loadSharp("contact sheets");
   const svgFileNames = svgPaths.map((p) => p.split("/").pop());
   const thumbSize = 200;
   const tmpDir = dirname(outputPath);

package/dist/{chunk-B4VT6YU2.js → chunk-OLZENUPI.js}

@@ -4,13 +4,13 @@ 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 {
+  EMBEDDED_FONT_DATA
+} from "./chunk-FI4I7CME.js";
 import {
   SYSTEM_FONT_SIZE_LIMIT,
   locateSystemFontVariants
 } from "./chunk-7FMUTGOH.js";
-import {
-  EMBEDDED_FONT_DATA
-} from "./chunk-FI4I7CME.js";
 import {
   FONT_ALIAS_MAP,
   resolveAliasDisplayName
@@ -3132,7 +3132,7 @@ var require_wawoff2 = __commonJS({
 
 // ../core/dist/fonts/deterministicFonts.js
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, mkdtempSync as mkdtempSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, mkdtempSync as mkdtempSync2, readFileSync as readFileSync2, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir2, tmpdir as tmpdir2 } from "os";
 import { join as join2 } from "path";
 import postcss2 from "postcss";
@@ -4252,8 +4252,38 @@ async function ensureWoff2DataUri(cachePath, woff2Url, familyName, weight, style
   return `data:font/woff2;base64,${readFileSync2(cachePath).toString("base64")}`;
 }
 var googleFontCssCache = /* @__PURE__ */ new Map();
+var GOOGLE_FONT_CSS_CACHE_DIR = "_css";
 function _clearGoogleFontCssCacheForTests() {
   googleFontCssCache.clear();
+  rmSync2(join2(resolveFontCacheRoot(), GOOGLE_FONT_CSS_CACHE_DIR), { recursive: true, force: true });
+}
+function googleFontCssCachePath(url) {
+  return join2(fontCacheDir(GOOGLE_FONT_CSS_CACHE_DIR), `${createHash2("sha256").update(url).digest("hex")}.json`);
+}
+function readCachedGoogleFontCss(url) {
+  let cached;
+  try {
+    cached = JSON.parse(readFileSync2(googleFontCssCachePath(url), "utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof cached !== "object" || cached === null)
+    return null;
+  const body = Reflect.get(cached, "body");
+  const status = Reflect.get(cached, "status");
+  return typeof body === "string" && typeof status === "number" ? { ok: true, body, status } : null;
+}
+function writeCachedGoogleFontCss(url, body, status) {
+  if (!/@font-face/i.test(body))
+    return;
+  const path = googleFontCssCachePath(url);
+  const partial = `${path}.${process.pid}.tmp`;
+  try {
+    writeFileSync2(partial, JSON.stringify({ status, body }), { mode: 420 });
+    renameSync2(partial, path);
+  } catch {
+    rmSync2(partial, { force: true });
+  }
 }
 function raceAgainstAbort(promise, signal) {
   if (!signal)
@@ -4270,11 +4300,18 @@ function fetchGoogleFontCss(url, familyName, options, attempt) {
   const mode = options.failClosedFontFetch ? `closed${options.retryPolicy.maxAttempts}` : "open";
   const key = `${mode}:${url}`;
   let shared = googleFontCssCache.get(key);
+  const cached = shared ? null : readCachedGoogleFontCss(url);
+  if (cached) {
+    shared = Promise.resolve(cached);
+    googleFontCssCache.set(key, shared);
+  }
   attempt.cssCache = shared ? "hit" : "fresh";
   if (!shared) {
     shared = fetchFontResource(url, { headers: { "User-Agent": WOFF2_USER_AGENT } }, (response) => response.text(), familyName, "Google Fonts CSS", { ...options, abortSignal: void 0 }).then((result) => {
-      if (result.ok)
+      if (result.ok) {
+        writeCachedGoogleFontCss(url, result.body, result.response.status);
         return { ok: true, body: result.body, status: result.response.status };
+      }
       if (isRetryableFontFetchStatus(result.response.status))
         googleFontCssCache.delete(key);
       return { ok: false, status: result.response.status };
@@ -4492,8 +4529,14 @@ function extractGoogleFontsText(html) {
   const decodedBodyText = document2.body?.textContent ?? "";
   const locales = collectLangAttributes(document2);
   const uniqueCharacters = /* @__PURE__ */ new Set();
-  for (const character of /* @__PURE__ */ new Set([...Array.from(html), ...Array.from(decodedBodyText)])) {
-    addCaseClosure(uniqueCharacters, character, locales);
+  const seen = /* @__PURE__ */ new Set();
+  for (const text of [html, decodedBodyText]) {
+    for (const character of text) {
+      if (seen.has(character))
+        continue;
+      seen.add(character);
+      addCaseClosure(uniqueCharacters, character, locales);
+    }
   }
   if (hasTextTransformKeyword(html, FULL_WIDTH_KEYWORD_RE))
     addFullwidthVariants(uniqueCharacters);

package/dist/{chunk-H4YZZ2VQ.js → chunk-PFD25NAC.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   failCommand
-} from "./chunk-PBN6GBJE.js";
+} from "./chunk-JVBRJMOP.js";
 
 // src/commands/lambda/state.ts
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "fs";

package/dist/{chunk-XH262OWN.js → chunk-PFYWVUHA.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-HVW7ABXD.js";
 import {
   DEFAULT_REGISTRY_URL
-} from "./chunk-TO6JNTML.js";
+} from "./chunk-7MB2ZAQF.js";
 
 // src/utils/projectConfig.ts
 import { readFileSync, writeFileSync } from "fs";

package/dist/{chunk-S3RYRF3W.js → chunk-PSKEKWVU.js}

@@ -10,7 +10,7 @@ import {
 import {
   DISTRIBUTED_FPS,
   isDistributedFps
-} from "./chunk-LBQFLUIY.js";
+} from "./chunk-J3QM7AHP.js";
 import {
   parseHTML
 } from "./chunk-SDYDNHEE.js";

package/dist/{chunk-N5SXQCJL.js → chunk-Q33P4EAC.js}

@@ -7,14 +7,14 @@ var __dirname = __hf_dirname(__filename);
 import {
   trackLintReport,
   trackLintRuleStreak
-} from "./chunk-5E5EYPZO.js";
+} from "./chunk-JIUTXKWA.js";
 import {
   shouldTrack
-} from "./chunk-K26FR4SM.js";
+} from "./chunk-UKOTVJFV.js";
 import {
   LINT_RULE_COUNT,
   LINT_RULE_GROUP_COUNTS
-} from "./chunk-GK2FIKIQ.js";
+} from "./chunk-ADDHW2FS.js";
 
 // src/telemetry/lintStreaks.ts
 import { createHash } from "crypto";

package/dist/{chunk-3DKN5WKL.js → chunk-QH3T4WI2.js}

@@ -34,8 +34,12 @@ var PINNED_PACKAGES = {
   "sherpa-onnx-node": "1.13.8"
 };
 var CACHE_DIR = join(homedir(), ".cache", "hyperframes", "optional");
+var SHARP_VERSION = "0.35.3";
 function optionalPackageDir(name, cacheDir = CACHE_DIR) {
-  return join(cacheDir, `${name.replace("/", "__")}@${OPTIONAL_PACKAGES[name]}`);
+  return join(cacheDir, `${name.replace("/", "__")}@${versionOf(name)}`);
+}
+function versionOf(name) {
+  return name === "sharp" ? SHARP_VERSION : OPTIONAL_PACKAGES[name];
 }
 function installedOptionalPackageVersion(name, cacheDir = CACHE_DIR, cliUrl = import.meta.url) {
   if (pinnedPackageBesideCli(name, cliUrl)?.resolution === "entry") return OPTIONAL_PACKAGES[name];
@@ -44,14 +48,78 @@ function installedOptionalPackageVersion(name, cacheDir = CACHE_DIR, cliUrl = im
   return JSON.parse(readFileSync(manifestPath(dir, name), "utf-8")).version;
 }
 function loadInstalledOptionalPackage(name, deps = defaultDeps) {
-  const found = deps.loadBesideCli(name) ?? deps.loadInstalled(optionalPackageDir(name, deps.cacheDir), name);
-  return found;
+  return loadPresent(name, deps);
+}
+function loadPresent(name, deps) {
+  return deps.loadBesideCli(name) ?? deps.loadInstalled(optionalPackageDir(name, deps.cacheDir), name);
 }
 async function loadOptionalPackage(name, feature, deps = defaultDeps) {
-  const present = loadInstalledOptionalPackage(name, deps);
+  return await loadOrInstall(name, feature, deps);
+}
+async function loadSharp(feature, deps = defaultDeps, besideCli = requireSharpBesideCli) {
+  return besideCli(feature) ?? sharpExport(await loadOrInstall("sharp", feature, deps));
+}
+var backgroundSharpInstall;
+async function loadSharpInBackground(feature, deps = defaultDeps, besideCli = requireSharpBesideCli) {
+  const present = loadInstalledSharp(feature, deps, besideCli);
   if (present !== null) return present;
+  const install2 = loadOrInstall("sharp", feature, deps);
+  if (backgroundSharpInstall !== install2) {
+    backgroundSharpInstall = install2;
+    install2.catch((err) => deps.log(err.message));
+  }
+  const notYet = /* @__PURE__ */ Symbol("installing");
+  const settled = await Promise.race([install2, notYet]);
+  if (settled === notYet)
+    throw new Error(`sharp is not installed yet; installing it once for ${feature}`);
+  return sharpExport(settled);
+}
+function loadInstalledSharp(feature, deps = defaultDeps, besideCli = requireSharpBesideCli) {
+  const found = besideCli(feature) ?? loadPresent("sharp", deps);
+  return found === null ? null : sharpExport(found);
+}
+function requireSharpBesideCli(feature, cliUrl = import.meta.url) {
+  const req = createRequire(cliUrl);
+  let entry;
+  try {
+    entry = req.resolve("sharp");
+  } catch {
+    return null;
+  }
+  try {
+    return sharpExport(req(entry));
+  } catch (err) {
+    throw new Error(
+      `${feature} needs sharp, which is installed but could not load (${err.message}). Reinstall hyperframes with optional dependencies enabled, or run: npm i sharp`
+    );
+  }
+}
+function sharpExport(module) {
+  const m = module;
+  return m.default ?? m;
+}
+function installTurnedOff(name) {
+  const value = process.env["HYPERFRAMES_NO_OPTIONAL_INSTALL"]?.trim() ?? "";
+  return value === "1" || value.split(",").some((entry) => entry.trim() === name);
+}
+var installs = /* @__PURE__ */ new WeakMap();
+function loadOrInstall(name, feature, deps) {
+  const present = loadPresent(name, deps);
+  if (present !== null) return Promise.resolve(present);
+  let pending = installs.get(deps);
+  if (!pending) installs.set(deps, pending = /* @__PURE__ */ new Map());
+  let install2 = pending.get(name);
+  if (!install2) pending.set(name, install2 = installAndLoad(name, feature, deps));
+  return install2;
+}
+async function installAndLoad(name, feature, deps) {
   const dir = optionalPackageDir(name, deps.cacheDir);
-  const version = OPTIONAL_PACKAGES[name];
+  const version = versionOf(name);
+  if (installTurnedOff(name)) {
+    throw new Error(
+      `${name} is not installed, and HYPERFRAMES_NO_OPTIONAL_INSTALL turns off installing it; ${feature} needs it.`
+    );
+  }
   deps.log(`installing ${name} for ${feature}, once`);
   try {
     await deps.install(dir, name, version);
@@ -179,7 +247,7 @@ async function install(dir, name, version, run = runNpm) {
 }
 var defaultDeps = {
   cacheDir: CACHE_DIR,
-  loadBesideCli: (name) => loadBesideCli(name),
+  loadBesideCli: (name) => name === "sharp" ? null : loadBesideCli(name),
   loadInstalled,
   install,
   log: (line) => console.error(line)
@@ -192,6 +260,9 @@ export {
   installedOptionalPackageVersion,
   loadInstalledOptionalPackage,
   loadOptionalPackage,
+  loadSharp,
+  loadSharpInBackground,
+  loadInstalledSharp,
   isInstalled,
   installedPackagePath,
   pinnedPackageBesideCli,