@gallop.software/studio 2.3.173 → 2.4.1

package/dist/cli/index.js

@@ -0,0 +1,1355 @@
+// @ts-nocheck
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config/workspace.ts
+import path from "path";
+function getWorkspace() {
+  if (workspacePath === null) {
+    workspacePath = process.env.STUDIO_WORKSPACE || process.cwd();
+  }
+  return workspacePath;
+}
+function getPublicPath(...segments) {
+  return path.join(getWorkspace(), "public", ...segments);
+}
+function getDataPath(...segments) {
+  return path.join(getWorkspace(), "_data", ...segments);
+}
+function getWorkspacePath(...segments) {
+  return path.join(getWorkspace(), ...segments);
+}
+var workspacePath;
+var init_workspace = __esm({
+  "src/config/workspace.ts"() {
+    "use strict";
+    workspacePath = null;
+  }
+});
+
+// src/config/index.ts
+var init_config = __esm({
+  "src/config/index.ts"() {
+    "use strict";
+    init_workspace();
+  }
+});
+
+// src/handlers/utils/meta.ts
+import { promises as fs } from "fs";
+import path2 from "path";
+async function loadMeta() {
+  const metaPath = getDataPath("_studio.json");
+  try {
+    const content = await fs.readFile(metaPath, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
+      return {};
+    }
+    if (err instanceof SyntaxError) {
+      const backupPath = metaPath + ".corrupt." + Date.now();
+      try {
+        await fs.rename(metaPath, backupPath);
+        console.warn(`[studio] _studio.json was corrupted. Backed up to ${path2.basename(backupPath)}`);
+      } catch {
+        console.warn("[studio] _studio.json was corrupted and could not be backed up");
+      }
+      return {};
+    }
+    throw err;
+  }
+}
+async function saveMeta(meta) {
+  const dataDir = getDataPath();
+  await fs.mkdir(dataDir, { recursive: true });
+  const metaPath = getDataPath("_studio.json");
+  const ordered = {};
+  if (meta._cdns) {
+    ordered._cdns = meta._cdns;
+  }
+  for (const [key, value] of Object.entries(meta)) {
+    if (key !== "_cdns") {
+      ordered[key] = value;
+    }
+  }
+  const tempPath = metaPath + ".tmp";
+  await fs.writeFile(tempPath, JSON.stringify(ordered, null, 2));
+  await fs.rename(tempPath, metaPath);
+}
+function getCdnUrls(meta) {
+  return meta._cdns || [];
+}
+function getOrAddCdnIndex(meta, cdnUrl) {
+  if (!meta._cdns) {
+    meta._cdns = [];
+  }
+  const normalizedUrl = cdnUrl.replace(/\/$/, "");
+  const existingIndex = meta._cdns.indexOf(normalizedUrl);
+  if (existingIndex >= 0) {
+    return existingIndex;
+  }
+  meta._cdns.push(normalizedUrl);
+  return meta._cdns.length - 1;
+}
+function getMetaEntry(meta, key) {
+  if (key.startsWith("_")) return void 0;
+  const value = meta[key];
+  if (Array.isArray(value)) return void 0;
+  return value;
+}
+function getFileEntries(meta) {
+  return Object.entries(meta).filter(
+    ([key, value]) => !key.startsWith("_") && !Array.isArray(value)
+  );
+}
+var init_meta = __esm({
+  "src/handlers/utils/meta.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/handlers/utils/files.ts
+import path3 from "path";
+function slugifyFilename(filename) {
+  const ext = path3.extname(filename).toLowerCase();
+  const baseName = path3.basename(filename, path3.extname(filename));
+  const slugged = baseName.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[_\s]+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const finalSlug = slugged || "file";
+  return finalSlug + ext;
+}
+function isImageFile(filename) {
+  const ext = path3.extname(filename).toLowerCase();
+  return [".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg", ".ico", ".bmp", ".tiff", ".tif"].includes(ext);
+}
+function isMediaFile(filename) {
+  const ext = path3.extname(filename).toLowerCase();
+  if ([".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg", ".ico", ".bmp", ".tiff", ".tif"].includes(ext)) return true;
+  if ([".mp4", ".webm", ".mov", ".avi", ".mkv", ".m4v"].includes(ext)) return true;
+  if ([".mp3", ".wav", ".ogg", ".m4a", ".flac", ".aac"].includes(ext)) return true;
+  if ([".pdf", ".json"].includes(ext)) return true;
+  return false;
+}
+function getContentType(filePath) {
+  const ext = path3.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".png":
+      return "image/png";
+    case ".gif":
+      return "image/gif";
+    case ".webp":
+      return "image/webp";
+    case ".svg":
+      return "image/svg+xml";
+    default:
+      return "application/octet-stream";
+  }
+}
+var init_files = __esm({
+  "src/handlers/utils/files.ts"() {
+    "use strict";
+  }
+});
+
+// src/handlers/utils/thumbnails.ts
+import { promises as fs2 } from "fs";
+import path4 from "path";
+import sharp from "sharp";
+async function processImage(buffer, imageKey) {
+  const rotatedBuffer = await sharp(buffer).rotate().toBuffer();
+  const metadata = await sharp(rotatedBuffer).metadata();
+  const originalWidth = metadata.width || 0;
+  const originalHeight = metadata.height || 0;
+  const ratio = originalHeight / originalWidth;
+  const keyWithoutSlash = imageKey.startsWith("/") ? imageKey.slice(1) : imageKey;
+  const baseName = path4.basename(
+    keyWithoutSlash,
+    path4.extname(keyWithoutSlash)
+  );
+  const ext = path4.extname(keyWithoutSlash).toLowerCase();
+  const imageDir = path4.dirname(keyWithoutSlash);
+  const imagesPath = getPublicPath("images", imageDir === "." ? "" : imageDir);
+  await fs2.mkdir(imagesPath, { recursive: true });
+  const isPng = ext === ".png";
+  const outputExt = isPng ? ".png" : ".jpg";
+  const entry = {
+    o: { w: originalWidth, h: originalHeight }
+  };
+  const fullFileName = imageDir === "." ? `${baseName}${outputExt}` : `${imageDir}/${baseName}${outputExt}`;
+  const fullPath = getPublicPath("images", fullFileName);
+  let fullWidth = originalWidth;
+  let fullHeight = originalHeight;
+  if (originalWidth > FULL_MAX_WIDTH) {
+    fullWidth = FULL_MAX_WIDTH;
+    fullHeight = Math.round(FULL_MAX_WIDTH * ratio);
+    if (isPng) {
+      await sharp(rotatedBuffer).resize(fullWidth, fullHeight).png({ quality: 85 }).toFile(fullPath);
+    } else {
+      await sharp(rotatedBuffer).resize(fullWidth, fullHeight).jpeg({ quality: 85 }).toFile(fullPath);
+    }
+  } else {
+    if (isPng) {
+      await sharp(rotatedBuffer).png({ quality: 85 }).toFile(fullPath);
+    } else {
+      await sharp(rotatedBuffer).jpeg({ quality: 85 }).toFile(fullPath);
+    }
+  }
+  entry.f = { w: fullWidth, h: fullHeight };
+  for (const [, sizeConfig] of Object.entries(DEFAULT_SIZES)) {
+    const { width: maxWidth, suffix, key } = sizeConfig;
+    if (originalWidth <= maxWidth) {
+      continue;
+    }
+    const newHeight = Math.round(maxWidth * ratio);
+    const sizeFileName = `${baseName}${suffix}${outputExt}`;
+    const sizeFilePath = imageDir === "." ? sizeFileName : `${imageDir}/${sizeFileName}`;
+    const sizePath = getPublicPath("images", sizeFilePath);
+    if (isPng) {
+      await sharp(rotatedBuffer).resize(maxWidth, newHeight).png({ quality: 80 }).toFile(sizePath);
+    } else {
+      await sharp(rotatedBuffer).resize(maxWidth, newHeight).jpeg({ quality: 80 }).toFile(sizePath);
+    }
+    entry[key] = { w: maxWidth, h: newHeight };
+  }
+  return entry;
+}
+var FULL_MAX_WIDTH, DEFAULT_SIZES;
+var init_thumbnails = __esm({
+  "src/handlers/utils/thumbnails.ts"() {
+    "use strict";
+    init_config();
+    FULL_MAX_WIDTH = 2560;
+    DEFAULT_SIZES = {
+      small: { width: 300, suffix: "-sm", key: "sm" },
+      medium: { width: 700, suffix: "-md", key: "md" },
+      large: { width: 1400, suffix: "-lg", key: "lg" }
+    };
+  }
+});
+
+// src/types.ts
+function getThumbnailPath(originalPath, size) {
+  if (size === "full") {
+    const ext2 = originalPath.match(/\.\w+$/)?.[0] || ".jpg";
+    const base2 = originalPath.replace(/\.\w+$/, "");
+    const outputExt2 = ext2.toLowerCase() === ".png" ? ".png" : ".jpg";
+    return `/images${base2}${outputExt2}`;
+  }
+  const ext = originalPath.match(/\.\w+$/)?.[0] || ".jpg";
+  const base = originalPath.replace(/\.\w+$/, "");
+  const outputExt = ext.toLowerCase() === ".png" ? ".png" : ".jpg";
+  return `/images${base}-${size}${outputExt}`;
+}
+function getAllThumbnailPaths(originalPath) {
+  return [
+    getThumbnailPath(originalPath, "full"),
+    getThumbnailPath(originalPath, "lg"),
+    getThumbnailPath(originalPath, "md"),
+    getThumbnailPath(originalPath, "sm")
+  ];
+}
+function isProcessed(entry) {
+  if (!entry) return false;
+  return !!(entry.f || entry.lg || entry.md || entry.sm);
+}
+var init_types = __esm({
+  "src/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/handlers/utils/cdn.ts
+import { S3Client, GetObjectCommand, PutObjectCommand, DeleteObjectCommand, CopyObjectCommand } from "@aws-sdk/client-s3";
+function getR2Client() {
+  const accountId = process.env.CLOUDFLARE_R2_ACCOUNT_ID;
+  const accessKeyId = process.env.CLOUDFLARE_R2_ACCESS_KEY_ID;
+  const secretAccessKey = process.env.CLOUDFLARE_R2_SECRET_ACCESS_KEY;
+  if (!accountId || !accessKeyId || !secretAccessKey) {
+    throw new Error("R2 not configured");
+  }
+  return new S3Client({
+    region: "auto",
+    endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
+    credentials: { accessKeyId, secretAccessKey }
+  });
+}
+async function downloadFromCdn(originalPath) {
+  const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
+  if (!bucketName) throw new Error("R2 bucket not configured");
+  const r2 = getR2Client();
+  const maxRetries = 3;
+  let lastError;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      const response = await r2.send(
+        new GetObjectCommand({
+          Bucket: bucketName,
+          Key: originalPath.replace(/^\//, "")
+        })
+      );
+      const stream = response.Body;
+      const chunks = [];
+      for await (const chunk of stream) {
+        chunks.push(Buffer.from(chunk));
+      }
+      return Buffer.concat(chunks);
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxRetries - 1) {
+        await new Promise((resolve) => setTimeout(resolve, 500 * (attempt + 1)));
+      }
+    }
+  }
+  throw lastError || new Error(`Failed to download ${originalPath} after ${maxRetries} attempts`);
+}
+async function downloadFromRemoteUrl(url) {
+  const maxRetries = 3;
+  let lastError;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Failed to download from ${url}: ${response.status}`);
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      return Buffer.from(arrayBuffer);
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxRetries - 1) {
+        await new Promise((resolve) => setTimeout(resolve, 500 * (attempt + 1)));
+      }
+    }
+  }
+  throw lastError || new Error(`Failed to download from ${url} after ${maxRetries} attempts`);
+}
+async function deleteThumbnailsFromCdn(imageKey) {
+  const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
+  if (!bucketName) throw new Error("R2 bucket not configured");
+  const r2 = getR2Client();
+  for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+    try {
+      await r2.send(
+        new DeleteObjectCommand({
+          Bucket: bucketName,
+          Key: thumbPath.replace(/^\//, "")
+        })
+      );
+    } catch {
+    }
+  }
+}
+async function deleteOriginalFromCdn(imageKey) {
+  const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
+  if (!bucketName) throw new Error("R2 bucket not configured");
+  const r2 = getR2Client();
+  try {
+    await r2.send(
+      new DeleteObjectCommand({
+        Bucket: bucketName,
+        Key: imageKey.replace(/^\//, "")
+      })
+    );
+  } catch {
+  }
+}
+var init_cdn = __esm({
+  "src/handlers/utils/cdn.ts"() {
+    "use strict";
+    init_types();
+    init_files();
+    init_config();
+  }
+});
+
+// src/handlers/utils/index.ts
+var init_utils = __esm({
+  "src/handlers/utils/index.ts"() {
+    "use strict";
+    init_meta();
+    init_files();
+    init_thumbnails();
+    init_cdn();
+  }
+});
+
+// src/cli/scan.ts
+var scan_exports = {};
+__export(scan_exports, {
+  runScan: () => runScan
+});
+import { promises as fs3 } from "fs";
+import path5 from "path";
+import sharp2 from "sharp";
+async function runScan(_args) {
+  console.log("Scanning for media files...");
+  const meta = await loadMeta();
+  const existingCount = Object.keys(meta).filter((k) => !k.startsWith("_")).length;
+  const existingKeys = new Set(Object.keys(meta));
+  const added = [];
+  const renamed = [];
+  const errors = [];
+  const orphanedFiles = [];
+  const pendingUpdates = [];
+  const allFiles = [];
+  async function scanDir(dir, relativePath = "") {
+    try {
+      const entries = await fs3.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".")) continue;
+        const fullPath = path5.join(dir, entry.name);
+        const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+        if (relPath === "images" || relPath.startsWith("images/")) continue;
+        if (entry.isDirectory()) {
+          await scanDir(fullPath, relPath);
+        } else if (isMediaFile(entry.name)) {
+          allFiles.push({ relativePath: relPath, fullPath });
+        }
+      }
+    } catch {
+    }
+  }
+  const publicDir = getPublicPath();
+  await scanDir(publicDir);
+  const total = allFiles.length;
+  for (let i = 0; i < allFiles.length; i++) {
+    let { relativePath, fullPath } = allFiles[i];
+    let imageKey = "/" + relativePath;
+    printProgress(i + 1, total, relativePath);
+    if (existingKeys.has(imageKey)) {
+      const entry = meta[imageKey];
+      if (entry?.c !== void 0 && !entry?.u) {
+        entry.u = 1;
+        pendingUpdates.push(imageKey);
+      }
+      continue;
+    }
+    const dirName = path5.dirname(relativePath);
+    const originalFileName = path5.basename(relativePath);
+    const sluggedFileName = slugifyFilename(originalFileName);
+    if (sluggedFileName !== originalFileName) {
+      const newRelativePath = dirName === "." ? sluggedFileName : `${dirName}/${sluggedFileName}`;
+      const newFullPath = getPublicPath(newRelativePath);
+      const newKey = "/" + newRelativePath;
+      if (!meta[newKey] && !existingKeys.has(newKey)) {
+        try {
+          await fs3.mkdir(path5.dirname(newFullPath), { recursive: true });
+          await fs3.rename(fullPath, newFullPath);
+          renamed.push({ from: relativePath, to: newRelativePath });
+          relativePath = newRelativePath;
+          fullPath = newFullPath;
+          imageKey = newKey;
+        } catch (err) {
+          console.error(`
+Failed to slugify ${relativePath}:`, err);
+        }
+      }
+    }
+    if (meta[imageKey]) {
+      const ext = path5.extname(relativePath);
+      const baseName = relativePath.slice(0, -ext.length);
+      let counter = 1;
+      let newKey = `/${baseName}-${counter}${ext}`;
+      while (meta[newKey]) {
+        counter++;
+        newKey = `/${baseName}-${counter}${ext}`;
+      }
+      const newRelativePath = `${baseName}-${counter}${ext}`;
+      const newFullPath = getPublicPath(newRelativePath);
+      try {
+        await fs3.rename(fullPath, newFullPath);
+        renamed.push({ from: relativePath, to: newRelativePath });
+        relativePath = newRelativePath;
+        fullPath = newFullPath;
+        imageKey = newKey;
+      } catch (err) {
+        console.error(`
+Failed to rename ${relativePath}:`, err);
+        errors.push(`Failed to rename ${relativePath}`);
+        continue;
+      }
+    }
+    try {
+      const isImage = isImageFile(relativePath);
+      if (isImage) {
+        const ext = path5.extname(relativePath).toLowerCase();
+        if (ext === ".svg") {
+          meta[imageKey] = { o: { w: 0, h: 0 } };
+        } else {
+          try {
+            const buffer = await fs3.readFile(fullPath);
+            const rotatedBuffer = await sharp2(buffer).rotate().toBuffer();
+            const metadata = await sharp2(rotatedBuffer).metadata();
+            meta[imageKey] = {
+              o: { w: metadata.width || 0, h: metadata.height || 0 }
+            };
+          } catch {
+            meta[imageKey] = { o: { w: 0, h: 0 } };
+          }
+        }
+      } else {
+        meta[imageKey] = {};
+      }
+      existingKeys.add(imageKey);
+      added.push(imageKey);
+      if (added.length % 10 === 0) {
+        await saveMeta(meta);
+      }
+    } catch (error) {
+      console.error(`
+Failed to process ${relativePath}:`, error);
+      errors.push(relativePath);
+    }
+  }
+  process.stdout.write("\n");
+  console.log("  Checking for orphaned thumbnails...");
+  const expectedThumbnails = /* @__PURE__ */ new Set();
+  const fileEntries = getFileEntries(meta);
+  for (const [imageKey, entry] of fileEntries) {
+    if (entry.c === void 0 && isProcessed(entry)) {
+      for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+        expectedThumbnails.add(thumbPath);
+      }
+    }
+  }
+  async function findOrphans(dir, relativePath = "") {
+    try {
+      const entries = await fs3.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".")) continue;
+        const fullPath = path5.join(dir, entry.name);
+        const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+          await findOrphans(fullPath, relPath);
+        } else if (isImageFile(entry.name)) {
+          const publicPath = `/images/${relPath}`;
+          if (!expectedThumbnails.has(publicPath)) {
+            orphanedFiles.push(publicPath);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const imagesDir = getPublicPath("images");
+  try {
+    await findOrphans(imagesDir);
+  } catch {
+  }
+  console.log("  Cleaning up empty folders...");
+  let emptyFoldersDeleted = 0;
+  async function cleanEmptyFolders(dir) {
+    try {
+      const entries = await fs3.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".")) continue;
+        if (!entry.isDirectory()) continue;
+        const fullPath = path5.join(dir, entry.name);
+        if (fullPath === imagesDir) continue;
+        await cleanEmptyFolders(fullPath);
+        try {
+          const subEntries = await fs3.readdir(fullPath);
+          const meaningfulEntries = subEntries.filter((e) => !e.startsWith("."));
+          if (meaningfulEntries.length === 0) {
+            await fs3.rm(fullPath, { recursive: true });
+            emptyFoldersDeleted++;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  await cleanEmptyFolders(getPublicPath());
+  async function cleanImagesEmptyFolders(dir) {
+    try {
+      const entries = await fs3.readdir(dir, { withFileTypes: true });
+      let isEmpty = true;
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const subDirEmpty = await cleanImagesEmptyFolders(path5.join(dir, entry.name));
+          if (!subDirEmpty) isEmpty = false;
+        } else if (!entry.name.startsWith(".")) {
+          isEmpty = false;
+        }
+      }
+      if (isEmpty && dir !== imagesDir) {
+        await fs3.rm(dir, { recursive: true });
+        emptyFoldersDeleted++;
+      }
+      return isEmpty;
+    } catch {
+      return true;
+    }
+  }
+  try {
+    await cleanImagesEmptyFolders(imagesDir);
+  } catch {
+  }
+  console.log("  Checking for orphaned entries...");
+  const orphanedEntries = [];
+  for (const key of Object.keys(meta)) {
+    if (key.startsWith("_")) continue;
+    const entry = meta[key];
+    if (!entry) continue;
+    if (entry.c !== void 0) {
+      if (entry.u === 1) {
+        const localPath2 = getPublicPath(key);
+        try {
+          await fs3.access(localPath2);
+        } catch {
+          delete entry.u;
+        }
+      }
+      continue;
+    }
+    const localPath = getPublicPath(key);
+    try {
+      await fs3.access(localPath);
+    } catch {
+      orphanedEntries.push(key);
+      delete meta[key];
+    }
+  }
+  await saveMeta(meta);
+  const parts = [];
+  parts.push(`${existingCount} existing`);
+  if (added.length > 0) parts.push(`${added.length} added`);
+  if (renamed.length > 0) parts.push(`${renamed.length} renamed`);
+  if (errors.length > 0) parts.push(`${errors.length} errors`);
+  if (orphanedFiles.length > 0) parts.push(`${orphanedFiles.length} orphaned thumbnails`);
+  if (orphanedEntries.length > 0) parts.push(`${orphanedEntries.length} orphaned entries removed`);
+  if (pendingUpdates.length > 0) parts.push(`${pendingUpdates.length} pending updates`);
+  if (emptyFoldersDeleted > 0) parts.push(`${emptyFoldersDeleted} empty folders removed`);
+  printComplete(`Scan complete. ${parts.join(", ")}.`);
+}
+var init_scan = __esm({
+  "src/cli/scan.ts"() {
+    "use strict";
+    init_cli();
+    init_utils();
+    init_types();
+    init_config();
+  }
+});
+
+// src/cli/process.ts
+var process_exports = {};
+__export(process_exports, {
+  runProcess: () => runProcess
+});
+import { promises as fs4 } from "fs";
+import path6 from "path";
+async function runProcess(args) {
+  const prefix = args[0] || "";
+  if (prefix) {
+    console.log(`Processing unprocessed images matching "/${prefix}"...`);
+  } else {
+    console.log("Processing all unprocessed images...");
+  }
+  const meta = await loadMeta();
+  const processed = [];
+  const errors = [];
+  let alreadyProcessed = 0;
+  const imagesToProcess = [];
+  for (const [key, entry] of getFileEntries(meta)) {
+    const fileName = path6.basename(key);
+    if (!isImageFile(fileName)) continue;
+    if (prefix && !key.startsWith(`/${prefix}`)) continue;
+    if (!isProcessed(entry)) {
+      imagesToProcess.push({ key });
+    } else {
+      alreadyProcessed++;
+    }
+  }
+  if (imagesToProcess.length === 0) {
+    console.log(`No unprocessed images found${prefix ? ` matching "/${prefix}"` : ""}. ${alreadyProcessed} already processed.`);
+    return;
+  }
+  const total = imagesToProcess.length;
+  console.log(`Found ${total} unprocessed image${total !== 1 ? "s" : ""} (${alreadyProcessed} already processed)`);
+  for (let i = 0; i < imagesToProcess.length; i++) {
+    const { key } = imagesToProcess[i];
+    const fullPath = getPublicPath(key);
+    printProgress(i + 1, total, key.slice(1));
+    try {
+      let buffer;
+      try {
+        buffer = await fs4.readFile(fullPath);
+      } catch {
+        printError2(`File not found: ${key}`);
+        errors.push(key);
+        continue;
+      }
+      const ext = path6.extname(key).toLowerCase();
+      const isSvg = ext === ".svg";
+      if (isSvg) {
+        const imageDir = path6.dirname(key.slice(1));
+        const imagesPath = getPublicPath("images", imageDir === "." ? "" : imageDir);
+        await fs4.mkdir(imagesPath, { recursive: true });
+        const fileName = path6.basename(key);
+        const destPath = path6.join(imagesPath, fileName);
+        await fs4.writeFile(destPath, buffer);
+        const existingEntry = meta[key];
+        meta[key] = {
+          ...typeof existingEntry === "object" && !Array.isArray(existingEntry) ? existingEntry : {},
+          o: { w: 0, h: 0 },
+          f: { w: 0, h: 0 }
+        };
+      } else {
+        const updatedEntry = await processImage(buffer, key);
+        meta[key] = updatedEntry;
+      }
+      await saveMeta(meta);
+      processed.push(key);
+    } catch (error) {
+      console.error(`
+Failed to process ${key}:`, error);
+      errors.push(key);
+    }
+  }
+  await saveMeta(meta);
+  const parts = [];
+  parts.push(`${processed.length} processed`);
+  if (errors.length > 0) parts.push(`${errors.length} failed`);
+  if (errors.length > 0) {
+    printError2(`Processing complete. ${parts.join(", ")}.`);
+  } else {
+    printComplete(`Processing complete. ${parts.join(", ")}.`);
+  }
+}
+var init_process = __esm({
+  "src/cli/process.ts"() {
+    "use strict";
+    init_cli();
+    init_utils();
+    init_types();
+    init_config();
+  }
+});
+
+// src/handlers/utils/folders.ts
+import { promises as fs5 } from "fs";
+import path7 from "path";
+function isHiddenOrSystemFile(filename) {
+  if (filename.startsWith(".")) return true;
+  const windowsSystemFiles = ["thumbs.db", "desktop.ini", "ehthumbs.db", "ehthumbs_vista.db"];
+  if (windowsSystemFiles.includes(filename.toLowerCase())) return true;
+  return false;
+}
+async function deleteEmptyFolders(folderPath) {
+  const publicPath = getPublicPath();
+  const normalizedFolder = path7.resolve(folderPath);
+  const normalizedPublic = path7.resolve(publicPath);
+  if (normalizedFolder === normalizedPublic) {
+    return;
+  }
+  if (!normalizedFolder.startsWith(normalizedPublic)) {
+    return;
+  }
+  try {
+    const entries = await fs5.readdir(folderPath);
+    const meaningfulEntries = entries.filter((e) => !isHiddenOrSystemFile(e));
+    if (meaningfulEntries.length === 0) {
+      for (const entry of entries) {
+        if (isHiddenOrSystemFile(entry)) {
+          try {
+            await fs5.unlink(path7.join(folderPath, entry));
+          } catch {
+          }
+        }
+      }
+      await fs5.rmdir(folderPath);
+      const parentFolder = path7.dirname(folderPath);
+      await deleteEmptyFolders(parentFolder);
+    }
+  } catch {
+  }
+}
+var init_folders = __esm({
+  "src/handlers/utils/folders.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/cli/push.ts
+var push_exports = {};
+__export(push_exports, {
+  runPush: () => runPush
+});
+import { promises as fs6 } from "fs";
+import path8 from "path";
+import { S3Client as S3Client2, PutObjectCommand as PutObjectCommand2 } from "@aws-sdk/client-s3";
+async function runPush(args) {
+  const prefix = args[0] || "";
+  const accountId = process.env.CLOUDFLARE_R2_ACCOUNT_ID;
+  const accessKeyId = process.env.CLOUDFLARE_R2_ACCESS_KEY_ID;
+  const secretAccessKey = process.env.CLOUDFLARE_R2_SECRET_ACCESS_KEY;
+  const bucketName = process.env.CLOUDFLARE_R2_BUCKET_NAME;
+  const publicUrl = process.env.CLOUDFLARE_R2_PUBLIC_URL?.replace(/\/\s*$/, "");
+  if (!accountId || !accessKeyId || !secretAccessKey || !bucketName || !publicUrl) {
+    printError2("R2 not configured. Set CLOUDFLARE_R2_* environment variables in .env.local");
+    process.exit(1);
+  }
+  if (prefix) {
+    console.log(`Pushing local images matching "/${prefix}" to CDN...`);
+  } else {
+    console.log("Pushing all local images to CDN...");
+  }
+  const meta = await loadMeta();
+  const cdnUrls = getCdnUrls(meta);
+  const cdnIndex = getOrAddCdnIndex(meta, publicUrl);
+  const r2 = new S3Client2({
+    region: "auto",
+    endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
+    credentials: { accessKeyId, secretAccessKey }
+  });
+  const imagesToPush = [];
+  for (const [key, entry] of getFileEntries(meta)) {
+    if (prefix && !key.startsWith(`/${prefix}`)) continue;
+    const existingCdnUrl = entry.c !== void 0 ? cdnUrls[entry.c] : void 0;
+    if (existingCdnUrl === publicUrl) continue;
+    imagesToPush.push(key);
+  }
+  if (imagesToPush.length === 0) {
+    console.log(`No local images to push${prefix ? ` matching "/${prefix}"` : ""}.`);
+    return;
+  }
+  const total = imagesToPush.length;
+  console.log(`Pushing ${total} image${total !== 1 ? "s" : ""} to CDN...`);
+  const pushed = [];
+  const errors = [];
+  const sourceFolders = /* @__PURE__ */ new Set();
+  for (let i = 0; i < imagesToPush.length; i++) {
+    const imageKey = imagesToPush[i];
+    const entry = getMetaEntry(meta, imageKey);
+    printProgress(i + 1, total, path8.basename(imageKey));
+    if (!entry) {
+      errors.push(`Not in meta: ${imageKey}`);
+      continue;
+    }
+    const existingCdnUrl = entry.c !== void 0 ? cdnUrls[entry.c] : void 0;
+    const isRemote = entry.c !== void 0 && existingCdnUrl !== publicUrl;
+    try {
+      let originalBuffer;
+      if (isRemote && existingCdnUrl) {
+        const remoteUrl = `${existingCdnUrl}${imageKey}`;
+        originalBuffer = await downloadFromRemoteUrl(remoteUrl);
+      } else {
+        const originalLocalPath = getPublicPath(imageKey);
+        try {
+          originalBuffer = await fs6.readFile(originalLocalPath);
+        } catch {
+          errors.push(`File not found: ${imageKey}`);
+          continue;
+        }
+      }
+      await r2.send(
+        new PutObjectCommand2({
+          Bucket: bucketName,
+          Key: imageKey.replace(/^\//, ""),
+          Body: originalBuffer,
+          ContentType: getContentType(imageKey)
+        })
+      );
+      if (!isRemote && isProcessed(entry)) {
+        for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+          const localPath = getPublicPath(thumbPath);
+          try {
+            const fileBuffer = await fs6.readFile(localPath);
+            await r2.send(
+              new PutObjectCommand2({
+                Bucket: bucketName,
+                Key: thumbPath.replace(/^\//, ""),
+                Body: fileBuffer,
+                ContentType: getContentType(thumbPath)
+              })
+            );
+          } catch {
+          }
+        }
+      }
+      entry.c = cdnIndex;
+      if (!isRemote) {
+        const originalLocalPath = getPublicPath(imageKey);
+        sourceFolders.add(path8.dirname(originalLocalPath));
+        for (const thumbPath of getAllThumbnailPaths(imageKey)) {
+          const localPath = getPublicPath(thumbPath);
+          sourceFolders.add(path8.dirname(localPath));
+          try {
+            await fs6.unlink(localPath);
+          } catch {
+          }
+        }
+        try {
+          await fs6.unlink(originalLocalPath);
+        } catch {
+        }
+      }
+      await saveMeta(meta);
+      pushed.push(imageKey);
+    } catch (error) {
+      console.error(`
+Failed to push ${imageKey}:`, error);
+      errors.push(`Failed: ${imageKey}`);
+    }
+  }
+  for (const folder of sourceFolders) {
+    await deleteEmptyFolders(folder);
+  }
+  const parts = [];
+  parts.push(`${pushed.length} pushed`);
+  if (errors.length > 0) parts.push(`${errors.length} failed`);
+  if (errors.length > 0) {
+    printError2(`Push complete. ${parts.join(", ")}.`);
+  } else {
+    printComplete(`Push complete. ${parts.join(", ")}.`);
+  }
+}
+var init_push = __esm({
+  "src/cli/push.ts"() {
+    "use strict";
+    init_cli();
+    init_utils();
+    init_types();
+    init_config();
+    init_folders();
+  }
+});
+
+// src/cli/download.ts
+var download_exports = {};
+__export(download_exports, {
+  runDownload: () => runDownload
+});
+import { promises as fs7 } from "fs";
+import path9 from "path";
+async function runDownload(args) {
+  const prefix = args[0] || "";
+  if (prefix) {
+    console.log(`Downloading cloud images matching "/${prefix}" to local...`);
+  } else {
+    console.log("Downloading all cloud images to local...");
+  }
+  const meta = await loadMeta();
+  const imagesToDownload = [];
+  for (const [key, entry] of getFileEntries(meta)) {
+    if (prefix && !key.startsWith(`/${prefix}`)) continue;
+    if (entry.c === void 0) continue;
+    imagesToDownload.push(key);
+  }
+  if (imagesToDownload.length === 0) {
+    console.log(`No cloud images to download${prefix ? ` matching "/${prefix}"` : ""}.`);
+    return;
+  }
+  const total = imagesToDownload.length;
+  console.log(`Downloading ${total} image${total !== 1 ? "s" : ""} from CDN...`);
+  const downloaded = [];
+  const errors = [];
+  for (let i = 0; i < imagesToDownload.length; i++) {
+    const imageKey = imagesToDownload[i];
+    const entry = getMetaEntry(meta, imageKey);
+    printProgress(i + 1, total, path9.basename(imageKey));
+    if (!entry || entry.c === void 0) {
+      errors.push(`Not on cloud: ${imageKey}`);
+      continue;
+    }
+    try {
+      const imageBuffer = await downloadFromCdn(imageKey);
+      const localPath = getPublicPath(imageKey.replace(/^\//, ""));
+      await fs7.mkdir(path9.dirname(localPath), { recursive: true });
+      await fs7.writeFile(localPath, imageBuffer);
+      await deleteOriginalFromCdn(imageKey);
+      await deleteThumbnailsFromCdn(imageKey);
+      const wasProcessed = isProcessed(entry);
+      delete entry.c;
+      if (wasProcessed) {
+        const processedEntry = await processImage(imageBuffer, imageKey);
+        entry.sm = processedEntry.sm;
+        entry.md = processedEntry.md;
+        entry.lg = processedEntry.lg;
+        entry.f = processedEntry.f;
+      }
+      await saveMeta(meta);
+      downloaded.push(imageKey);
+    } catch (error) {
+      console.error(`
+Failed to download ${imageKey}:`, error);
+      errors.push(imageKey);
+    }
+  }
+  await saveMeta(meta);
+  const parts = [];
+  parts.push(`${downloaded.length} downloaded`);
+  if (errors.length > 0) parts.push(`${errors.length} failed`);
+  if (errors.length > 0) {
+    printError2(`Download complete. ${parts.join(", ")}.`);
+  } else {
+    printComplete(`Download complete. ${parts.join(", ")}.`);
+  }
+}
+var init_download = __esm({
+  "src/cli/download.ts"() {
+    "use strict";
+    init_cli();
+    init_utils();
+    init_types();
+    init_config();
+  }
+});
+
+// src/handlers/utils/response.ts
+var init_response = __esm({
+  "src/handlers/utils/response.ts"() {
+    "use strict";
+  }
+});
+
+// src/handlers/utils/errors.ts
+var init_errors = __esm({
+  "src/handlers/utils/errors.ts"() {
+    "use strict";
+  }
+});
+
+// src/handlers/utils/cancellation.ts
+var init_cancellation = __esm({
+  "src/handlers/utils/cancellation.ts"() {
+    "use strict";
+  }
+});
+
+// src/handlers/fonts.ts
+function parseFontMetadata(filename) {
+  const name = filename.toLowerCase();
+  let weight = "400";
+  let style = "normal";
+  const isVariable = name.includes("variable");
+  if (isVariable) {
+    weight = "100 900";
+  } else {
+    const numericMatch = name.match(/[-_]w?(\d{3})(?:[-_.]|$)/);
+    if (numericMatch) {
+      const num = parseInt(numericMatch[1]);
+      if (num >= 100 && num <= 900 && num % 100 === 0) {
+        weight = String(num);
+      }
+    } else {
+      if (name.includes("ultralight")) weight = weightMap.ultralight;
+      else if (name.includes("extralight")) weight = weightMap.extralight;
+      else if (name.includes("ultrabold")) weight = weightMap.ultrabold;
+      else if (name.includes("extrabold")) weight = weightMap.extrabold;
+      else if (name.includes("demibold")) weight = weightMap.demibold;
+      else if (name.includes("semibold")) weight = weightMap.semibold;
+      else if (name.includes("hairline")) weight = weightMap.hairline;
+      else if (name.includes("thin")) weight = weightMap.thin;
+      else if (name.includes("light")) weight = weightMap.light;
+      else if (name.includes("heavy")) weight = weightMap.heavy;
+      else if (name.includes("black")) weight = weightMap.black;
+      else if (name.includes("bold")) weight = weightMap.bold;
+      else if (name.includes("medium")) weight = weightMap.medium;
+      else if (name.includes("book")) weight = weightMap.book;
+      else if (name.includes("regular")) weight = weightMap.regular;
+    }
+  }
+  if (name.includes("italic")) style = "italic";
+  return { weight, style, isVariable };
+}
+var weightMap;
+var init_fonts = __esm({
+  "src/handlers/fonts.ts"() {
+    "use strict";
+    init_config();
+    init_response();
+    init_files();
+    init_errors();
+    init_cancellation();
+    weightMap = {
+      thin: "100",
+      hairline: "100",
+      extralight: "200",
+      ultralight: "200",
+      light: "300",
+      regular: "400",
+      book: "400",
+      medium: "500",
+      semibold: "600",
+      demibold: "600",
+      bold: "700",
+      extrabold: "800",
+      ultrabold: "800",
+      black: "900",
+      heavy: "900"
+    };
+  }
+});
+
+// src/cli/fonts.ts
+var fonts_exports = {};
+__export(fonts_exports, {
+  runFonts: () => runFonts
+});
+import { promises as fs8 } from "fs";
+import path10 from "path";
+async function runFonts(args) {
+  const subcommand = args[0];
+  if (!subcommand) {
+    console.error("Usage:");
+    console.error("  studio fonts woff2 <folder>    Convert TTF/OTF to woff2");
+    console.error("  studio fonts assign <folder> --name <name>  Generate src/fonts/<name>.ts");
+    process.exit(1);
+  }
+  switch (subcommand) {
+    case "woff2":
+      await runFontsWoff2(args.slice(1));
+      break;
+    case "assign":
+      await runFontsAssign(args.slice(1));
+      break;
+    default:
+      console.error(`Unknown fonts subcommand: ${subcommand}`);
+      console.error("Available: woff2, assign");
+      process.exit(1);
+  }
+}
+async function runFontsWoff2(args) {
+  const folder = args[0];
+  if (!folder) {
+    console.error("Usage: studio fonts woff2 <folder>");
+    console.error("  <folder> is the folder name inside _fonts/");
+    process.exit(1);
+  }
+  const folderPath = getWorkspacePath("_fonts", folder);
+  try {
+    const stat = await fs8.stat(folderPath);
+    if (!stat.isDirectory()) {
+      printError2(`Not a directory: _fonts/${folder}`);
+      process.exit(1);
+    }
+  } catch {
+    printError2(`Folder not found: _fonts/${folder}`);
+    process.exit(1);
+  }
+  const entries = await fs8.readdir(folderPath);
+  const sourceFiles = entries.filter((f) => {
+    const lower = f.toLowerCase();
+    return lower.endsWith(".ttf") || lower.endsWith(".otf");
+  });
+  if (sourceFiles.length === 0) {
+    console.log(`No TTF/OTF files found in _fonts/${folder}/`);
+    return;
+  }
+  console.log(`Converting ${sourceFiles.length} font file${sourceFiles.length !== 1 ? "s" : ""} to woff2...`);
+  const ttf2woff2Module = await import("ttf2woff2");
+  const ttf2woff2 = ttf2woff2Module.default;
+  const converted = [];
+  const errors = [];
+  for (let i = 0; i < sourceFiles.length; i++) {
+    const sourceFile = sourceFiles[i];
+    const sourceExt = path10.extname(sourceFile);
+    const baseName = path10.basename(sourceFile, sourceExt);
+    const woff2Name = baseName + ".woff2";
+    printProgress(i + 1, sourceFiles.length, sourceFile);
+    try {
+      const sourcePath = path10.join(folderPath, sourceFile);
+      const input = await fs8.readFile(sourcePath);
+      const woff2Data = ttf2woff2(input);
+      await fs8.writeFile(path10.join(folderPath, woff2Name), woff2Data);
+      converted.push(woff2Name);
+    } catch (error) {
+      console.error(`
+Failed to convert ${sourceFile}:`, error);
+      errors.push(sourceFile);
+    }
+  }
+  if (errors.length > 0) {
+    printError2(`Converted ${converted.length} files, ${errors.length} failed.`);
+  } else {
+    printComplete(`Converted ${converted.length} file${converted.length !== 1 ? "s" : ""} to woff2.`);
+  }
+}
+async function runFontsAssign(args) {
+  const folder = args[0];
+  let name = "";
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--name" && args[i + 1]) {
+      name = args[i + 1];
+      break;
+    }
+  }
+  if (!folder || !name) {
+    console.error("Usage: studio fonts assign <folder> --name <name>");
+    console.error("  <folder> is the folder name inside _fonts/");
+    console.error("  <name> is the variable name for src/fonts/<name>.ts");
+    process.exit(1);
+  }
+  if (!/^[a-zA-Z][a-zA-Z0-9]*$/.test(name)) {
+    printError2(`Invalid assignment name: ${name}. Must start with a letter and contain only letters/numbers.`);
+    process.exit(1);
+  }
+  const folderPath = getWorkspacePath("_fonts", folder);
+  try {
+    const stat = await fs8.stat(folderPath);
+    if (!stat.isDirectory()) {
+      printError2(`Not a directory: _fonts/${folder}`);
+      process.exit(1);
+    }
+  } catch {
+    printError2(`Folder not found: _fonts/${folder}`);
+    process.exit(1);
+  }
+  const entries = await fs8.readdir(folderPath);
+  const woff2Files = entries.filter((f) => f.toLowerCase().endsWith(".woff2"));
+  if (woff2Files.length === 0) {
+    printError2(`No woff2 files found in _fonts/${folder}/. Run 'studio fonts woff2 ${folder}' first.`);
+    process.exit(1);
+  }
+  console.log(`Generating font assignment from ${woff2Files.length} woff2 file${woff2Files.length !== 1 ? "s" : ""}...`);
+  const fontMap = woff2Files.map((file) => {
+    const baseName = path10.basename(file, ".woff2");
+    const { weight, style } = parseFontMetadata(baseName);
+    return { path: `${folder}/${file}`, weight, style };
+  });
+  fontMap.sort((a, b) => {
+    const wa = parseInt(a.weight) || 400;
+    const wb = parseInt(b.weight) || 400;
+    if (wa !== wb) return wa - wb;
+    return a.style === "normal" ? -1 : 1;
+  });
+  const variableName = `${name}Font`;
+  const srcArray = fontMap.map((font) => `    { path: '../../_fonts/${font.path}', weight: '${font.weight}', style: '${font.style}' },`).join("\n");
+  const template = `import localFont from 'next/font/local'
+
+export const ${variableName} = localFont({
+  src: [
+${srcArray}
+  ],
+  display: 'swap',
+})
+`;
+  const srcFontsPath = getWorkspacePath("src/fonts");
+  await fs8.mkdir(srcFontsPath, { recursive: true });
+  const filePath = path10.join(srcFontsPath, `${name}.ts`);
+  let overwritten = false;
+  try {
+    await fs8.stat(filePath);
+    overwritten = true;
+  } catch {
+  }
+  await fs8.writeFile(filePath, template, "utf8");
+  if (overwritten) {
+    printComplete(`Overwrote src/fonts/${name}.ts with ${woff2Files.length} font source${woff2Files.length !== 1 ? "s" : ""}.`);
+  } else {
+    printComplete(`Created src/fonts/${name}.ts with ${woff2Files.length} font source${woff2Files.length !== 1 ? "s" : ""}.`);
+  }
+  for (const font of fontMap) {
+    const weightName = getWeightNameLocal(font.weight);
+    console.log(`  ${font.path} -> ${weightName} ${font.style}`);
+  }
+}
+function getWeightNameLocal(weight) {
+  if (weight === "100 900") return "Variable";
+  const names = {
+    "100": "Thin",
+    "200": "ExtraLight",
+    "300": "Light",
+    "400": "Regular",
+    "500": "Medium",
+    "600": "SemiBold",
+    "700": "Bold",
+    "800": "ExtraBold",
+    "900": "Black"
+  };
+  return names[weight] || weight;
+}
+var init_fonts2 = __esm({
+  "src/cli/fonts.ts"() {
+    "use strict";
+    init_cli();
+    init_fonts();
+    init_config();
+  }
+});
+
+// src/cli/index.ts
+import { config as loadEnv } from "dotenv";
+import { join } from "path";
+import { existsSync } from "fs";
+function printProgress(current, total, message) {
+  const pct = Math.round(current / total * 100);
+  process.stdout.write(`\r  [${current}/${total}] ${pct}% ${message}`);
+}
+function printComplete(message) {
+  process.stdout.write("\n");
+  console.log(`\u2713 ${message}`);
+}
+function printError2(message) {
+  process.stderr.write("\n");
+  console.error(`\u2717 ${message}`);
+}
+async function run(command, workspace, args) {
+  process.env.STUDIO_WORKSPACE = workspace;
+  const envPath = join(workspace, ".env.local");
+  if (existsSync(envPath)) {
+    loadEnv({ path: envPath });
+  }
+  try {
+    switch (command) {
+      case "scan": {
+        const { runScan: runScan2 } = await Promise.resolve().then(() => (init_scan(), scan_exports));
+        await runScan2(args);
+        break;
+      }
+      case "process": {
+        const { runProcess: runProcess2 } = await Promise.resolve().then(() => (init_process(), process_exports));
+        await runProcess2(args);
+        break;
+      }
+      case "push": {
+        const { runPush: runPush2 } = await Promise.resolve().then(() => (init_push(), push_exports));
+        await runPush2(args);
+        break;
+      }
+      case "download": {
+        const { runDownload: runDownload2 } = await Promise.resolve().then(() => (init_download(), download_exports));
+        await runDownload2(args);
+        break;
+      }
+      case "fonts": {
+        const { runFonts: runFonts2 } = await Promise.resolve().then(() => (init_fonts2(), fonts_exports));
+        await runFonts2(args);
+        break;
+      }
+      default:
+        console.error(`Unknown command: ${command}`);
+        console.error("Available commands: scan, process, push, download, fonts");
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error("Command failed:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+var init_cli = __esm({
+  "src/cli/index.ts"() {
+  }
+});
+init_cli();
+export {
+  printComplete,
+  printError2 as printError,
+  printProgress,
+  run
+};
+//# sourceMappingURL=index.js.map