@vfrey/vfrey 0.0.1 → 1.0.0-beta.1

package/vendor/framey/dist/chunk-6BNTGNGD.js

@@ -0,0 +1,286 @@
+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 {
+  decodeHTMLAttribute
+} from "./chunk-SDYDNHEE.js";
+
+// ../parsers/dist/assetResolution.js
+import { closeSync, constants, existsSync, fstatSync, openSync, readFileSync } from "fs";
+import { isAbsolute as isAbsolute2, join as join2, posix as posix2, relative as relative2, resolve as resolve3, sep } from "path";
+import { posix } from "path";
+function readAttributeValue(html, at) {
+  while (/[\t\n\f\r ]/.test(html.charAt(at))) at++;
+  const quote = ['"', "'"].includes(html.charAt(at)) ? html.charAt(at) : "";
+  if (quote) at++;
+  const valueStart = at;
+  if (quote) {
+    const closing = html.indexOf(quote, at);
+    at = closing === -1 ? html.length : closing;
+  } else {
+    while (at < html.length && !/[\t\n\f\r >]/.test(html[at])) at++;
+  }
+  const valueEnd = at;
+  const end = quote ? Math.min(valueEnd + 1, html.length) : valueEnd;
+  return { value: html.slice(valueStart, valueEnd), valueStart, valueEnd, quote, end };
+}
+function readAttribute(html, start) {
+  let at = start;
+  while (at < html.length && !/[\t\n\f\r =/>]/.test(html[at])) at++;
+  if (at === start) return null;
+  const name = html.slice(start, at).toLowerCase();
+  const nameEnd = at;
+  while (/[\t\n\f\r ]/.test(html[at] ?? "")) at++;
+  if (html[at] !== "=") return { kind: "boolean", name, start, end: nameEnd };
+  return { kind: "value", name, start, ...readAttributeValue(html, at + 1) };
+}
+function readOpeningTag(html, start, name, at) {
+  const attributes = [];
+  while (at < html.length) {
+    while (/[\t\n\f\r /]/.test(html[at] ?? "")) at++;
+    if (at >= html.length || html[at] === ">") break;
+    const attribute = readAttribute(html, at);
+    if (attribute === null) {
+      at++;
+      continue;
+    }
+    attributes.push(attribute);
+    at = attribute.end;
+  }
+  const closed = html[at] === ">";
+  return {
+    name: name.toLowerCase(),
+    start,
+    bodyEnd: at,
+    end: closed ? at + 1 : at,
+    closed,
+    rawTextEnd: null,
+    attributes
+  };
+}
+function scanHtmlOpeningTags(html) {
+  const tags = [];
+  const opening = /<!--[\s\S]*?(?:--!?>|$)|<([a-z][^\t\n\f\r />]*)/gi;
+  let match;
+  while ((match = opening.exec(html)) !== null) {
+    if (!match[1]) continue;
+    const tag = readOpeningTag(html, match.index, match[1], opening.lastIndex);
+    tags.push(tag);
+    opening.lastIndex = tag.end;
+    if ([
+      "script",
+      "style",
+      "textarea",
+      "title",
+      "xmp",
+      "iframe",
+      "noembed",
+      "noframes",
+      "plaintext"
+    ].includes(tag.name)) {
+      if (tag.name === "plaintext") {
+        tag.rawTextEnd = html.length;
+        break;
+      }
+      const closing = new RegExp(`</${tag.name}(?=[\\t\\n\\f\\r />])`, "gi");
+      closing.lastIndex = tag.end;
+      const end = closing.exec(html);
+      tag.rawTextEnd = end?.index ?? html.length;
+      opening.lastIndex = tag.rawTextEnd;
+    }
+  }
+  return tags;
+}
+function decodeAuthoredAttribute(value) {
+  return decodeHTMLAttribute(value);
+}
+function decodeUrlPathVariants(path) {
+  const decoded = decodeWellFormedEscapes(path);
+  return decoded === path ? [path] : [decoded, path];
+}
+function decodeWellFormedEscapes(path) {
+  return path.replace(/(?:%[0-9A-Fa-f]{2})+/g, (run) => {
+    try {
+      return decodeURIComponent(run);
+    } catch {
+      return run;
+    }
+  });
+}
+function splitUrlSuffix(urlValue) {
+  const queryIdx = urlValue.indexOf("?");
+  const hashIdx = urlValue.indexOf("#");
+  if (queryIdx < 0 && hashIdx < 0) return { basePath: urlValue, suffix: "" };
+  let cutIdx = urlValue.length;
+  if (queryIdx >= 0) cutIdx = Math.min(cutIdx, queryIdx);
+  if (hashIdx >= 0) cutIdx = Math.min(cutIdx, hashIdx);
+  return { basePath: urlValue.slice(0, cutIdx), suffix: urlValue.slice(cutIdx) };
+}
+function encodeUrlPath(path) {
+  return encodeURIComponent(path).replace(/%2F/g, "/").replace(/['()]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function isNonRelativeUrl(val) {
+  return !val || val.startsWith("http://") || val.startsWith("https://") || val.startsWith("//") || val.startsWith("data:") || val.startsWith("#") || val.startsWith("/");
+}
+var { join, resolve: resolve2, dirname } = posix;
+var isAbsoluteOrSpecial = isNonRelativeUrl;
+function needsRewrite(val) {
+  return val.startsWith("../") || val === "..";
+}
+function rewriteAssetPath(compSrcPath, relativePath, assetExists) {
+  if (isAbsoluteOrSpecial(relativePath)) return relativePath;
+  const compDir = dirname(compSrcPath);
+  if (!compDir || compDir === ".") return relativePath;
+  const { basePath, suffix } = splitUrlSuffix(relativePath);
+  const slashed = basePath.replace(/\\/g, "/");
+  if (!slashed || slashed.startsWith("/")) return relativePath;
+  const filePath = decodeWellFormedEscapes(slashed);
+  const sibling = resolve2("/", join(compDir, filePath)).slice(1);
+  if (!needsRewrite(filePath) && (!assetExists || !assetExists(sibling))) return relativePath;
+  return encodeUrlPath(sibling) + suffix;
+}
+function isRemoteOrInlineUrl(url) {
+  return /^(https?:|data:|blob:|\/\/|#)/i.test(url);
+}
+function hasUnresolvedTemplatingToken(url) {
+  return /<<[^<>]+>>|\{\{[^{}]+\}\}|\$\{[^{}]+\}/.test(url);
+}
+function isUnresolvedAssetPlaceholder(rawSrc) {
+  return /^__[A-Z_]+__$/.test(rawSrc.trim()) || hasUnresolvedTemplatingToken(rawSrc);
+}
+function collectSubCompositionSrcs(html) {
+  const srcs = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const tag of scanHtmlOpeningTags(html)) {
+    if (!tag.closed) continue;
+    const attribute = tag.attributes.find((attr) => attr.name === "data-composition-src");
+    if (attribute?.kind !== "value") continue;
+    const src = decodeAuthoredAttribute(attribute.value).trim();
+    if (!src || seen.has(src)) continue;
+    if (isUnresolvedAssetPlaceholder(src)) continue;
+    if (isRemoteOrInlineUrl(src)) continue;
+    seen.add(src);
+    srcs.push(src);
+  }
+  return srcs;
+}
+function cleanAssetUrl(url) {
+  return url.trim().split(/[?#]/, 1)[0] ?? "";
+}
+function isWithinProjectRoot(projectDir, candidate, pathModule = { resolve: resolve3, relative: relative2, isAbsolute: isAbsolute2 }) {
+  const projectRoot = pathModule.resolve(projectDir);
+  const relativePath = pathModule.relative(projectRoot, candidate);
+  return relativePath === "" || !relativePath.startsWith("..") && !pathModule.isAbsolute(relativePath);
+}
+function addCandidate(candidates, candidate) {
+  if (!candidates.includes(candidate)) candidates.push(candidate);
+}
+function resolveLocalAssetCandidates(projectDir, url) {
+  const cleanUrl = cleanAssetUrl(url);
+  const projectRoot = resolve3(projectDir);
+  const candidates = [];
+  for (const variant of decodeUrlPathVariants(cleanUrl)) {
+    const projectRelative = variant.startsWith("/") ? variant.slice(1) : variant;
+    const resolved = resolve3(projectRoot, projectRelative);
+    if (isWithinProjectRoot(projectRoot, resolved)) {
+      addCandidate(candidates, resolved);
+      continue;
+    }
+    const normalized = posix2.normalize(projectRelative.replace(/\\/g, "/"));
+    const clamped = normalized.replace(/^(\.\.\/)+/, "");
+    if (clamped && !clamped.startsWith("..")) {
+      addCandidate(candidates, resolve3(projectRoot, clamped));
+    }
+  }
+  return candidates;
+}
+function resolveExistingLocalAsset(projectDir, url) {
+  const projectRoot = resolve3(projectDir);
+  const resolved = resolveLocalAssetCandidates(projectRoot, url).find(existsSync);
+  if (!resolved) return null;
+  return { resolved, rootRelativePath: relative2(projectRoot, resolved) };
+}
+function resolveAuthoredAssetFile(projectDir, compositionFile, src) {
+  const cleanSrc = cleanAssetUrl(src.trim());
+  if (!cleanSrc) return null;
+  const rootRelative = cleanSrc.startsWith("/") ? cleanSrc : rewriteAssetPath(compositionFile, cleanSrc, (path) => existsSync(join2(projectDir, path)));
+  return resolveExistingLocalAsset(projectDir, rootRelative)?.resolved ?? null;
+}
+function reanchoredCandidates(variant, baseDir, compiledDir) {
+  const baseAbs = resolve3(baseDir);
+  const joinedAbs = resolve3(join2(baseDir, variant));
+  if (joinedAbs === baseAbs || joinedAbs.startsWith(baseAbs + sep)) return [];
+  const stripped = posix2.normalize(variant.replace(/\\/g, "/")).replace(/^(\.\.\/)+/, "");
+  if (!stripped || stripped === variant || stripped.startsWith("..")) return [];
+  return compiledDir ? [join2(compiledDir, stripped), join2(baseDir, stripped)] : [join2(baseDir, stripped)];
+}
+function resolveProjectRelativeSrc(src, baseDir, compiledDir) {
+  const cleanSrc = cleanAssetUrl(src);
+  if (isAbsolute2(cleanSrc) && existsSync(cleanSrc)) return cleanSrc;
+  const candidates = /* @__PURE__ */ new Set();
+  for (const variant of decodeUrlPathVariants(cleanSrc)) {
+    for (const candidate of reanchoredCandidates(variant, baseDir, compiledDir)) {
+      candidates.add(candidate);
+    }
+    if (compiledDir) candidates.add(join2(compiledDir, variant));
+    candidates.add(join2(baseDir, variant));
+  }
+  return [...candidates].find(existsSync) ?? join2(baseDir, cleanSrc);
+}
+function maskRange(src, pattern) {
+  return src.replace(pattern, (m) => " ".repeat(m.length));
+}
+function maskHtmlComments(src) {
+  const chunks = [];
+  let cursor = 0;
+  while (true) {
+    const start = src.indexOf("<!--", cursor);
+    if (start === -1) break;
+    const end = src.indexOf("-->", start + 4);
+    if (end === -1) break;
+    const afterComment = end + 3;
+    chunks.push(src.slice(cursor, start), " ".repeat(afterComment - start));
+    cursor = afterComment;
+  }
+  return chunks.length === 0 ? src : chunks.join("") + src.slice(cursor);
+}
+function maskNonScannableRanges(html) {
+  let out = maskHtmlComments(html);
+  out = maskRange(out, /<style\b[^>]*>[\s\S]*?<\/style\b[^>]*>/gi);
+  out = maskRange(out, /<script\b[^>]*>[\s\S]*?<\/script\b[^>]*>/gi);
+  return out;
+}
+function readProjectFile(path) {
+  let fd;
+  try {
+    fd = openSync(path, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0), 384);
+  } catch (error) {
+    const code = error.code ?? "";
+    if (["EISDIR", "ENXIO"].includes(code)) return { kind: "folder" };
+    if (["ENOENT", "ENOTDIR", "ELOOP", "ENAMETOOLONG"].includes(code)) return { kind: "missing" };
+    throw error;
+  }
+  try {
+    if (!fstatSync(fd).isFile()) return { kind: "folder" };
+    return { kind: "file", text: readFileSync(fd, "utf-8") };
+  } finally {
+    closeSync(fd);
+  }
+}
+
+export {
+  isRemoteOrInlineUrl,
+  isUnresolvedAssetPlaceholder,
+  collectSubCompositionSrcs,
+  cleanAssetUrl,
+  isWithinProjectRoot,
+  resolveLocalAssetCandidates,
+  resolveExistingLocalAsset,
+  resolveAuthoredAssetFile,
+  resolveProjectRelativeSrc,
+  maskNonScannableRanges,
+  readProjectFile
+};

package/vendor/framey/dist/chunk-6DDPOHMK.js

@@ -0,0 +1,140 @@
+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 {
+  getMimeType
+} from "./chunk-THJALHFJ.js";
+import {
+  injectTagsAtHeadStart
+} from "./chunk-UJZREAV6.js";
+
+// src/utils/compositionServer.ts
+import { createHash } from "crypto";
+import { createReadStream, existsSync, statSync } from "fs";
+import { resolve, dirname } from "path";
+import { Readable } from "stream";
+import { fileURLToPath } from "url";
+function helperDir() {
+  return dirname(fileURLToPath(import.meta.url));
+}
+function resolveRuntimePath() {
+  const d = helperDir();
+  const candidates = [
+    resolve(d, "hyperframe.runtime.iife.js"),
+    resolve(d, "hyperframe-runtime.js"),
+    resolve(d, "..", "hyperframe-runtime.js"),
+    // Monorepo dev: src/<dir>/ → src/ → cli/ → packages/ then into core/dist/
+    resolve(d, "..", "..", "..", "core", "dist", "hyperframe.runtime.iife.js")
+  ];
+  return candidates.find((p) => existsSync(p)) ?? null;
+}
+function resolvePlayerPath() {
+  const d = helperDir();
+  const candidates = [
+    resolve(d, "..", "..", "..", "player", "dist", "hyperframes-player.global.js"),
+    resolve(d, "hyperframes-player.global.js"),
+    resolve(d, "..", "hyperframes-player.global.js")
+  ];
+  return candidates.find((p) => existsSync(p)) ?? null;
+}
+function resolveSlideshowPath() {
+  const d = helperDir();
+  const candidates = [
+    resolve(d, "..", "..", "..", "player", "dist", "slideshow", "hyperframes-slideshow.global.js"),
+    resolve(d, "hyperframes-slideshow.global.js"),
+    resolve(d, "..", "hyperframes-slideshow.global.js")
+  ];
+  return candidates.find((p) => existsSync(p)) ?? null;
+}
+function injectRuntime(html) {
+  return injectTagsAtHeadStart(html, `<script src="/runtime.js"></script>`);
+}
+function assetContentType(filePath) {
+  return getMimeType(filePath);
+}
+function revalidatedResponse(body, contentType, ifNoneMatch) {
+  const etag = `"${createHash("sha256").update(body).digest("base64url").slice(0, 27)}"`;
+  const headers = { "Content-Type": contentType, "Cache-Control": "no-cache", ETag: etag };
+  if (ifNoneMatch === etag) return new Response(null, { status: 304, headers });
+  return new Response(body, { status: 200, headers });
+}
+function buildRangeResponse(filePath, contentType, rangeHeader, ifNoneMatch) {
+  const { size, mtimeMs } = statSync(filePath);
+  const last = size - 1;
+  const cache = {
+    "Cache-Control": "no-cache",
+    ETag: `"${mtimeMs.toString(36)}-${size.toString(36)}"`
+  };
+  if (ifNoneMatch === cache.ETag) return new Response(null, { status: 304, headers: cache });
+  const match = rangeHeader ? /^bytes=(\d*)-(\d*)$/.exec(rangeHeader.trim()) : null;
+  const body = (start2, end2) => size === 0 ? null : Readable.toWeb(createReadStream(filePath, { start: start2, end: end2 }));
+  if (!match) {
+    return new Response(body(0, last), {
+      status: 200,
+      headers: {
+        ...cache,
+        "Content-Type": contentType,
+        "Accept-Ranges": "bytes",
+        "Content-Length": String(size)
+      }
+    });
+  }
+  const hasStart = match[1] !== "";
+  const start = hasStart ? Number(match[1]) : Math.max(0, size - Number(match[2]));
+  const end = !hasStart ? last : match[2] !== "" ? Math.min(Number(match[2]), last) : last;
+  if (start > end || start > last) {
+    return new Response(null, {
+      status: 416,
+      headers: { "Content-Range": `bytes */${size}`, "Accept-Ranges": "bytes" }
+    });
+  }
+  return new Response(body(start, end), {
+    status: 206,
+    headers: {
+      ...cache,
+      "Content-Type": contentType,
+      "Accept-Ranges": "bytes",
+      "Content-Range": `bytes ${start}-${end}/${size}`,
+      "Content-Length": String(end - start + 1)
+    }
+  });
+}
+async function listenOnFreePort(server, startPort) {
+  for (let attempt = 0; attempt < 10; attempt++) {
+    const port = startPort + attempt;
+    try {
+      await new Promise((res, rej) => {
+        const onErr = (err) => {
+          server.removeListener("listening", onOk);
+          rej(err ?? new Error("server error"));
+        };
+        const onOk = () => {
+          server.removeListener("error", onErr);
+          res();
+        };
+        server.once("error", onErr);
+        server.once("listening", onOk);
+        server.listen(port);
+      });
+      return port;
+    } catch (err) {
+      if (err.code === "EADDRINUSE") continue;
+      throw err;
+    }
+  }
+  throw new Error(`No free port found in [${startPort}, ${startPort + 9}]`);
+}
+
+export {
+  resolveRuntimePath,
+  resolvePlayerPath,
+  resolveSlideshowPath,
+  injectRuntime,
+  assetContentType,
+  revalidatedResponse,
+  buildRangeResponse,
+  listenOnFreePort
+};

package/vendor/framey/dist/chunk-6GV5XSOR.js

@@ -0,0 +1,214 @@
+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 {
+  writeCaptureFileSync
+} from "./chunk-GKZEVJIB.js";
+import {
+  loadSharp
+} from "./chunk-VMC4WSH5.js";
+
+// src/capture/contactSheet.ts
+import { readdirSync, readFileSync, unlinkSync, existsSync } from "fs";
+import { join, extname, basename, dirname } from "path";
+async function createContactSheet(imagePaths, outputPath, opts = {}) {
+  const {
+    cols = 3,
+    maxImages = 16,
+    padding = 4,
+    labelMode = "index",
+    labels,
+    quality = 88,
+    cellWidth = 600
+  } = 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.autoOrient.width || 1920;
+  const srcH = firstMeta.autoOrient.height || 1080;
+  const scale = cellWidth / srcW;
+  const cellW = cellWidth;
+  const cellH = Math.round(srcH * scale);
+  const rows = Math.ceil(files.length / cols);
+  const labelH = 26;
+  const totalW = cols * cellW + (cols + 1) * padding;
+  const totalH = rows * (cellH + labelH) + (rows + 1) * padding;
+  const overlays = [];
+  for (let i = 0; i < files.length; i++) {
+    const col = i % cols;
+    const row = Math.floor(i / cols);
+    const x = padding + col * (cellW + padding);
+    const y = padding + row * (cellH + labelH + padding);
+    const resized = await sharp(files[i]).autoOrient().resize(cellW, cellH, { fit: "contain", background: { r: 26, g: 26, b: 26 } }).toBuffer();
+    overlays.push({ input: resized, left: x, top: y + labelH });
+    let labelText = `${i + 1}`;
+    if (labelMode === "filename") {
+      labelText = `${i + 1}. ${basename(files[i]).replace(extname(files[i]), "")}`;
+    } else if (labelMode === "custom" && labels?.[i]) {
+      labelText = `${i + 1}. ${labels[i]}`;
+    }
+    if (labelText.length > 60) labelText = labelText.slice(0, 57) + "...";
+    const labelSvg = Buffer.from(
+      `<svg width="${cellW}" height="${labelH}"><rect width="${cellW}" height="${labelH}" fill="#1a1a1a"/><text x="8" y="18" font-family="Arial,Helvetica,sans-serif" font-size="13" font-weight="bold" fill="#ffffff">${escapeXml(labelText)}</text></svg>`
+    );
+    overlays.push({ input: labelSvg, left: x, top: y });
+  }
+  const sheet = sharp({
+    create: {
+      width: totalW,
+      height: totalH,
+      channels: 3,
+      background: { r: 26, g: 26, b: 26 }
+    }
+  }).composite(overlays);
+  const encoded = extname(outputPath).toLowerCase() === ".png" ? await sheet.png().toBuffer() : await sheet.jpeg({ quality }).toBuffer();
+  writeCaptureFileSync(outputPath, encoded);
+  return outputPath;
+}
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+async function createContactSheetPages(imagePaths, outputBasePath, opts = {}, labelOffset = 0, customLabels) {
+  if (imagePaths.length === 0) return [];
+  const { pageSize = imagePaths.length, remainingMs, ...sheetOpts } = opts;
+  const ext = outputBasePath.match(/\.[^.]+$/)?.[0] ?? ".jpg";
+  const base = outputBasePath.slice(0, -ext.length);
+  const pages = Math.ceil(imagePaths.length / pageSize);
+  const results = [];
+  for (let p = 0; p < pages; p++) {
+    if ((remainingMs?.() ?? 1) <= 0) break;
+    const chunk = imagePaths.slice(p * pageSize, (p + 1) * pageSize);
+    const chunkLabels = customLabels?.slice(p * pageSize, (p + 1) * pageSize);
+    const outPath = pages === 1 ? outputBasePath : `${base}-${p + 1}${ext}`;
+    const labelsForChunk = chunkLabels ? { labelMode: "custom", labels: chunkLabels } : sheetOpts.labelMode === "filename" ? { labelMode: "filename" } : { labelMode: "index" };
+    const written = await createContactSheet(chunk, outPath, {
+      ...sheetOpts,
+      ...labelsForChunk,
+      maxImages: chunk.length
+    });
+    if (written) results.push(written);
+    void labelOffset;
+  }
+  return results;
+}
+async function createScrollContactSheet(screenshotsDir, outputPath, budget = {}) {
+  if (!existsSync(screenshotsDir)) return [];
+  const scrollFiles = readdirSync(screenshotsDir).filter((f) => f.startsWith("scroll-") && f.endsWith(".png")).sort();
+  if (scrollFiles.length === 0) return [];
+  const paths = scrollFiles.map((f) => join(screenshotsDir, f));
+  const labels = scrollFiles.map((f) => {
+    const m = f.match(/scroll-(\d+)\.png/);
+    return m ? `${m[1]}% scroll` : f;
+  });
+  return createContactSheetPages(
+    paths,
+    outputPath,
+    { cols: 3, cellWidth: 600, pageSize: 9, ...budget },
+    0,
+    labels
+  );
+}
+async function createSnapshotContactSheet(paths, outputPath, budget = {}) {
+  if (paths.length === 0) return [];
+  const labels = paths.map((path) => {
+    const m = basename(path).match(/at-([\d.]+)s/);
+    return m ? `${m[1]}s` : basename(path);
+  });
+  return createContactSheetPages(
+    paths,
+    outputPath,
+    { cols: 3, cellWidth: 600, pageSize: 9, ...budget },
+    0,
+    labels
+  );
+}
+async function createAssetContactSheet(assetsDir, outputPath, budget = {}) {
+  if (!existsSync(assetsDir)) return [];
+  const imageExts = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".avif", ".gif", ".heic", ".tiff"]);
+  const assetFiles = readdirSync(assetsDir).filter((f) => imageExts.has(extname(f).toLowerCase()) && !f.includes("contact-sheet")).sort();
+  if (assetFiles.length === 0) return [];
+  const paths = assetFiles.map((f) => join(assetsDir, f));
+  return createContactSheetPages(paths, outputPath, {
+    cols: 4,
+    cellWidth: 480,
+    labelMode: "filename",
+    pageSize: 12,
+    ...budget
+  });
+}
+async function createSvgContactSheet(svgsDir, outputPath, assetsRootDir, budget = {}) {
+  const dirsToScan = [svgsDir, assetsRootDir].filter(
+    (d) => d !== void 0 && existsSync(d)
+  );
+  if (dirsToScan.length === 0) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const svgPaths = [];
+  for (const dir of dirsToScan) {
+    for (const f of readdirSync(dir).filter((f2) => f2.endsWith(".svg")).sort()) {
+      if (!seen.has(f)) {
+        seen.add(f);
+        svgPaths.push(join(dir, f));
+      }
+    }
+  }
+  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);
+  const tmpPaths = [];
+  const labels = [];
+  for (let i = 0; i < svgPaths.length; i++) {
+    if ((budget.remainingMs?.() ?? 1) <= 0) break;
+    const svgPath = svgPaths[i];
+    const tmpPath = join(tmpDir, `.thumb-${i}.png`);
+    try {
+      const svgBuf = readFileSync(svgPath);
+      const thumb = await sharp(svgBuf).resize(thumbSize, thumbSize, {
+        fit: "contain",
+        background: { r: 245, g: 245, b: 245, alpha: 1 }
+      }).flatten({ background: { r: 245, g: 245, b: 245 } }).png().toBuffer();
+      writeCaptureFileSync(tmpPath, thumb);
+      tmpPaths.push(tmpPath);
+      labels.push(svgFileNames[i].replace(".svg", ""));
+    } catch {
+    }
+  }
+  if (tmpPaths.length === 0) return [];
+  let results = [];
+  try {
+    results = await createContactSheetPages(
+      tmpPaths,
+      outputPath,
+      {
+        cols: 5,
+        cellWidth: thumbSize,
+        pageSize: 15,
+        ...budget
+      },
+      0,
+      labels
+    );
+  } finally {
+    for (const tmp of tmpPaths) {
+      try {
+        unlinkSync(tmp);
+      } catch {
+      }
+    }
+  }
+  return results;
+}
+
+export {
+  createContactSheet,
+  createScrollContactSheet,
+  createSnapshotContactSheet,
+  createAssetContactSheet,
+  createSvgContactSheet
+};