vite-plugin-asset-manager 0.0.1

package/dist/index.cjs

@@ -0,0 +1,1837 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  assetManager: () => assetManager,
+  default: () => assetManager
+});
+module.exports = __toCommonJS(index_exports);
+
+// node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/plugin.ts
+var import_picocolors = __toESM(require("picocolors"), 1);
+
+// src/server/index.ts
+var import_sirv = __toESM(require("sirv"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var import_fs2 = __toESM(require("fs"), 1);
+var import_url2 = require("url");
+
+// src/server/api.ts
+var import_url = require("url");
+var import_path2 = __toESM(require("path"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var import_archiver = __toESM(require("archiver"), 1);
+
+// src/server/editor-launcher.ts
+var import_launch_editor = __toESM(require("launch-editor"), 1);
+function launchEditor(absolutePath, line, column, editor) {
+  return new Promise((resolve, reject) => {
+    const fileSpec = `${absolutePath}:${line}:${column}`;
+    (0, import_launch_editor.default)(fileSpec, editor, (_fileName, errorMsg) => {
+      if (errorMsg) {
+        reject(new Error(errorMsg));
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
+// src/server/file-revealer.ts
+var import_child_process = require("child_process");
+var import_path = __toESM(require("path"), 1);
+async function revealInFileExplorer(absolutePath) {
+  return new Promise((resolve, reject) => {
+    const platform = process.platform;
+    let command;
+    let args;
+    switch (platform) {
+      case "darwin":
+        command = "open";
+        args = ["-R", absolutePath];
+        break;
+      case "win32":
+        command = "explorer";
+        args = ["/select,", absolutePath];
+        break;
+      case "linux": {
+        const directory = import_path.default.dirname(absolutePath);
+        command = "xdg-open";
+        args = [directory];
+        break;
+      }
+      default:
+        return reject(new Error(`Unsupported platform: ${platform}`));
+    }
+    const child = (0, import_child_process.spawn)(command, args);
+    child.on("error", (error) => {
+      reject(new Error(`Failed to reveal file: ${error.message}`));
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Reveal command exited with code ${code}`));
+      }
+    });
+  });
+}
+
+// src/server/api.ts
+var sseClients = /* @__PURE__ */ new Set();
+var MIME_TYPES = {
+  /**
+   * Images:
+   */
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".ico": "image/x-icon",
+  ".bmp": "image/bmp",
+  ".tiff": "image/tiff",
+  ".tif": "image/tiff",
+  ".heic": "image/heic",
+  ".heif": "image/heif",
+  /**
+   * Videos:
+   */
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".ogg": "video/ogg",
+  ".mov": "video/quicktime",
+  /**
+   * Audio:
+   */
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  /**
+   * Documents:
+   */
+  ".pdf": "application/pdf",
+  ".json": "application/json",
+  ".md": "text/markdown",
+  ".txt": "text/plain",
+  ".csv": "text/csv",
+  /**
+   * Config files:
+   */
+  ".yml": "text/yaml",
+  ".yaml": "text/yaml",
+  ".toml": "application/toml",
+  ".xml": "application/xml",
+  /**
+   * Fonts:
+   */
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".eot": "application/vnd.ms-fontobject"
+};
+function createApiRouter(scanner, importerScanner, duplicateScanner, thumbnailService, root, basePath, editor) {
+  return async (req, res, next) => {
+    const { pathname, query } = (0, import_url.parse)(req.url || "", true);
+    const apiPath = pathname?.replace(`${basePath}/api`, "") || "";
+    try {
+      switch (apiPath) {
+        case "/assets":
+          return handleGetAssets(res, scanner, query);
+        case "/assets/grouped":
+          return handleGetGroupedAssets(res, scanner, query);
+        case "/search":
+          return handleSearch(res, scanner, query);
+        case "/thumbnail":
+          return handleThumbnail(res, thumbnailService, root, query);
+        case "/file":
+          return handleServeFile(res, root, query);
+        case "/stats":
+          return handleGetStats(res, scanner, duplicateScanner);
+        case "/duplicates":
+          return handleGetDuplicates(res, scanner, duplicateScanner, query);
+        case "/importers":
+          return handleGetImporters(res, importerScanner, query);
+        case "/open-in-editor":
+          return handleOpenInEditor(req, res, root, editor, query);
+        case "/reveal-in-finder":
+          return handleRevealInFinder(req, res, root, query);
+        case "/bulk-download":
+          return handleBulkDownload(req, res, root);
+        case "/bulk-delete":
+          return handleBulkDelete(req, res, root);
+        case "/events":
+          return handleSSE(res);
+        default:
+          next();
+      }
+    } catch (error) {
+      console.error("[asset-manager] API error:", error);
+      res.statusCode = 500;
+      res.setHeader("Content-Type", "application/json");
+      res.end(JSON.stringify({ error: "Internal server error" }));
+    }
+  };
+}
+async function handleGetAssets(res, scanner, query) {
+  const assets = scanner.getAssets();
+  let filtered = assets;
+  const directory = query.directory;
+  if (directory) {
+    filtered = filtered.filter(
+      (a) => a.directory === directory || a.directory.startsWith(directory + "/")
+    );
+  }
+  const type = query.type;
+  if (type) {
+    filtered = filtered.filter((a) => a.type === type);
+  }
+  sendJson(res, { assets: filtered, total: filtered.length });
+}
+async function handleGetGroupedAssets(res, scanner, query) {
+  let groups = scanner.getGroupedAssets();
+  const type = query.type;
+  if (type) {
+    groups = groups.map((group) => ({
+      ...group,
+      assets: group.assets.filter((a) => a.type === type),
+      count: group.assets.filter((a) => a.type === type).length
+    })).filter((group) => group.count > 0);
+  }
+  const unused = query.unused === "true";
+  if (unused) {
+    groups = groups.map((group) => ({
+      ...group,
+      assets: group.assets.filter((a) => a.importersCount === 0),
+      count: group.assets.filter((a) => a.importersCount === 0).length
+    })).filter((group) => group.count > 0);
+  }
+  const duplicates = query.duplicates === "true";
+  if (duplicates) {
+    groups = groups.map((group) => ({
+      ...group,
+      assets: group.assets.filter((a) => (a.duplicatesCount ?? 0) > 0),
+      count: group.assets.filter((a) => (a.duplicatesCount ?? 0) > 0).length
+    })).filter((group) => group.count > 0);
+  }
+  const total = groups.reduce((sum, g) => sum + g.count, 0);
+  sendJson(res, { groups, total });
+}
+async function handleSearch(res, scanner, query) {
+  const q = query.q || "";
+  const results = scanner.search(q);
+  sendJson(res, { assets: results, total: results.length, query: q });
+}
+async function handleThumbnail(res, thumbnailService, root, query) {
+  const relativePath = query.path;
+  if (!relativePath) {
+    res.statusCode = 400;
+    res.end("Missing path parameter");
+    return;
+  }
+  const absolutePath = import_path2.default.resolve(root, relativePath);
+  if (!absolutePath.startsWith(root)) {
+    res.statusCode = 403;
+    res.end("Forbidden");
+    return;
+  }
+  if (relativePath.endsWith(".svg")) {
+    res.setHeader("Content-Type", "image/svg+xml");
+    res.setHeader("Cache-Control", "public, max-age=31536000");
+    import_fs.default.createReadStream(absolutePath).pipe(res);
+    return;
+  }
+  const thumbnail = await thumbnailService.getThumbnail(absolutePath);
+  if (thumbnail) {
+    res.setHeader("Content-Type", "image/jpeg");
+    res.setHeader("Cache-Control", "public, max-age=31536000");
+    res.end(thumbnail);
+  } else {
+    const ext = import_path2.default.extname(relativePath).toLowerCase();
+    res.setHeader("Content-Type", MIME_TYPES[ext] || "application/octet-stream");
+    import_fs.default.createReadStream(absolutePath).pipe(res);
+  }
+}
+async function handleServeFile(res, root, query) {
+  const relativePath = query.path;
+  if (!relativePath) {
+    res.statusCode = 400;
+    res.end("Missing path parameter");
+    return;
+  }
+  const absolutePath = import_path2.default.resolve(root, relativePath);
+  if (!absolutePath.startsWith(root)) {
+    res.statusCode = 403;
+    res.end("Forbidden");
+    return;
+  }
+  try {
+    await import_fs.default.promises.access(absolutePath, import_fs.default.constants.R_OK);
+  } catch {
+    res.statusCode = 404;
+    res.end("File not found");
+    return;
+  }
+  const ext = import_path2.default.extname(relativePath).toLowerCase();
+  res.setHeader("Content-Type", MIME_TYPES[ext] || "application/octet-stream");
+  res.setHeader("Cache-Control", "public, max-age=3600");
+  import_fs.default.createReadStream(absolutePath).pipe(res);
+}
+async function handleGetStats(res, scanner, duplicateScanner) {
+  const assets = scanner.getAssets();
+  const dupStats = duplicateScanner.getStats();
+  const stats = {
+    total: assets.length,
+    byType: {
+      image: assets.filter((a) => a.type === "image").length,
+      video: assets.filter((a) => a.type === "video").length,
+      audio: assets.filter((a) => a.type === "audio").length,
+      document: assets.filter((a) => a.type === "document").length,
+      font: assets.filter((a) => a.type === "font").length,
+      data: assets.filter((a) => a.type === "data").length,
+      text: assets.filter((a) => a.type === "text").length,
+      other: assets.filter((a) => a.type === "other").length
+    },
+    totalSize: assets.reduce((sum, a) => sum + a.size, 0),
+    directories: [...new Set(assets.map((a) => a.directory))].length,
+    unused: assets.filter((a) => a.importersCount === 0).length,
+    duplicateGroups: dupStats.duplicateGroups,
+    duplicateFiles: dupStats.duplicateFiles
+  };
+  sendJson(res, stats);
+}
+async function handleGetDuplicates(res, scanner, duplicateScanner, query) {
+  const hash = query.hash;
+  if (hash) {
+    const paths = duplicateScanner.getDuplicatesByHash(hash);
+    const assets = scanner.getAssets().filter((a) => paths.includes(a.path));
+    sendJson(res, { duplicates: assets, total: assets.length, hash });
+  } else {
+    const assets = scanner.getAssets().filter((a) => (a.duplicatesCount ?? 0) > 0);
+    sendJson(res, { duplicates: assets, total: assets.length });
+  }
+}
+function sendJson(res, data) {
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(data));
+}
+function handleSSE(res) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    "Access-Control-Allow-Origin": "*"
+  });
+  res.write(`data: ${JSON.stringify({ type: "connected" })}
+
+`);
+  sseClients.add(res);
+  res.on("close", () => {
+    sseClients.delete(res);
+  });
+}
+function broadcastSSE(event, data) {
+  const message = JSON.stringify({ event, data });
+  for (const client of sseClients) {
+    client.write(`data: ${message}
+
+`);
+  }
+}
+async function handleGetImporters(res, importerScanner, query) {
+  const assetPath = query.path;
+  if (!assetPath) {
+    res.statusCode = 400;
+    sendJson(res, { error: "Missing path parameter" });
+    return;
+  }
+  const importers = importerScanner.getImporters(assetPath);
+  sendJson(res, { importers, total: importers.length });
+}
+async function handleOpenInEditor(req, res, root, editor, query) {
+  if (req.method !== "POST") {
+    res.statusCode = 405;
+    sendJson(res, { error: "Method not allowed" });
+    return;
+  }
+  const filePath = query.file;
+  const line = parseInt(query.line) || 1;
+  const column = parseInt(query.column) || 1;
+  if (!filePath) {
+    res.statusCode = 400;
+    sendJson(res, { error: "Missing file parameter" });
+    return;
+  }
+  const absolutePath = import_path2.default.resolve(root, filePath);
+  if (!absolutePath.startsWith(root)) {
+    res.statusCode = 403;
+    sendJson(res, { error: "Forbidden" });
+    return;
+  }
+  try {
+    await import_fs.default.promises.access(absolutePath, import_fs.default.constants.R_OK);
+  } catch {
+    res.statusCode = 404;
+    sendJson(res, { error: "File not found" });
+    return;
+  }
+  try {
+    await launchEditor(absolutePath, line, column, editor);
+    sendJson(res, { success: true });
+  } catch (error) {
+    res.statusCode = 500;
+    sendJson(res, { error: error instanceof Error ? error.message : "Failed to open editor" });
+  }
+}
+async function handleRevealInFinder(req, res, root, query) {
+  if (req.method !== "POST") {
+    res.statusCode = 405;
+    sendJson(res, { error: "Method not allowed" });
+    return;
+  }
+  const filePath = query.path;
+  if (!filePath) {
+    res.statusCode = 400;
+    sendJson(res, { error: "Missing path parameter" });
+    return;
+  }
+  const absolutePath = import_path2.default.resolve(root, filePath);
+  if (!absolutePath.startsWith(root)) {
+    res.statusCode = 403;
+    sendJson(res, { error: "Invalid path" });
+    return;
+  }
+  try {
+    await import_fs.default.promises.access(absolutePath, import_fs.default.constants.R_OK);
+  } catch {
+    res.statusCode = 404;
+    sendJson(res, { error: "File not found" });
+    return;
+  }
+  try {
+    await revealInFileExplorer(absolutePath);
+    sendJson(res, { success: true });
+  } catch (error) {
+    res.statusCode = 500;
+    sendJson(res, {
+      error: error instanceof Error ? error.message : "Failed to reveal file"
+    });
+  }
+}
+async function parseJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      try {
+        resolve(JSON.parse(body));
+      } catch {
+        reject(new Error("Invalid JSON"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+async function handleBulkDownload(req, res, root) {
+  if (req.method !== "POST") {
+    res.statusCode = 405;
+    sendJson(res, { error: "Method not allowed" });
+    return;
+  }
+  let body;
+  try {
+    body = await parseJsonBody(req);
+  } catch {
+    res.statusCode = 400;
+    sendJson(res, { error: "Invalid JSON body" });
+    return;
+  }
+  const paths = body.paths;
+  if (!Array.isArray(paths) || paths.length === 0) {
+    res.statusCode = 400;
+    sendJson(res, { error: "Missing or invalid paths array" });
+    return;
+  }
+  const validatedPaths = [];
+  for (const relativePath of paths) {
+    const absolutePath = import_path2.default.resolve(root, relativePath);
+    if (!absolutePath.startsWith(root)) {
+      res.statusCode = 403;
+      sendJson(res, { error: `Forbidden path: ${relativePath}` });
+      return;
+    }
+    try {
+      await import_fs.default.promises.access(absolutePath, import_fs.default.constants.R_OK);
+      validatedPaths.push({ relativePath, absolutePath });
+    } catch {
+      console.warn(`[asset-manager] Bulk download skipping missing file: ${relativePath}`);
+    }
+  }
+  if (validatedPaths.length === 0) {
+    res.statusCode = 404;
+    sendJson(res, { error: "No valid files found" });
+    return;
+  }
+  res.setHeader("Content-Type", "application/zip");
+  res.setHeader("Content-Disposition", `attachment; filename="assets-${Date.now()}.zip"`);
+  const archive = (0, import_archiver.default)("zip", { zlib: { level: 6 } });
+  archive.on("error", (err) => {
+    console.error("[asset-manager] ZIP creation error:", err);
+    if (!res.headersSent) {
+      res.statusCode = 500;
+      res.end("ZIP creation failed");
+    }
+  });
+  archive.pipe(res);
+  for (const { relativePath, absolutePath } of validatedPaths) {
+    archive.file(absolutePath, { name: relativePath });
+  }
+  await archive.finalize();
+}
+async function handleBulkDelete(req, res, root) {
+  if (req.method !== "POST") {
+    res.statusCode = 405;
+    sendJson(res, { error: "Method not allowed" });
+    return;
+  }
+  let body;
+  try {
+    body = await parseJsonBody(req);
+  } catch {
+    res.statusCode = 400;
+    sendJson(res, { error: "Invalid JSON body" });
+    return;
+  }
+  const paths = body.paths;
+  if (!Array.isArray(paths) || paths.length === 0) {
+    res.statusCode = 400;
+    sendJson(res, { error: "Missing or invalid paths array" });
+    return;
+  }
+  const results = {
+    deleted: 0,
+    failed: [],
+    errors: []
+  };
+  for (const relativePath of paths) {
+    const absolutePath = import_path2.default.resolve(root, relativePath);
+    if (!absolutePath.startsWith(root)) {
+      results.failed.push(relativePath);
+      results.errors.push(`Forbidden path: ${relativePath}`);
+      continue;
+    }
+    try {
+      await import_fs.default.promises.unlink(absolutePath);
+      results.deleted++;
+    } catch (error) {
+      results.failed.push(relativePath);
+      results.errors.push(error instanceof Error ? error.message : "Unknown error");
+    }
+  }
+  sendJson(res, {
+    deleted: results.deleted,
+    failed: results.failed.length,
+    errors: results.errors
+  });
+}
+
+// src/server/index.ts
+var __dirname = import_path3.default.dirname((0, import_url2.fileURLToPath)(importMetaUrl));
+function findClientDir() {
+  const fromDist = import_path3.default.join(__dirname, "client");
+  if (import_fs2.default.existsSync(fromDist)) {
+    return fromDist;
+  }
+  const fromSource = import_path3.default.resolve(__dirname, "../../dist/client");
+  if (import_fs2.default.existsSync(fromSource)) {
+    return fromSource;
+  }
+  return fromDist;
+}
+function setupMiddleware(server, context) {
+  const { base, scanner, importerScanner, duplicateScanner, thumbnailService, root, launchEditor: launchEditor2 } = context;
+  const apiRouter = createApiRouter(
+    scanner,
+    importerScanner,
+    duplicateScanner,
+    thumbnailService,
+    root,
+    base,
+    launchEditor2
+  );
+  const clientDir = findClientDir();
+  server.middlewares.use((req, res, next) => {
+    const url = req.url || "";
+    if (url.startsWith(`${base}/api/`)) {
+      return apiRouter(req, res, next);
+    }
+    if (url === base || url.startsWith(`${base}/`)) {
+      const serve = (0, import_sirv.default)(clientDir, {
+        single: true,
+        dev: true
+      });
+      req.url = url.slice(base.length) || "/";
+      return serve(req, res, next);
+    }
+    next();
+  });
+}
+
+// src/server/scanner.ts
+var import_events = require("events");
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_path4 = __toESM(require("path"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_chokidar = __toESM(require("chokidar"), 1);
+var AssetScanner = class extends import_events.EventEmitter {
+  root;
+  options;
+  cache = /* @__PURE__ */ new Map();
+  watcher;
+  scanPromise;
+  constructor(root, options) {
+    super();
+    this.root = root;
+    this.options = options;
+  }
+  async init() {
+    await this.scan();
+    if (this.options.watch) {
+      this.initWatcher();
+    }
+  }
+  async scan() {
+    if (this.scanPromise) {
+      await this.scanPromise;
+      return this.getAssets();
+    }
+    this.scanPromise = this.performScan();
+    await this.scanPromise;
+    this.scanPromise = void 0;
+    return this.getAssets();
+  }
+  async performScan() {
+    const extensionPattern = this.options.extensions.map((ext) => ext.replace(".", "")).join(",");
+    const patterns = this.options.include.map((dir) => `${dir}/**/*.{${extensionPattern}}`);
+    const entries = await (0, import_fast_glob.default)(patterns, {
+      cwd: this.root,
+      ignore: this.options.exclude.map((p) => `**/${p}/**`),
+      absolute: false,
+      stats: true,
+      onlyFiles: true,
+      dot: false
+    });
+    this.cache.clear();
+    for (const entry of entries) {
+      const asset = this.createAsset(entry);
+      this.cache.set(asset.path, asset);
+    }
+  }
+  createAsset(entry) {
+    const relativePath = entry.path;
+    const absolutePath = import_path4.default.join(this.root, relativePath);
+    const extension = import_path4.default.extname(relativePath).toLowerCase();
+    const name = import_path4.default.basename(relativePath);
+    const directory = import_path4.default.dirname(relativePath);
+    return {
+      id: Buffer.from(relativePath).toString("base64url"),
+      name,
+      path: relativePath,
+      absolutePath,
+      extension,
+      type: this.getAssetType(extension),
+      size: entry.stats?.size || 0,
+      mtime: entry.stats?.mtimeMs || Date.now(),
+      directory: directory === "." ? "/" : directory
+    };
+  }
+  getAssetType(extension) {
+    const imageExts = [
+      ".png",
+      ".jpg",
+      ".jpeg",
+      ".gif",
+      ".svg",
+      ".webp",
+      ".avif",
+      ".ico",
+      ".bmp",
+      ".tiff",
+      ".tif",
+      ".heic",
+      ".heif"
+    ];
+    const videoExts = [".mp4", ".webm", ".ogg", ".mov", ".avi"];
+    const audioExts = [".mp3", ".wav", ".flac", ".aac"];
+    const docExts = [".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx"];
+    const fontExts = [".woff", ".woff2", ".ttf", ".otf", ".eot"];
+    const dataExts = [".json", ".csv", ".xml", ".yml", ".yaml", ".toml"];
+    const textExts = [".md", ".txt"];
+    if (imageExts.includes(extension)) return "image";
+    if (videoExts.includes(extension)) return "video";
+    if (audioExts.includes(extension)) return "audio";
+    if (docExts.includes(extension)) return "document";
+    if (fontExts.includes(extension)) return "font";
+    if (dataExts.includes(extension)) return "data";
+    if (textExts.includes(extension)) return "text";
+    return "other";
+  }
+  getAssets() {
+    return Array.from(this.cache.values());
+  }
+  getGroupedAssets() {
+    const groups = /* @__PURE__ */ new Map();
+    for (const asset of this.cache.values()) {
+      const dir = asset.directory;
+      if (!groups.has(dir)) {
+        groups.set(dir, []);
+      }
+      groups.get(dir).push(asset);
+    }
+    return Array.from(groups.entries()).map(([directory, assets]) => ({
+      directory,
+      assets: assets.sort((a, b) => a.name.localeCompare(b.name)),
+      count: assets.length
+    })).sort((a, b) => a.directory.localeCompare(b.directory));
+  }
+  search(query) {
+    const normalizedQuery = query.toLowerCase().trim();
+    if (!normalizedQuery) return this.getAssets();
+    return this.getAssets().filter(
+      (asset) => asset.name.toLowerCase().includes(normalizedQuery) || asset.path.toLowerCase().includes(normalizedQuery)
+    );
+  }
+  getAsset(relativePath) {
+    return this.cache.get(relativePath);
+  }
+  /**
+   * Enrich assets with importer count metadata.
+   * Should be called after scanning completes and when importers change.
+   */
+  enrichWithImporterCounts(importerScanner) {
+    for (const asset of this.cache.values()) {
+      const importers = importerScanner.getImporters(asset.path);
+      asset.importersCount = importers.length;
+    }
+  }
+  /**
+   * Enrich assets with duplicate detection metadata.
+   * Should be called after scanning completes and when file content changes.
+   */
+  enrichWithDuplicateInfo(duplicateScanner) {
+    for (const asset of this.cache.values()) {
+      const info = duplicateScanner.getDuplicateInfo(asset.path);
+      asset.contentHash = info.hash;
+      asset.duplicatesCount = info.duplicatesCount;
+    }
+  }
+  initWatcher() {
+    const watchPaths = this.options.include.map((dir) => import_path4.default.join(this.root, dir));
+    this.watcher = import_chokidar.default.watch(watchPaths, {
+      ignored: this.options.exclude.map((p) => `**/${p}/**`),
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 100,
+        pollInterval: 50
+      }
+    });
+    this.watcher.on("add", (filePath) => this.handleFileChange("add", filePath));
+    this.watcher.on("unlink", (filePath) => this.handleFileChange("unlink", filePath));
+    this.watcher.on("change", (filePath) => this.handleFileChange("change", filePath));
+  }
+  async handleFileChange(event, absolutePath) {
+    const relativePath = import_path4.default.relative(this.root, absolutePath);
+    const extension = import_path4.default.extname(relativePath).toLowerCase();
+    if (!this.options.extensions.includes(extension)) {
+      return;
+    }
+    if (event === "unlink") {
+      this.cache.delete(relativePath);
+    } else {
+      try {
+        const stats = await import_promises.default.stat(absolutePath);
+        const asset = {
+          id: Buffer.from(relativePath).toString("base64url"),
+          name: import_path4.default.basename(relativePath),
+          path: relativePath,
+          absolutePath,
+          extension,
+          type: this.getAssetType(extension),
+          size: stats.size,
+          mtime: stats.mtimeMs,
+          directory: import_path4.default.dirname(relativePath)
+        };
+        this.cache.set(relativePath, asset);
+      } catch {
+        return;
+      }
+    }
+    this.emit("change", { event, path: relativePath });
+  }
+  destroy() {
+    this.watcher?.close();
+  }
+};
+
+// src/server/importer-scanner.ts
+var import_events2 = require("events");
+var import_fast_glob2 = __toESM(require("fast-glob"), 1);
+var import_path5 = __toESM(require("path"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_chokidar2 = __toESM(require("chokidar"), 1);
+var SOURCE_EXTENSIONS = ["js", "jsx", "ts", "tsx", "vue", "svelte", "css", "scss", "less", "html"];
+var ASSET_EXTENSIONS = [
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "svg",
+  "webp",
+  "avif",
+  "ico",
+  "bmp",
+  "tiff",
+  "tif",
+  "heic",
+  "heif",
+  "mp4",
+  "webm",
+  "ogg",
+  "mov",
+  "avi",
+  "mp3",
+  "wav",
+  "flac",
+  "aac",
+  "woff",
+  "woff2",
+  "ttf",
+  "otf",
+  "eot",
+  "pdf",
+  "json",
+  "md",
+  "txt",
+  "csv",
+  "xml",
+  "yml",
+  "yaml",
+  "toml"
+];
+var ASSET_EXT_PATTERN = ASSET_EXTENSIONS.join("|");
+var IMPORT_PATTERNS = [
+  {
+    type: "es-import",
+    pattern: new RegExp(
+      `import\\s+(?:[\\w\\s{},*]+\\s+from\\s+)?['"]([^'"]*\\.(?:${ASSET_EXT_PATTERN}))['"]`,
+      "gi"
+    )
+  },
+  {
+    type: "dynamic-import",
+    pattern: new RegExp(`import\\s*\\(\\s*['"]([^'"]*\\.(?:${ASSET_EXT_PATTERN}))['"]\\s*\\)`, "gi")
+  },
+  {
+    type: "require",
+    pattern: new RegExp(
+      `require\\s*\\(\\s*['"]([^'"]*\\.(?:${ASSET_EXT_PATTERN}))['"]\\s*\\)`,
+      "gi"
+    )
+  },
+  {
+    type: "css-url",
+    pattern: new RegExp(
+      `url\\s*\\(\\s*['"]?([^'")\\s]+\\.(?:${ASSET_EXT_PATTERN}))['"]?\\s*\\)`,
+      "gi"
+    )
+  },
+  {
+    type: "html-src",
+    pattern: new RegExp(`\\bsrc\\s*=\\s*['"]([^'"]*\\.(?:${ASSET_EXT_PATTERN}))['"]`, "gi")
+  },
+  {
+    type: "html-href",
+    pattern: new RegExp(`\\bhref\\s*=\\s*['"]([^'"]*\\.(?:${ASSET_EXT_PATTERN}))['"]`, "gi")
+  }
+];
+var ImporterScanner = class extends import_events2.EventEmitter {
+  root;
+  options;
+  /** Maps asset path -> array of importers */
+  cache = /* @__PURE__ */ new Map();
+  /** Reverse index: source file -> set of asset paths it imports */
+  reverseIndex = /* @__PURE__ */ new Map();
+  watcher;
+  scanPromise;
+  initialized = false;
+  constructor(root, options) {
+    super();
+    this.root = root;
+    this.options = options;
+  }
+  async init() {
+    if (this.initialized) return;
+    await this.scan();
+    if (this.options.watch) {
+      this.initWatcher();
+    }
+    this.initialized = true;
+  }
+  async scan() {
+    if (this.scanPromise) {
+      await this.scanPromise;
+      return;
+    }
+    this.scanPromise = this.performScan();
+    await this.scanPromise;
+    this.scanPromise = void 0;
+  }
+  async performScan() {
+    const patterns = this.options.include.map((dir) => `${dir}/**/*.{${SOURCE_EXTENSIONS.join(",")}}`);
+    const entries = await (0, import_fast_glob2.default)(patterns, {
+      cwd: this.root,
+      ignore: this.options.exclude.map((p) => `**/${p}/**`),
+      absolute: false,
+      onlyFiles: true,
+      dot: false
+    });
+    this.cache.clear();
+    this.reverseIndex.clear();
+    const BATCH_SIZE = 50;
+    for (let i = 0; i < entries.length; i += BATCH_SIZE) {
+      const batch = entries.slice(i, i + BATCH_SIZE);
+      await Promise.all(batch.map((filePath) => this.scanFile(filePath)));
+    }
+  }
+  async scanFile(relativePath) {
+    const absolutePath = import_path5.default.join(this.root, relativePath);
+    try {
+      const content = await import_promises2.default.readFile(absolutePath, "utf-8");
+      const importers = this.findImportsInFile(content, relativePath, absolutePath);
+      const previousAssets = this.reverseIndex.get(relativePath);
+      if (previousAssets) {
+        for (const assetPath of previousAssets) {
+          const assetImporters = this.cache.get(assetPath);
+          if (assetImporters) {
+            const filtered = assetImporters.filter((i) => i.filePath !== relativePath);
+            if (filtered.length > 0) {
+              this.cache.set(assetPath, filtered);
+            } else {
+              this.cache.delete(assetPath);
+            }
+          }
+        }
+      }
+      const newAssets = /* @__PURE__ */ new Set();
+      for (const importer of importers) {
+        const assetPath = this.resolveAssetPath(importer.filePath, importer.snippet);
+        if (assetPath) {
+          newAssets.add(assetPath);
+          const existing = this.cache.get(assetPath) || [];
+          existing.push({ ...importer, filePath: relativePath, absolutePath });
+          this.cache.set(assetPath, existing);
+        }
+      }
+      this.reverseIndex.set(relativePath, newAssets);
+    } catch {
+    }
+  }
+  findImportsInFile(content, relativePath, absolutePath) {
+    const importers = [];
+    const lines = content.split("\n");
+    const fileDir = import_path5.default.dirname(relativePath);
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+      const line = lines[lineIndex];
+      for (const { type, pattern } of IMPORT_PATTERNS) {
+        pattern.lastIndex = 0;
+        let match;
+        while ((match = pattern.exec(line)) !== null) {
+          const importPath = match[1];
+          const resolvedAssetPath = this.resolveImportPath(importPath, fileDir);
+          if (resolvedAssetPath) {
+            importers.push({
+              filePath: relativePath,
+              absolutePath,
+              line: lineIndex + 1,
+              column: match.index + 1,
+              importType: type,
+              snippet: line.trim().slice(0, 100)
+            });
+          }
+        }
+      }
+    }
+    return importers;
+  }
+  /**
+   * Resolves an import path relative to the file directory.
+   * Returns the normalized asset path relative to project root, or null if invalid.
+   */
+  resolveImportPath(importPath, fileDir) {
+    if (importPath.startsWith("http://") || importPath.startsWith("https://") || importPath.startsWith("//")) {
+      return null;
+    }
+    if (!importPath.startsWith(".") && !importPath.startsWith("/") && !importPath.startsWith("@/")) {
+      return null;
+    }
+    let resolvedPath;
+    if (importPath.startsWith("/")) {
+      resolvedPath = importPath.slice(1);
+      if (!resolvedPath.startsWith("public/")) {
+        resolvedPath = "public" + importPath;
+      }
+    } else if (importPath.startsWith("@/")) {
+      resolvedPath = "src/" + importPath.slice(2);
+    } else {
+      resolvedPath = import_path5.default.normalize(import_path5.default.join(fileDir, importPath));
+    }
+    resolvedPath = resolvedPath.split(import_path5.default.sep).join("/");
+    return resolvedPath;
+  }
+  /**
+   * Extract asset path from importer snippet (for reverse lookup)
+   */
+  resolveAssetPath(sourceFile, snippet) {
+    const fileDir = import_path5.default.dirname(sourceFile);
+    for (const { pattern } of IMPORT_PATTERNS) {
+      pattern.lastIndex = 0;
+      const match = pattern.exec(snippet);
+      if (match) {
+        return this.resolveImportPath(match[1], fileDir);
+      }
+    }
+    return null;
+  }
+  /**
+   * Get all importers for a specific asset.
+   * @param assetPath - Relative path to the asset from project root
+   */
+  getImporters(assetPath) {
+    const normalizedPath = assetPath.split(import_path5.default.sep).join("/");
+    let importers = this.cache.get(normalizedPath);
+    if (!importers) {
+      if (normalizedPath.startsWith("public/")) {
+        importers = this.cache.get(normalizedPath.slice(7));
+      } else {
+        importers = this.cache.get("public/" + normalizedPath);
+      }
+    }
+    return importers || [];
+  }
+  /**
+   * Get assets affected when a source file changes.
+   */
+  getAffectedAssets(sourceFile) {
+    return Array.from(this.reverseIndex.get(sourceFile) || []);
+  }
+  initWatcher() {
+    const watchPaths = this.options.include.map((dir) => import_path5.default.join(this.root, dir));
+    this.watcher = import_chokidar2.default.watch(watchPaths, {
+      ignored: [
+        ...this.options.exclude.map((p) => `**/${p}/**`),
+        (filePath) => {
+          const ext = import_path5.default.extname(filePath).slice(1);
+          return ext !== "" && !SOURCE_EXTENSIONS.includes(ext);
+        }
+      ],
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 200,
+        pollInterval: 50
+      }
+    });
+    this.watcher.on("add", (filePath) => this.handleFileChange("add", filePath));
+    this.watcher.on("unlink", (filePath) => this.handleFileChange("unlink", filePath));
+    this.watcher.on("change", (filePath) => this.handleFileChange("change", filePath));
+  }
+  async handleFileChange(event, absolutePath) {
+    const relativePath = import_path5.default.relative(this.root, absolutePath);
+    const extension = import_path5.default.extname(relativePath).slice(1);
+    if (!SOURCE_EXTENSIONS.includes(extension)) {
+      return;
+    }
+    const previousAssets = this.getAffectedAssets(relativePath);
+    if (event === "unlink") {
+      for (const assetPath of previousAssets) {
+        const assetImporters = this.cache.get(assetPath);
+        if (assetImporters) {
+          const filtered = assetImporters.filter((i) => i.filePath !== relativePath);
+          if (filtered.length > 0) {
+            this.cache.set(assetPath, filtered);
+          } else {
+            this.cache.delete(assetPath);
+          }
+        }
+      }
+      this.reverseIndex.delete(relativePath);
+    } else {
+      await this.scanFile(relativePath);
+    }
+    const currentAssets = this.getAffectedAssets(relativePath);
+    const allAffectedAssets = [.../* @__PURE__ */ new Set([...previousAssets, ...currentAssets])];
+    if (allAffectedAssets.length > 0) {
+      this.emit("change", {
+        event,
+        path: relativePath,
+        affectedAssets: allAffectedAssets
+      });
+    }
+  }
+  destroy() {
+    this.watcher?.close();
+  }
+};
+
+// src/server/duplicate-scanner.ts
+var import_events3 = require("events");
+var import_crypto = __toESM(require("crypto"), 1);
+var import_fs3 = __toESM(require("fs"), 1);
+var import_path6 = __toESM(require("path"), 1);
+var import_chokidar3 = __toESM(require("chokidar"), 1);
+var STREAMING_THRESHOLD = 1024 * 1024;
+var DuplicateScanner = class extends import_events3.EventEmitter {
+  root;
+  options;
+  /** Maps relative path -> { hash, mtime, size } for cache validation */
+  hashCache = /* @__PURE__ */ new Map();
+  /** Maps hash -> set of relative paths (for grouping duplicates) */
+  duplicateGroups = /* @__PURE__ */ new Map();
+  /** Reverse index: path -> hash (for quick lookups) */
+  pathToHash = /* @__PURE__ */ new Map();
+  watcher;
+  scanPromise;
+  initialized = false;
+  constructor(root, options) {
+    super();
+    this.root = root;
+    this.options = options;
+  }
+  async init() {
+    if (this.initialized) return;
+    this.initialized = true;
+  }
+  /**
+   * Scan all assets and compute hashes.
+   * Called after AssetScanner has discovered assets.
+   */
+  async scanAssets(assets) {
+    if (this.scanPromise) {
+      await this.scanPromise;
+      return;
+    }
+    this.scanPromise = this.performScan(assets);
+    await this.scanPromise;
+    this.scanPromise = void 0;
+  }
+  async performScan(assets) {
+    this.duplicateGroups.clear();
+    this.pathToHash.clear();
+    const BATCH_SIZE = 20;
+    for (let i = 0; i < assets.length; i += BATCH_SIZE) {
+      const batch = assets.slice(i, i + BATCH_SIZE);
+      await Promise.all(batch.map((asset) => this.processAsset(asset)));
+    }
+  }
+  async processAsset(asset) {
+    try {
+      const hash = await this.getOrComputeHash(asset.path, asset.absolutePath);
+      if (hash) {
+        this.pathToHash.set(asset.path, hash);
+        if (!this.duplicateGroups.has(hash)) {
+          this.duplicateGroups.set(hash, /* @__PURE__ */ new Set());
+        }
+        this.duplicateGroups.get(hash).add(asset.path);
+      }
+    } catch {
+    }
+  }
+  /**
+   * Get cached hash or compute new one if cache is invalid.
+   */
+  async getOrComputeHash(relativePath, absolutePath) {
+    try {
+      const stats = await import_fs3.default.promises.stat(absolutePath);
+      const cached = this.hashCache.get(relativePath);
+      if (cached && cached.mtime === stats.mtimeMs && cached.size === stats.size) {
+        return cached.hash;
+      }
+      const hash = await this.computeFileHash(absolutePath, stats.size);
+      this.hashCache.set(relativePath, {
+        hash,
+        mtime: stats.mtimeMs,
+        size: stats.size
+      });
+      return hash;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Compute MD5 hash of file contents.
+   * Uses streaming for large files to avoid memory issues.
+   */
+  async computeFileHash(absolutePath, size) {
+    if (size > STREAMING_THRESHOLD) {
+      return new Promise((resolve, reject) => {
+        const hash = import_crypto.default.createHash("md5");
+        const stream = import_fs3.default.createReadStream(absolutePath);
+        stream.on("data", (chunk) => hash.update(chunk));
+        stream.on("end", () => resolve(hash.digest("hex")));
+        stream.on("error", reject);
+      });
+    }
+    const content = await import_fs3.default.promises.readFile(absolutePath);
+    return import_crypto.default.createHash("md5").update(content).digest("hex");
+  }
+  /**
+   * Get duplicate info for a specific asset.
+   */
+  getDuplicateInfo(assetPath) {
+    const normalizedPath = assetPath.split(import_path6.default.sep).join("/");
+    const hash = this.pathToHash.get(normalizedPath);
+    if (!hash) {
+      return { hash: "", duplicatesCount: 0 };
+    }
+    const group = this.duplicateGroups.get(hash);
+    const duplicatesCount = group ? group.size - 1 : 0;
+    return { hash, duplicatesCount };
+  }
+  /**
+   * Get all assets in a duplicate group by hash.
+   */
+  getDuplicatesByHash(hash) {
+    const group = this.duplicateGroups.get(hash);
+    return group ? Array.from(group).sort() : [];
+  }
+  /**
+   * Get duplicate statistics.
+   */
+  getStats() {
+    let duplicateGroups = 0;
+    let duplicateFiles = 0;
+    for (const [, paths] of this.duplicateGroups) {
+      if (paths.size > 1) {
+        duplicateGroups++;
+        duplicateFiles += paths.size;
+      }
+    }
+    return { duplicateGroups, duplicateFiles };
+  }
+  /**
+   * Enrich assets with duplicate detection metadata.
+   */
+  enrichAssetsWithDuplicateInfo(assets) {
+    for (const asset of assets) {
+      const info = this.getDuplicateInfo(asset.path);
+      asset.contentHash = info.hash;
+      asset.duplicatesCount = info.duplicatesCount;
+    }
+  }
+  /**
+   * Handle file change event from watcher.
+   * Recalculates hash and updates duplicate groups.
+   */
+  async handleAssetChange(event, relativePath, absolutePath) {
+    const normalizedPath = relativePath.split(import_path6.default.sep).join("/");
+    const previousHash = this.pathToHash.get(normalizedPath);
+    const affectedHashes = [];
+    if (previousHash) {
+      affectedHashes.push(previousHash);
+      const oldGroup = this.duplicateGroups.get(previousHash);
+      if (oldGroup) {
+        oldGroup.delete(normalizedPath);
+        if (oldGroup.size === 0) {
+          this.duplicateGroups.delete(previousHash);
+        }
+      }
+      this.pathToHash.delete(normalizedPath);
+    }
+    if (event === "unlink") {
+      this.hashCache.delete(normalizedPath);
+    } else {
+      try {
+        const stats = await import_fs3.default.promises.stat(absolutePath);
+        const hash = await this.computeFileHash(absolutePath, stats.size);
+        this.hashCache.set(normalizedPath, {
+          hash,
+          mtime: stats.mtimeMs,
+          size: stats.size
+        });
+        this.pathToHash.set(normalizedPath, hash);
+        if (!this.duplicateGroups.has(hash)) {
+          this.duplicateGroups.set(hash, /* @__PURE__ */ new Set());
+        }
+        this.duplicateGroups.get(hash).add(normalizedPath);
+        if (!affectedHashes.includes(hash)) {
+          affectedHashes.push(hash);
+        }
+      } catch {
+      }
+    }
+    if (affectedHashes.length > 0) {
+      this.emit("change", { event, affectedHashes });
+    }
+  }
+  /**
+   * Initialize file watcher for real-time updates.
+   * Note: This watches asset files, not source files.
+   */
+  initWatcher() {
+    if (this.watcher) return;
+    const watchPaths = this.options.include.map((dir) => import_path6.default.join(this.root, dir));
+    this.watcher = import_chokidar3.default.watch(watchPaths, {
+      ignored: [
+        ...this.options.exclude.map((p) => `**/${p}/**`),
+        (filePath) => {
+          const ext = import_path6.default.extname(filePath).toLowerCase();
+          return ext !== "" && !this.options.extensions.includes(ext);
+        }
+      ],
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 200,
+        pollInterval: 50
+      }
+    });
+    this.watcher.on("add", async (filePath) => {
+      const relativePath = import_path6.default.relative(this.root, filePath);
+      await this.handleAssetChange("add", relativePath, filePath);
+    });
+    this.watcher.on("change", async (filePath) => {
+      const relativePath = import_path6.default.relative(this.root, filePath);
+      await this.handleAssetChange("change", relativePath, filePath);
+    });
+    this.watcher.on("unlink", async (filePath) => {
+      const relativePath = import_path6.default.relative(this.root, filePath);
+      await this.handleAssetChange("unlink", relativePath, filePath);
+    });
+  }
+  destroy() {
+    this.watcher?.close();
+    this.hashCache.clear();
+    this.duplicateGroups.clear();
+    this.pathToHash.clear();
+  }
+};
+
+// src/server/thumbnail.ts
+var import_sharp = __toESM(require("sharp"), 1);
+var import_path7 = __toESM(require("path"), 1);
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_crypto2 = require("crypto");
+var import_os = __toESM(require("os"), 1);
+var ThumbnailService = class {
+  size;
+  cache = /* @__PURE__ */ new Map();
+  cacheDir;
+  supportedFormats = [".jpg", ".jpeg", ".png", ".webp", ".avif", ".gif", ".tiff"];
+  constructor(size = 200) {
+    this.size = size;
+    this.cacheDir = import_path7.default.join(import_os.default.tmpdir(), "vite-asset-manager-thumbnails");
+  }
+  async getThumbnail(absolutePath) {
+    const extension = import_path7.default.extname(absolutePath).toLowerCase();
+    if (!this.supportedFormats.includes(extension)) {
+      return null;
+    }
+    const cacheKey = await this.getCacheKey(absolutePath);
+    const cached = this.cache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const diskCached = await this.loadFromDiskCache(cacheKey);
+    if (diskCached) {
+      this.cache.set(cacheKey, diskCached);
+      return diskCached;
+    }
+    try {
+      const thumbnail = await this.generateThumbnail(absolutePath);
+      this.cache.set(cacheKey, thumbnail);
+      await this.saveToDiskCache(cacheKey, thumbnail);
+      return thumbnail;
+    } catch (error) {
+      console.warn(`[asset-manager] Failed to generate thumbnail for ${absolutePath}:`, error);
+      return null;
+    }
+  }
+  async generateThumbnail(absolutePath) {
+    return (0, import_sharp.default)(absolutePath).resize(this.size, this.size, {
+      fit: "cover",
+      position: "center"
+    }).jpeg({ quality: 80 }).toBuffer();
+  }
+  async getCacheKey(absolutePath) {
+    const hash = (0, import_crypto2.createHash)("md5");
+    hash.update(absolutePath);
+    hash.update(this.size.toString());
+    try {
+      const stats = await import_promises3.default.stat(absolutePath);
+      hash.update(stats.mtimeMs.toString());
+    } catch {
+    }
+    return hash.digest("hex");
+  }
+  async loadFromDiskCache(key) {
+    try {
+      const cachePath = import_path7.default.join(this.cacheDir, `${key}.jpg`);
+      return await import_promises3.default.readFile(cachePath);
+    } catch {
+      return null;
+    }
+  }
+  async saveToDiskCache(key, data) {
+    try {
+      await import_promises3.default.mkdir(this.cacheDir, { recursive: true });
+      const cachePath = import_path7.default.join(this.cacheDir, `${key}.jpg`);
+      await import_promises3.default.writeFile(cachePath, data);
+    } catch {
+    }
+  }
+  invalidate(absolutePath) {
+    this.getCacheKey(absolutePath).then((key) => {
+      this.cache.delete(key);
+    });
+  }
+  isSupportedFormat(extension) {
+    return this.supportedFormats.includes(extension.toLowerCase());
+  }
+};
+
+// src/shared/types.ts
+var DEFAULT_OPTIONS = {
+  base: "/__asset_manager__",
+  include: ["src", "public"],
+  exclude: ["node_modules", ".git", "dist", ".cache", "coverage"],
+  extensions: [
+    /**
+     * Images:
+     */
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".svg",
+    ".webp",
+    ".avif",
+    ".ico",
+    ".bmp",
+    ".tiff",
+    ".tif",
+    ".heic",
+    ".heif",
+    /**
+     * Videos:
+     */
+    ".mp4",
+    ".webm",
+    ".ogg",
+    ".mov",
+    ".avi",
+    /**
+     * Audio:
+     */
+    ".mp3",
+    ".wav",
+    ".flac",
+    ".aac",
+    /**
+     * Documents:
+     */
+    ".pdf",
+    ".doc",
+    ".docx",
+    ".xls",
+    ".xlsx",
+    ".ppt",
+    ".pptx",
+    /**
+     * Text/Config:
+     */
+    ".json",
+    ".md",
+    ".txt",
+    ".csv",
+    ".yml",
+    ".yaml",
+    ".toml",
+    ".xml",
+    /**
+     * Fonts:
+     */
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".otf",
+    ".eot"
+  ],
+  thumbnails: true,
+  thumbnailSize: 200,
+  watch: true,
+  floatingIcon: true,
+  launchEditor: "code"
+};
+function resolveOptions(options) {
+  return {
+    ...DEFAULT_OPTIONS,
+    ...options
+  };
+}
+
+// src/plugin.ts
+var FLOATING_ICON_SCRIPT = (base) => `
+<script type="module">
+(function() {
+  const BASE_URL = '${base}';
+  const STORAGE_KEY = 'vite-asset-manager-open';
+
+  // Styles for the floating button and overlay
+  const styles = document.createElement('style');
+  styles.textContent = \`
+    #vam-trigger {
+      position: fixed;
+      bottom: 20px;
+      right: 20px;
+      width: 48px;
+      height: 48px;
+      border-radius: 14px;
+      background: linear-gradient(135deg, #8b5cf6 0%, #7c3aed 100%);
+      border: none;
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      box-shadow: 0 4px 24px -4px rgba(139, 92, 246, 0.5), 0 0 0 1px rgba(255,255,255,0.1) inset;
+      transition: all 0.2s ease;
+      z-index: 99998;
+    }
+    #vam-trigger:hover {
+      transform: translateY(-2px) scale(1.05);
+      box-shadow: 0 8px 32px -4px rgba(139, 92, 246, 0.6), 0 0 0 1px rgba(255,255,255,0.15) inset;
+    }
+    #vam-trigger:active {
+      transform: translateY(0) scale(0.98);
+    }
+    #vam-trigger svg {
+      width: 24px;
+      height: 24px;
+      color: white;
+    }
+    #vam-overlay {
+      position: fixed;
+      inset: 0;
+      background: rgba(0, 0, 0, 0.6);
+      backdrop-filter: blur(4px);
+      z-index: 99999;
+      opacity: 0;
+      visibility: hidden;
+      transition: opacity 0.3s ease, visibility 0.3s ease;
+    }
+    #vam-overlay.open {
+      opacity: 1;
+      visibility: visible;
+    }
+    #vam-panel {
+      position: fixed;
+      top: 0;
+      right: 0;
+      bottom: 0;
+      width: min(90vw, 1200px);
+      background: #09090b;
+      border-left: 1px solid rgba(255,255,255,0.08);
+      transform: translateX(100%);
+      transition: transform 0.3s cubic-bezier(0.32, 0.72, 0, 1);
+      z-index: 100000;
+      display: flex;
+      flex-direction: column;
+    }
+    #vam-overlay.open #vam-panel {
+      transform: translateX(0);
+    }
+    #vam-panel-header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 12px 16px;
+      border-bottom: 1px solid rgba(255,255,255,0.08);
+      background: #0f0f11;
+    }
+    #vam-panel-title {
+      font-family: 'JetBrains Mono', ui-monospace, monospace;
+      font-size: 12px;
+      font-weight: 600;
+      color: #fafafa;
+      letter-spacing: 0.05em;
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+    #vam-panel-title svg {
+      width: 18px;
+      height: 18px;
+      color: #8b5cf6;
+    }
+    #vam-close-btn {
+      width: 32px;
+      height: 32px;
+      border-radius: 8px;
+      border: none;
+      background: transparent;
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      color: #71717a;
+      transition: all 0.15s ease;
+    }
+    #vam-close-btn:hover {
+      background: rgba(255,255,255,0.1);
+      color: #fafafa;
+    }
+    #vam-iframe {
+      flex: 1;
+      border: none;
+      width: 100%;
+      height: 100%;
+    }
+  \`;
+  document.head.appendChild(styles);
+
+  // Create trigger button
+  const trigger = document.createElement('button');
+  trigger.id = 'vam-trigger';
+  trigger.title = 'Open Asset Manager (\u2325\u21E7A)';
+  trigger.innerHTML = \`
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="currentColor">
+      <path d="M216,40H40A16,16,0,0,0,24,56V200a16,16,0,0,0,16,16H216a16,16,0,0,0,16-16V56A16,16,0,0,0,216,40Zm0,16V88H40V56Zm0,144H40V104H216v96ZM64,128a8,8,0,0,1,8-8h80a8,8,0,0,1,0,16H72A8,8,0,0,1,64,128Zm0,32a8,8,0,0,1,8-8h80a8,8,0,0,1,0,16H72A8,8,0,0,1,64,160Z"/>
+    </svg>
+  \`;
+
+  // Create overlay and panel
+  const overlay = document.createElement('div');
+  overlay.id = 'vam-overlay';
+  overlay.innerHTML = \`
+    <div id="vam-panel">
+      <div id="vam-panel-header">
+        <div id="vam-panel-title">
+          <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="currentColor">
+            <path d="M216,40H40A16,16,0,0,0,24,56V200a16,16,0,0,0,16,16H216a16,16,0,0,0,16-16V56A16,16,0,0,0,216,40Zm0,160H40V56H216V200ZM176,88a48,48,0,1,0-96,0,48,48,0,0,0,96,0Zm-48,32a32,32,0,1,1,32-32A32,32,0,0,1,128,120Zm80,56a8,8,0,0,1-8,8H56a8,8,0,0,1-6.65-12.44l24-36a8,8,0,0,1,13.3,0l15.18,22.77,24.89-41.48a8,8,0,0,1,13.72.18l40,64A8,8,0,0,1,208,176Z"/>
+          </svg>
+          ASSET MANAGER
+        </div>
+        <button id="vam-close-btn" title="Close (Esc)">
+          <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor">
+            <path d="M205.66,194.34a8,8,0,0,1-11.32,11.32L128,139.31,61.66,205.66a8,8,0,0,1-11.32-11.32L116.69,128,50.34,61.66A8,8,0,0,1,61.66,50.34L128,116.69l66.34-66.35a8,8,0,0,1,11.32,11.32L139.31,128Z"/>
+          </svg>
+        </button>
+      </div>
+      <iframe id="vam-iframe" src="\${BASE_URL}?embedded=true"></iframe>
+    </div>
+  \`;
+
+  document.body.appendChild(trigger);
+  document.body.appendChild(overlay);
+
+  // State management
+  let isOpen = sessionStorage.getItem(STORAGE_KEY) === 'true';
+
+  function open() {
+    isOpen = true;
+    overlay.classList.add('open');
+    sessionStorage.setItem(STORAGE_KEY, 'true');
+  }
+
+  function close() {
+    isOpen = false;
+    overlay.classList.remove('open');
+    sessionStorage.setItem(STORAGE_KEY, 'false');
+  }
+
+  // Restore state
+  if (isOpen) {
+    requestAnimationFrame(() => open());
+  }
+
+  // Event listeners
+  trigger.addEventListener('click', () => {
+    if (isOpen) close();
+    else open();
+  });
+
+  overlay.addEventListener('click', (e) => {
+    if (e.target === overlay) close();
+  });
+
+  document.getElementById('vam-close-btn').addEventListener('click', close);
+
+  document.addEventListener('keydown', (e) => {
+    // Close on Escape
+    if (e.key === 'Escape' && isOpen) {
+      close();
+    }
+    // Toggle on Option/Alt + Shift + A
+    if (e.altKey && e.shiftKey && e.code === 'KeyA') {
+      e.preventDefault();
+      if (isOpen) close();
+      else open();
+    }
+  });
+})();
+</script>
+`;
+function createAssetManagerPlugin(options = {}) {
+  let config;
+  let scanner;
+  let importerScanner;
+  let duplicateScanner;
+  let thumbnailService;
+  const resolvedOptions = resolveOptions(options);
+  return {
+    name: "vite-plugin-asset-manager",
+    apply: "serve",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    configureServer(server) {
+      scanner = new AssetScanner(config.root, resolvedOptions);
+      importerScanner = new ImporterScanner(config.root, resolvedOptions);
+      duplicateScanner = new DuplicateScanner(config.root, resolvedOptions);
+      thumbnailService = new ThumbnailService(resolvedOptions.thumbnailSize);
+      setupMiddleware(server, {
+        base: resolvedOptions.base,
+        scanner,
+        importerScanner,
+        duplicateScanner,
+        thumbnailService,
+        root: config.root,
+        launchEditor: resolvedOptions.launchEditor
+      });
+      scanner.init().then(async () => {
+        await importerScanner.init();
+        scanner.enrichWithImporterCounts(importerScanner);
+        await duplicateScanner.init();
+        await duplicateScanner.scanAssets(scanner.getAssets());
+        scanner.enrichWithDuplicateInfo(duplicateScanner);
+        if (resolvedOptions.watch) {
+          duplicateScanner.initWatcher();
+        }
+      });
+      const _printUrls = server.printUrls;
+      server.printUrls = () => {
+        _printUrls();
+        const colorUrl = (url2) => import_picocolors.default.cyan(url2.replace(/:(\d+)\//, (_, port) => `:${import_picocolors.default.bold(port)}/`));
+        let host = `${server.config.server.https ? "https" : "http"}://localhost:${server.config.server.port || "80"}`;
+        const url = server.resolvedUrls?.local[0];
+        if (url) {
+          try {
+            const u = new URL(url);
+            host = `${u.protocol}//${u.host}`;
+          } catch {
+          }
+        }
+        const base = server.config.base || "/";
+        const fullUrl = `${host}${base}${resolvedOptions.base.replace(/^\//, "")}/`;
+        server.config.logger.info(
+          `  ${import_picocolors.default.magenta("\u279C")}  ${import_picocolors.default.bold("Asset Manager")}: Open ${colorUrl(fullUrl)} as a separate window`
+        );
+        server.config.logger.info(
+          `  ${import_picocolors.default.magenta("\u279C")}  ${import_picocolors.default.bold("Asset Manager")}: Press ${import_picocolors.default.yellow("Option(\u2325)+Shift(\u21E7)+A")} in App to toggle the Asset Manager`
+        );
+      };
+      if (resolvedOptions.watch) {
+        scanner.on("change", async (event) => {
+          await duplicateScanner.scanAssets(scanner.getAssets());
+          scanner.enrichWithDuplicateInfo(duplicateScanner);
+          broadcastSSE("asset-manager:update", event);
+        });
+        importerScanner.on("change", (event) => {
+          scanner.enrichWithImporterCounts(importerScanner);
+          broadcastSSE("asset-manager:importers-update", event);
+        });
+        duplicateScanner.on("change", (event) => {
+          scanner.enrichWithDuplicateInfo(duplicateScanner);
+          broadcastSSE("asset-manager:duplicates-update", event);
+        });
+      }
+    },
+    transformIndexHtml() {
+      if (!resolvedOptions.floatingIcon) {
+        return [];
+      }
+      return [
+        {
+          tag: "script",
+          attrs: { type: "module" },
+          children: FLOATING_ICON_SCRIPT(resolvedOptions.base).replace(/<\/?script[^>]*>/g, "").trim(),
+          injectTo: "body"
+        }
+      ];
+    },
+    resolveId(id) {
+      if (id === "virtual:asset-manager-config") {
+        return "\0virtual:asset-manager-config";
+      }
+    },
+    load(id) {
+      if (id === "\0virtual:asset-manager-config") {
+        return `export default ${JSON.stringify({
+          base: resolvedOptions.base,
+          extensions: resolvedOptions.extensions
+        })}`;
+      }
+    },
+    buildEnd() {
+      scanner?.destroy();
+      importerScanner?.destroy();
+      duplicateScanner?.destroy();
+    }
+  };
+}
+
+// src/index.ts
+function assetManager(options = {}) {
+  return createAssetManagerPlugin(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assetManager
+});
+//# sourceMappingURL=index.cjs.map