storeshot 0.1.0

package/dist/cli.js

@@ -0,0 +1,1458 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import path3 from "path";
+import { fileURLToPath } from "url";
+import { Command, Option } from "commander";
+import open from "open";
+
+// src/server.ts
+import { createReadStream } from "fs";
+import { readFile as readFile2, stat as stat2 } from "fs/promises";
+import { createServer } from "http";
+import path2 from "path";
+
+// src/project-store.ts
+import { createHash, randomUUID } from "crypto";
+import { constants } from "fs";
+import { access, lstat, mkdir, readFile, readdir, realpath, rename, rm, stat, unlink, writeFile } from "fs/promises";
+import path from "path";
+
+// src/device-mockups.ts
+var MOCKUP_BUNDLE_FILENAME = "storeshot-mockups.json";
+var MOCKUP_BUNDLE_FORMAT = "storeshot-mockup-bundle";
+var identifierPattern = /^[a-z0-9][a-z0-9-]*$/;
+var styles = /* @__PURE__ */ new Set([
+  "3d",
+  "colored",
+  "colored-3d",
+  "handheld",
+  "handheld-dim",
+  "handheld-silhouette",
+  "handheld-styles",
+  "standard",
+  "textured"
+]);
+var platforms = /* @__PURE__ */ new Set(["iphone", "ipad", "mac", "watch"]);
+var frameExtensions = /* @__PURE__ */ new Set([".jpeg", ".jpg", ".png", ".svg", ".webp"]);
+function emptyDeviceMockupCatalog() {
+  return { bundles: [], groups: [], mockups: [] };
+}
+function parseMockupBundleManifest(value) {
+  if (!isRecord(value)) throw new Error(`${MOCKUP_BUNDLE_FILENAME} must contain a JSON object`);
+  if (value.format !== MOCKUP_BUNDLE_FORMAT || value.version !== 1) {
+    throw new Error("Unsupported StoreShot mockup bundle format");
+  }
+  if (!Array.isArray(value.mockups) || value.mockups.length === 0) {
+    throw new Error("A mockup bundle must contain at least one mockup");
+  }
+  const id = readIdentifier(value.id, "Bundle id");
+  const mockups = value.mockups.map(parseMockupEntry);
+  const entryIds = /* @__PURE__ */ new Set();
+  for (const mockup of mockups) {
+    if (entryIds.has(mockup.id)) throw new Error(`Duplicate mockup id: ${mockup.id}`);
+    entryIds.add(mockup.id);
+  }
+  return {
+    format: MOCKUP_BUNDLE_FORMAT,
+    version: 1,
+    id,
+    name: readString(value.name, "Bundle name"),
+    author: readString(value.author, "Bundle author"),
+    license: parseLicense(value.license),
+    ...value.source === void 0 ? {} : { source: parseSource(value.source) },
+    mockups
+  };
+}
+function resolveMockupBundle(manifest, baseUrl, origin) {
+  const bundlePrefix = `${manifest.id}/`;
+  const mockups = manifest.mockups.map((entry) => ({
+    ...entry,
+    id: `${bundlePrefix}${entry.id}`,
+    bundleId: manifest.id,
+    groupId: `${bundlePrefix}${entry.groupId}`,
+    frameUrl: `${baseUrl}${encodeBundlePath(entry.frame)}`,
+    thumbnailUrl: `${baseUrl}${encodeBundlePath(entry.thumbnail ?? entry.frame)}`
+  }));
+  const groupEntries = /* @__PURE__ */ new Map();
+  for (const mockup of mockups) {
+    const entries = groupEntries.get(mockup.groupId) ?? [];
+    entries.push(mockup);
+    groupEntries.set(mockup.groupId, entries);
+  }
+  return {
+    bundles: [{
+      id: manifest.id,
+      name: manifest.name,
+      author: manifest.author,
+      license: manifest.license,
+      ...manifest.source ? { source: manifest.source } : {},
+      mockupCount: mockups.length,
+      origin
+    }],
+    groups: [...groupEntries.entries()].map(([id, entries]) => ({
+      id,
+      bundleId: manifest.id,
+      name: manifest.mockups.find((entry) => `${bundlePrefix}${entry.groupId}` === id)?.groupName ?? entries[0].name,
+      platform: entries[0].platform,
+      style: entries[0].style,
+      thumbnailUrl: entries[0].thumbnailUrl,
+      count: entries.length
+    })),
+    mockups
+  };
+}
+function mergeDeviceMockupCatalogs(...catalogs) {
+  const result = emptyDeviceMockupCatalog();
+  const bundleIds = /* @__PURE__ */ new Set();
+  const groupIds = /* @__PURE__ */ new Set();
+  const mockupIds = /* @__PURE__ */ new Set();
+  for (const catalog of catalogs) {
+    for (const bundle of catalog.bundles) {
+      if (bundleIds.has(bundle.id)) continue;
+      bundleIds.add(bundle.id);
+      result.bundles.push(bundle);
+    }
+    for (const group of catalog.groups) {
+      if (groupIds.has(group.id)) continue;
+      groupIds.add(group.id);
+      result.groups.push(group);
+    }
+    for (const mockup of catalog.mockups) {
+      if (mockupIds.has(mockup.id)) continue;
+      mockupIds.add(mockup.id);
+      result.mockups.push(mockup);
+    }
+  }
+  return result;
+}
+function bundleAssetPaths(manifest) {
+  const paths = /* @__PURE__ */ new Set();
+  if (manifest.license.file) paths.add(manifest.license.file);
+  for (const mockup of manifest.mockups) {
+    paths.add(mockup.frame);
+    if (mockup.thumbnail) paths.add(mockup.thumbnail);
+  }
+  return [...paths];
+}
+function isSafeBundlePath(value) {
+  if (!value || value.startsWith("/") || value.includes("\\")) return false;
+  const parts = value.split("/");
+  return parts.every((part) => part.length > 0 && part !== "." && part !== "..");
+}
+function parseMockupEntry(value) {
+  if (!isRecord(value)) throw new Error("Mockup entry must be an object");
+  const platform = readString(value.platform, "Mockup platform");
+  const style = readString(value.style, "Mockup style");
+  if (!platforms.has(platform)) throw new Error(`Unsupported mockup platform: ${platform}`);
+  if (!styles.has(style)) throw new Error(`Unsupported mockup style: ${style}`);
+  const frame = readFramePath(value.frame, "Mockup frame");
+  const thumbnail = value.thumbnail === void 0 ? void 0 : readFramePath(value.thumbnail, "Mockup thumbnail");
+  return {
+    id: readIdentifier(value.id, "Mockup id"),
+    groupId: readIdentifier(value.groupId, "Mockup group id"),
+    groupName: readString(value.groupName, "Mockup group name"),
+    name: readString(value.name, "Mockup name"),
+    description: readString(value.description, "Mockup description"),
+    platform,
+    style,
+    frame,
+    ...thumbnail ? { thumbnail } : {},
+    width: readDimension(value.width, "Mockup width"),
+    height: readDimension(value.height, "Mockup height"),
+    screen: parseScreen(value.screen)
+  };
+}
+function parseScreen(value) {
+  if (!isRecord(value)) throw new Error("Mockup screen must be an object");
+  if (value.kind === "rect") {
+    return {
+      kind: "rect",
+      x: readNumber(value.x, "Screen x"),
+      y: readNumber(value.y, "Screen y"),
+      width: readDimension(value.width, "Screen width"),
+      height: readDimension(value.height, "Screen height"),
+      cornerRadius: readNonNegative(value.cornerRadius, "Screen corner radius")
+    };
+  }
+  if (value.kind === "projective") {
+    if (!Array.isArray(value.transform) || value.transform.length !== 3) throw new Error("Projective transform must have three rows");
+    const transform = value.transform.map((row) => {
+      if (!Array.isArray(row) || row.length !== 3) throw new Error("Each projective transform row must have three numbers");
+      return row.map((entry) => readNumber(entry, "Projective transform value"));
+    });
+    if (!isRecord(value.sourceCornerRadius)) throw new Error("Projective source corner radius must be an object");
+    return {
+      kind: "projective",
+      transform,
+      sourceCornerRadius: {
+        x: readNonNegative(value.sourceCornerRadius.x, "Source corner radius x"),
+        y: readNonNegative(value.sourceCornerRadius.y, "Source corner radius y")
+      }
+    };
+  }
+  throw new Error("Unsupported mockup screen geometry");
+}
+function parseLicense(value) {
+  if (!isRecord(value)) throw new Error("Bundle license must be an object");
+  const file = value.file === void 0 ? void 0 : readBundlePath(value.file, "License file");
+  return {
+    name: readString(value.name, "License name"),
+    ...value.url === void 0 ? {} : { url: readString(value.url, "License URL") },
+    ...file ? { file } : {}
+  };
+}
+function parseSource(value) {
+  if (!isRecord(value)) throw new Error("Bundle source must be an object");
+  return {
+    ...value.name === void 0 ? {} : { name: readString(value.name, "Source name") },
+    url: readString(value.url, "Source URL"),
+    ...value.revision === void 0 ? {} : { revision: readString(value.revision, "Source revision") }
+  };
+}
+function readFramePath(value, name) {
+  const result = readBundlePath(value, name);
+  const extensionIndex = result.lastIndexOf(".");
+  const extension = extensionIndex >= 0 ? result.slice(extensionIndex).toLowerCase() : "";
+  if (!frameExtensions.has(extension)) throw new Error(`${name} has an unsupported file type`);
+  return result;
+}
+function readBundlePath(value, name) {
+  const result = readString(value, name);
+  if (!isSafeBundlePath(result)) throw new Error(`${name} must be a relative path inside the bundle`);
+  return result;
+}
+function readIdentifier(value, name) {
+  const result = readString(value, name);
+  if (!identifierPattern.test(result)) throw new Error(`${name} must use lowercase letters, numbers, and hyphens`);
+  return result;
+}
+function readString(value, name) {
+  const result = typeof value === "string" ? value.trim() : "";
+  if (!result) throw new Error(`${name} must be a non-empty string`);
+  return result;
+}
+function readNumber(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${name} must be a number`);
+  return value;
+}
+function readDimension(value, name) {
+  const result = readNumber(value, name);
+  if (result <= 0 || result > 2e4) throw new Error(`${name} is outside the supported range`);
+  return result;
+}
+function readNonNegative(value, name) {
+  const result = readNumber(value, name);
+  if (result < 0 || result > 2e4) throw new Error(`${name} is outside the supported range`);
+  return result;
+}
+function encodeBundlePath(value) {
+  return value.split("/").map(encodeURIComponent).join("/");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/image-metadata.ts
+function readImageMetadata(contents) {
+  return readPngMetadata(contents) ?? readJpegMetadata(contents) ?? readWebpMetadata(contents) ?? readSvgMetadata(contents);
+}
+function readSvgMetadata(contents) {
+  const source = contents.subarray(0, 64 * 1024).toString("utf8");
+  const svg = source.match(/<svg\b[^>]*>/i)?.[0];
+  if (!svg) return void 0;
+  const width = readSvgLength(svg, "width");
+  const height = readSvgLength(svg, "height");
+  if (width && height) return validDimensions(width, height);
+  const viewBox = svg.match(/\bviewBox\s*=\s*["']\s*([-+\d.e]+)[\s,]+([-+\d.e]+)[\s,]+([-+\d.e]+)[\s,]+([-+\d.e]+)\s*["']/i);
+  if (!viewBox) return void 0;
+  return validDimensions(Number(viewBox[3]), Number(viewBox[4]));
+}
+function readSvgLength(svg, attribute) {
+  const match = svg.match(new RegExp(`\\b${attribute}\\s*=\\s*["']\\s*([-+\\d.e]+)`, "i"));
+  const value = match ? Number(match[1]) : NaN;
+  return Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function detectScreenshotDeviceType(width, height) {
+  const shortSide = Math.min(width, height);
+  const longSide = Math.max(width, height);
+  const ratio = longSide / shortSide;
+  const dimensions = `${shortSide}x${longSide}`;
+  if (WATCH_SCREENSHOT_DIMENSIONS.has(dimensions)) return "watch";
+  if (IPAD_SCREENSHOT_DIMENSIONS.has(dimensions)) return "ipad";
+  if (IPHONE_SCREENSHOT_DIMENSIONS.has(dimensions) && (height > width || longSide >= 2200)) return "iphone";
+  if (longSide <= 700 && ratio <= 1.4) return "watch";
+  if (shortSide >= 1400 && ratio >= 1.25 && ratio <= 1.45) return "ipad";
+  if (height > width && ratio >= 1.65) return "iphone";
+  if (width > height && ratio >= 1.45) return "mac";
+  if (shortSide >= 1e3 && ratio >= 1.25 && ratio <= 1.45) return "ipad";
+  return "unknown";
+}
+var IPHONE_SCREENSHOT_DIMENSIONS = /* @__PURE__ */ new Set([
+  "640x1136",
+  "750x1334",
+  "828x1792",
+  "1080x1920",
+  "1125x2436",
+  "1170x2532",
+  "1179x2556",
+  "1206x2622",
+  "1242x2208",
+  "1242x2688",
+  "1284x2778",
+  "1290x2796",
+  "1320x2868"
+]);
+var IPAD_SCREENSHOT_DIMENSIONS = /* @__PURE__ */ new Set([
+  "1536x2048",
+  "1668x2224",
+  "1668x2388",
+  "2048x2732",
+  "2064x2752"
+]);
+var WATCH_SCREENSHOT_DIMENSIONS = /* @__PURE__ */ new Set([
+  "368x448",
+  "396x484",
+  "416x496",
+  "422x514"
+]);
+function readPngMetadata(contents) {
+  if (contents.length < 24 || contents.toString("ascii", 1, 4) !== "PNG") return void 0;
+  return validDimensions(contents.readUInt32BE(16), contents.readUInt32BE(20));
+}
+function readJpegMetadata(contents) {
+  if (contents.length < 4 || contents[0] !== 255 || contents[1] !== 216) return void 0;
+  let offset = 2;
+  while (offset + 8 < contents.length) {
+    if (contents[offset] !== 255) {
+      offset += 1;
+      continue;
+    }
+    const marker = contents[offset + 1];
+    offset += 2;
+    if (marker === 216 || marker === 217) continue;
+    if (offset + 2 > contents.length) return void 0;
+    const length = contents.readUInt16BE(offset);
+    if (length < 2 || offset + length > contents.length) return void 0;
+    if (isJpegStartOfFrame(marker) && length >= 7) {
+      return validDimensions(contents.readUInt16BE(offset + 5), contents.readUInt16BE(offset + 3));
+    }
+    offset += length;
+  }
+  return void 0;
+}
+function isJpegStartOfFrame(marker) {
+  return marker >= 192 && marker <= 207 && ![196, 200, 204].includes(marker);
+}
+function readWebpMetadata(contents) {
+  if (contents.length < 30 || contents.toString("ascii", 0, 4) !== "RIFF" || contents.toString("ascii", 8, 12) !== "WEBP") return void 0;
+  const type = contents.toString("ascii", 12, 16);
+  if (type === "VP8X") {
+    return validDimensions(readUInt24LE(contents, 24) + 1, readUInt24LE(contents, 27) + 1);
+  }
+  if (type === "VP8 " && contents.length >= 30 && contents[23] === 157 && contents[24] === 1 && contents[25] === 42) {
+    return validDimensions(contents.readUInt16LE(26) & 16383, contents.readUInt16LE(28) & 16383);
+  }
+  if (type === "VP8L" && contents.length >= 25 && contents[20] === 47) {
+    const bits = contents.readUInt32LE(21);
+    return validDimensions((bits & 16383) + 1, (bits >>> 14 & 16383) + 1);
+  }
+  return void 0;
+}
+function readUInt24LE(contents, offset) {
+  return contents[offset] | contents[offset + 1] << 8 | contents[offset + 2] << 16;
+}
+function validDimensions(width, height) {
+  return width > 0 && height > 0 ? { width, height } : void 0;
+}
+
+// src/screenshot-area.ts
+var defaultIdFactory = () => globalThis.crypto.randomUUID();
+function cloneCanvasElement(element, { idFactory = defaultIdFactory, offsetX = 0, offsetY = 0 } = {}) {
+  return {
+    ...structuredClone(element),
+    id: `element-${idFactory()}`,
+    x: element.x + offsetX,
+    y: element.y + offsetY
+  };
+}
+function cloneScreenshotArea(area, { idFactory = defaultIdFactory, name = area.name } = {}) {
+  return {
+    ...structuredClone(area),
+    id: `area-${idFactory()}`,
+    name,
+    elements: area.elements.map((element) => cloneCanvasElement(element, { idFactory }))
+  };
+}
+
+// src/shared.ts
+var ASSET_CATEGORIES = ["screenshots", "brand", "logos", "other"];
+var SCREENSHOT_DEVICE_TYPES = ["iphone", "ipad", "mac", "watch"];
+
+// src/project-store.ts
+var CONFIG_FILENAME = "storeshot.json";
+var ASSETS_DIRECTORY = "assets";
+var SETS_DIRECTORY = "sets";
+var ASSET_METADATA_FILENAME = ".storeshot-metadata.json";
+var MOCKUP_BUNDLES_DIRECTORY = "mockup-bundles";
+var MOCKUP_IMPORTS_DIRECTORY = ".imports";
+var supportedExtensions = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".svg"]);
+var supportedMockupBundleExtensions = /* @__PURE__ */ new Set([".jpeg", ".jpg", ".md", ".png", ".svg", ".txt", ".webp"]);
+var safeIdentifierPattern = /^[a-z0-9][a-z0-9-]*$/;
+var hexColorPattern = /^#[0-9a-f]{6}$/i;
+var ProjectStore = class {
+  root;
+  configPath;
+  assetsPath;
+  setsPath;
+  mockupBundlesPath;
+  mockupImportsPath;
+  operations = /* @__PURE__ */ new Map();
+  assetHashes = /* @__PURE__ */ new Map();
+  constructor(directory) {
+    this.root = path.resolve(directory);
+    this.configPath = path.join(this.root, CONFIG_FILENAME);
+    this.assetsPath = path.join(this.root, ASSETS_DIRECTORY);
+    this.setsPath = path.join(this.root, SETS_DIRECTORY);
+    this.mockupBundlesPath = path.join(this.root, MOCKUP_BUNDLES_DIRECTORY);
+    this.mockupImportsPath = path.join(this.mockupBundlesPath, MOCKUP_IMPORTS_DIRECTORY);
+  }
+  async initialize() {
+    await mkdir(this.root, { recursive: true });
+    await this.assertManagedDirectory(this.root);
+    await this.ensureManagedDirectory(this.assetsPath, this.root);
+    await this.ensureManagedDirectory(this.setsPath, this.root);
+    await this.ensureManagedDirectory(this.mockupBundlesPath, this.root);
+    await rm(this.mockupImportsPath, { recursive: true, force: true });
+    await this.ensureManagedDirectory(this.mockupImportsPath, this.mockupBundlesPath);
+    for (const category of ASSET_CATEGORIES) {
+      await this.ensureManagedDirectory(path.join(this.assetsPath, category), this.assetsPath);
+    }
+    try {
+      await access(this.configPath, constants.F_OK);
+    } catch {
+      await this.writeConfig({
+        version: 1,
+        appName: path.basename(this.root),
+        platforms: ["ios"]
+      });
+    }
+  }
+  async readProject() {
+    const [config, assets, sets] = await Promise.all([this.readConfig(), this.listAssets(), this.listSets()]);
+    return { directory: this.root, config, assets, sets };
+  }
+  async readConfig() {
+    const value = JSON.parse(await this.readManagedFile(this.configPath, this.root, "utf8"));
+    return parseConfig(value);
+  }
+  async writeConfig(config) {
+    const value = parseConfig(config);
+    await this.runExclusive(this.configPath, async () => {
+      await this.assertSafeWriteTarget(this.configPath, this.root);
+      await writeJson(this.configPath, value);
+    });
+    return value;
+  }
+  async listAssets() {
+    const entries = await Promise.all(
+      ASSET_CATEGORIES.map(async (category) => [category, await this.listAssetsInCategory(category)])
+    );
+    return Object.fromEntries(entries);
+  }
+  async deleteAsset(category, filename) {
+    const target = await this.resolveExistingAsset(category, filename);
+    await this.runExclusive(target, async () => unlink(target));
+    this.assetHashes.delete(target);
+    await this.updateAssetMetadataFile((metadata) => {
+      delete metadata[`${category}/${filename}`];
+    });
+  }
+  async updateAssetMetadata(category, filename, input) {
+    await this.resolveExistingAsset(category, filename);
+    if (category !== "screenshots") throw new Error("Device type can only be set for raw screenshots");
+    const deviceType = input.deviceType;
+    if (deviceType !== null && !SCREENSHOT_DEVICE_TYPES.includes(deviceType)) throw new Error("Unsupported screenshot device type");
+    await this.updateAssetMetadataFile((metadata) => {
+      const id = `${category}/${filename}`;
+      if (deviceType === null) delete metadata[id];
+      else metadata[id] = { deviceType };
+    });
+  }
+  async addAsset(category, filename, contents) {
+    const target = this.resolveAsset(category, filename);
+    assertValidImage(filename, contents);
+    return this.runExclusive("asset-catalog", async () => {
+      await this.assertSafeWriteTarget(target, path.dirname(target));
+      const incomingHash = hash(contents);
+      const replaced = await access(target, constants.F_OK).then(() => true).catch(() => false);
+      for (const assetCategory of ASSET_CATEGORIES) {
+        const directory = path.join(this.assetsPath, assetCategory);
+        const entries = await readdir(directory, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isFile() || !supportedExtensions.has(path.extname(entry.name).toLowerCase())) continue;
+          const existingPath = path.join(directory, entry.name);
+          if (existingPath === target) continue;
+          if (await this.hashAsset(existingPath, directory) === incomingHash) {
+            throw new DuplicateAssetError(`${assetCategory}/${entry.name}`);
+          }
+        }
+      }
+      await writeFileAtomically(target, contents);
+      const metadata = await stat(target);
+      this.assetHashes.set(target, { hash: incomingHash, mtimeMs: metadata.mtimeMs, size: metadata.size });
+      return { replaced };
+    });
+  }
+  resolveAsset(category, filename) {
+    if (!isAssetCategory(category)) throw new Error("Unsupported asset category");
+    const safeName = path.basename(filename);
+    const extension = path.extname(safeName).toLowerCase();
+    if (safeName !== filename || !supportedExtensions.has(extension)) {
+      throw new Error("Unsupported asset filename");
+    }
+    return path.join(this.assetsPath, category, safeName);
+  }
+  async resolveExistingAsset(category, filename) {
+    const target = this.resolveAsset(category, filename);
+    await this.assertRegularFile(target);
+    const resolved = await realpath(target);
+    await this.assertContained(resolved, path.join(this.assetsPath, category));
+    return resolved;
+  }
+  async listSets() {
+    const entries = await readdir(this.setsPath, { withFileTypes: true });
+    const sets = await Promise.all(
+      entries.filter((entry) => entry.isFile() && path.extname(entry.name) === ".json").map(async (entry) => parseSet(JSON.parse(await this.readManagedFile(path.join(this.setsPath, entry.name), this.setsPath, "utf8"))))
+    );
+    return sets.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  }
+  async createSet(input) {
+    const value = parseCreateSetInput(input);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = `${slugify(value.name)}-${randomUUID().slice(0, 8)}`;
+    const areaId = `area-${randomUUID()}`;
+    const set = {
+      version: 1,
+      id,
+      name: value.name,
+      locale: value.locale,
+      device: value.device,
+      canvas: { width: value.width, height: value.height },
+      areas: [
+        {
+          id: areaId,
+          name: "Screenshot 1",
+          background: "#245f4a",
+          elements: [
+            {
+              id: `element-${randomUUID()}`,
+              type: "text",
+              text: "Your headline",
+              x: Math.round(value.width * 0.08),
+              y: Math.round(value.height * 0.07),
+              width: Math.round(value.width * 0.84),
+              height: Math.round(value.height * 0.2),
+              rotation: 0,
+              opacity: 1,
+              fontFamily: "Geist Variable",
+              fontSize: Math.max(48, Math.round(value.width * 0.09)),
+              fontWeight: 700,
+              color: "#ffffff",
+              textAlign: "center"
+            }
+          ]
+        }
+      ],
+      createdAt: now,
+      updatedAt: now
+    };
+    const target = this.resolveSet(id);
+    await this.runExclusive(target, async () => {
+      await this.assertSafeWriteTarget(target, this.setsPath);
+      await writeJson(target, set);
+    });
+    return set;
+  }
+  async duplicateSet(id) {
+    const source = await this.readSet(id);
+    const existingSets = await this.listSets();
+    const name = duplicateName(source.name, existingSets.map((set) => set.name));
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const duplicate = {
+      ...structuredClone(source),
+      id: `${slugify(name)}-${randomUUID().slice(0, 8)}`,
+      name,
+      areas: source.areas.map((area) => cloneScreenshotArea(area, { idFactory: randomUUID })),
+      createdAt: now,
+      updatedAt: now
+    };
+    const target = this.resolveSet(duplicate.id);
+    await this.runExclusive(target, async () => {
+      await this.assertSafeWriteTarget(target, this.setsPath);
+      await writeJson(target, duplicate);
+    });
+    return duplicate;
+  }
+  async writeSet(id, set) {
+    if (id !== set.id) throw new Error("Set id cannot be changed");
+    const target = this.resolveSet(id);
+    return this.runExclusive(target, async () => {
+      const value = parseSet({ ...set, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      await this.assertSafeWriteTarget(target, this.setsPath);
+      await writeJson(target, value);
+      return value;
+    });
+  }
+  async updateSetMetadata(id, input) {
+    const metadata = parseSetMetadataInput(input);
+    const target = this.resolveSet(id);
+    return this.runExclusive(target, async () => {
+      const current = parseSet(JSON.parse(await this.readManagedFile(target, this.setsPath, "utf8")));
+      const value = parseSet({ ...current, ...metadata, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      await writeJson(target, value);
+      return value;
+    });
+  }
+  async deleteSet(id) {
+    const target = this.resolveSet(id);
+    await this.runExclusive(target, async () => {
+      await this.assertRegularFile(target);
+      await unlink(target);
+    });
+  }
+  async listMockupCatalog() {
+    const entries = await readdir(this.mockupBundlesPath, { withFileTypes: true });
+    const catalogs = (await Promise.all(entries.filter((entry) => entry.isDirectory() && safeIdentifierPattern.test(entry.name)).map(async (entry) => {
+      const manifestPath = path.join(this.mockupBundlesPath, entry.name, MOCKUP_BUNDLE_FILENAME);
+      let contents;
+      try {
+        contents = await this.readManagedFile(manifestPath, path.dirname(manifestPath), "utf8");
+      } catch (error) {
+        if (error.code === "ENOENT") return void 0;
+        throw error;
+      }
+      const manifest = parseMockupBundleManifest(JSON.parse(contents));
+      if (manifest.id !== entry.name) throw new Error(`Mockup bundle folder ${entry.name} does not match manifest id ${manifest.id}`);
+      return resolveMockupBundle(
+        manifest,
+        `/api/mockup-bundle-files/${encodeURIComponent(manifest.id)}/`,
+        "project"
+      );
+    }))).filter((catalog) => catalog !== void 0);
+    return catalogs.length > 0 ? mergeDeviceMockupCatalogs(...catalogs) : emptyDeviceMockupCatalog();
+  }
+  async writeMockupBundleManifest(bundleId, input) {
+    if (!safeIdentifierPattern.test(bundleId)) throw new Error("Unsupported mockup bundle id");
+    if (bundleId === "frameup-free") throw new Error("frameup-free is reserved for StoreShot's built-in bundle");
+    const manifest = parseMockupBundleManifest(input);
+    if (manifest.id !== bundleId) throw new Error("Mockup bundle id cannot be changed");
+    const bundleDirectory = path.join(this.mockupBundlesPath, bundleId);
+    await this.ensureManagedDirectory(bundleDirectory, this.mockupBundlesPath);
+    await Promise.all(bundleAssetPaths(manifest).map(async (relativePath) => {
+      await this.resolveExistingMockupBundleFile(bundleId, relativePath);
+    }));
+    const manifestPath = path.join(bundleDirectory, MOCKUP_BUNDLE_FILENAME);
+    await this.runExclusive(manifestPath, async () => writeJson(manifestPath, manifest));
+    return manifest;
+  }
+  async writeMockupBundleFile(bundleId, relativePath, contents) {
+    if (bundleId === "frameup-free") throw new Error("frameup-free is reserved for StoreShot's built-in bundle");
+    const target = this.resolveMockupBundleFile(bundleId, relativePath);
+    if (isImageFile(relativePath)) assertValidImage(relativePath, contents);
+    await this.ensureManagedDirectory(path.dirname(target), this.mockupBundlesPath);
+    await this.assertSafeWriteTarget(target, path.dirname(target));
+    await this.runExclusive(target, async () => writeFileAtomically(target, contents));
+  }
+  async writeMockupBundleImportFile(importId, bundleId, relativePath, contents) {
+    this.assertMockupImportId(importId);
+    this.resolveMockupBundleFile(bundleId, relativePath);
+    if (isImageFile(relativePath)) assertValidImage(relativePath, contents);
+    const bundleDirectory = path.join(this.mockupImportsPath, importId, bundleId);
+    const target = path.resolve(bundleDirectory, relativePath);
+    if (!target.startsWith(`${bundleDirectory}${path.sep}`)) throw new Error("Mockup bundle file is outside the import");
+    await this.ensureManagedDirectory(path.dirname(target), this.mockupImportsPath);
+    await this.assertSafeWriteTarget(target, path.dirname(target));
+    await this.runExclusive(target, async () => writeFileAtomically(target, contents));
+  }
+  async commitMockupBundleImport(importId, bundleId, input) {
+    this.assertMockupImportId(importId);
+    if (!safeIdentifierPattern.test(bundleId)) throw new Error("Unsupported mockup bundle id");
+    if (bundleId === "frameup-free") throw new Error("frameup-free is reserved for StoreShot's built-in bundle");
+    const manifest = parseMockupBundleManifest(input);
+    if (manifest.id !== bundleId) throw new Error("Mockup bundle id cannot be changed");
+    const importDirectory = path.join(this.mockupImportsPath, importId);
+    const stagedBundle = path.join(importDirectory, bundleId);
+    await this.assertManagedDirectory(stagedBundle);
+    await Promise.all(bundleAssetPaths(manifest).map(async (relativePath) => {
+      const target = path.resolve(stagedBundle, relativePath);
+      if (!target.startsWith(`${stagedBundle}${path.sep}`)) throw new Error("Mockup bundle file is outside the import");
+      await this.readManagedFile(target, stagedBundle);
+    }));
+    await writeJson(path.join(stagedBundle, MOCKUP_BUNDLE_FILENAME), manifest);
+    const finalBundle = path.join(this.mockupBundlesPath, bundleId);
+    const backupBundle = path.join(this.mockupBundlesPath, `.${bundleId}.${randomUUID()}.backup`);
+    await this.runExclusive(`mockup-bundle:${bundleId}`, async () => {
+      let hasBackup = false;
+      try {
+        const metadata = await lstat(finalBundle);
+        if (!metadata.isDirectory() || metadata.isSymbolicLink()) throw new Error("Mockup bundle must be a regular directory");
+        await rename(finalBundle, backupBundle);
+        hasBackup = true;
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+      try {
+        await rename(stagedBundle, finalBundle);
+      } catch (error) {
+        if (hasBackup) await rename(backupBundle, finalBundle);
+        throw error;
+      }
+      if (hasBackup) await rm(backupBundle, { recursive: true, force: true }).catch(() => void 0);
+      await rm(importDirectory, { recursive: true, force: true }).catch(() => void 0);
+    });
+    return manifest;
+  }
+  async discardMockupBundleImport(importId) {
+    this.assertMockupImportId(importId);
+    const target = path.join(this.mockupImportsPath, importId);
+    const relative = path.relative(this.mockupImportsPath, target);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error("Mockup import is outside the project boundary");
+    await rm(target, { recursive: true, force: true });
+  }
+  resolveMockupBundleFile(bundleId, relativePath) {
+    if (!safeIdentifierPattern.test(bundleId)) throw new Error("Unsupported mockup bundle id");
+    if (!isSafeBundlePath(relativePath) || relativePath === MOCKUP_BUNDLE_FILENAME) {
+      throw new Error("Unsupported mockup bundle file path");
+    }
+    const extension = path.extname(relativePath).toLowerCase();
+    if (path.basename(relativePath) !== "LICENSE" && !supportedMockupBundleExtensions.has(extension)) {
+      throw new Error("Unsupported mockup bundle file type");
+    }
+    const bundleRoot = path.join(this.mockupBundlesPath, bundleId);
+    const target = path.resolve(bundleRoot, relativePath);
+    if (!target.startsWith(`${bundleRoot}${path.sep}`)) throw new Error("Mockup bundle file is outside the bundle");
+    return target;
+  }
+  async resolveExistingMockupBundleFile(bundleId, relativePath) {
+    const bundleRoot = await realpath(path.join(this.mockupBundlesPath, bundleId));
+    await this.assertContained(bundleRoot, this.mockupBundlesPath);
+    await this.assertRegularFile(this.resolveMockupBundleFile(bundleId, relativePath));
+    const target = await realpath(this.resolveMockupBundleFile(bundleId, relativePath));
+    if (!target.startsWith(`${bundleRoot}${path.sep}`)) throw new Error("Mockup bundle file is outside the bundle");
+    return target;
+  }
+  async listAssetsInCategory(category) {
+    const directory = path.join(this.assetsPath, category);
+    const entries = await readdir(directory, { withFileTypes: true });
+    const files = entries.filter((entry) => entry.isFile() && supportedExtensions.has(path.extname(entry.name).toLowerCase())).sort((a, b) => a.name.localeCompare(b.name));
+    const assetMetadata = await this.readAssetMetadata();
+    return Promise.all(
+      files.map(async (file) => {
+        const filename = path.join(directory, file.name);
+        const [metadata, contents] = await Promise.all([stat(filename), this.readManagedFile(filename, directory)]);
+        const dimensions = readImageMetadata(contents);
+        const detectedDeviceType = category === "screenshots" && dimensions ? detectScreenshotDeviceType(dimensions.width, dimensions.height) : void 0;
+        const deviceTypeOverride = assetMetadata[`${category}/${file.name}`]?.deviceType;
+        return {
+          id: `${category}/${file.name}`,
+          category,
+          name: file.name,
+          url: `/api/assets/${category}/${encodeURIComponent(file.name)}?v=${Math.trunc(metadata.mtimeMs)}`,
+          size: metadata.size,
+          modifiedAt: metadata.mtime.toISOString(),
+          ...dimensions ?? {},
+          ...detectedDeviceType ? {
+            detectedDeviceType,
+            deviceTypeOverride,
+            deviceType: deviceTypeOverride ?? detectedDeviceType
+          } : {}
+        };
+      })
+    );
+  }
+  async readAssetMetadata() {
+    const target = path.join(this.assetsPath, ASSET_METADATA_FILENAME);
+    try {
+      const value = JSON.parse(await this.readManagedFile(target, this.assetsPath, "utf8"));
+      if (!isRecord2(value) || value.version !== 1 || !isRecord2(value.assets)) return {};
+      return Object.fromEntries(Object.entries(value.assets).flatMap(([id, entry]) => {
+        if (!isRecord2(entry) || !SCREENSHOT_DEVICE_TYPES.includes(entry.deviceType)) return [];
+        return [[id, { deviceType: entry.deviceType }]];
+      }));
+    } catch (error) {
+      if (error.code === "ENOENT") return {};
+      throw error;
+    }
+  }
+  async writeAssetMetadata(assets) {
+    const target = path.join(this.assetsPath, ASSET_METADATA_FILENAME);
+    await this.assertSafeWriteTarget(target, this.assetsPath);
+    await writeJson(target, { version: 1, assets });
+  }
+  async updateAssetMetadataFile(update) {
+    const target = path.join(this.assetsPath, ASSET_METADATA_FILENAME);
+    await this.runExclusive(target, async () => {
+      const metadata = await this.readAssetMetadata();
+      update(metadata);
+      await this.writeAssetMetadata(metadata);
+    });
+  }
+  async hashAsset(filename, boundary) {
+    const metadata = await stat(filename);
+    const cached = this.assetHashes.get(filename);
+    if (cached && cached.mtimeMs === metadata.mtimeMs && cached.size === metadata.size) return cached.hash;
+    const value = hash(await this.readManagedFile(filename, boundary));
+    this.assetHashes.set(filename, { hash: value, mtimeMs: metadata.mtimeMs, size: metadata.size });
+    return value;
+  }
+  async readSet(id) {
+    const target = this.resolveSet(id);
+    return parseSet(JSON.parse(await this.readManagedFile(target, this.setsPath, "utf8")));
+  }
+  async runExclusive(key, operation) {
+    const previous = this.operations.get(key) ?? Promise.resolve();
+    const result = previous.catch(() => void 0).then(operation);
+    const tail = result.then(() => void 0, () => void 0);
+    this.operations.set(key, tail);
+    try {
+      return await result;
+    } finally {
+      if (this.operations.get(key) === tail) this.operations.delete(key);
+    }
+  }
+  async assertManagedDirectory(directory) {
+    const metadata = await lstat(directory);
+    if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+      throw new Error(`${path.relative(this.root, directory) || "."} must be a regular project directory`);
+    }
+    await this.assertContained(await realpath(directory), this.root, true);
+  }
+  async ensureManagedDirectory(directory, boundary) {
+    await this.assertManagedDirectory(boundary);
+    const relative = path.relative(boundary, directory);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error("Directory is outside the project boundary");
+    let current = boundary;
+    for (const segment of relative.split(path.sep).filter(Boolean)) {
+      current = path.join(current, segment);
+      try {
+        await mkdir(current);
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+      }
+      const metadata = await lstat(current);
+      if (!metadata.isDirectory() || metadata.isSymbolicLink()) throw new Error("Project directories cannot be symbolic links");
+    }
+    await this.assertContained(await realpath(directory), boundary, true);
+  }
+  async assertSafeWriteTarget(target, boundary) {
+    await this.assertManagedDirectory(boundary);
+    const relative = path.relative(boundary, target);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error("File is outside the project boundary");
+    try {
+      const metadata = await lstat(target);
+      if (metadata.isSymbolicLink() || !metadata.isFile()) throw new Error("Project files must be regular files");
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  async readManagedFile(filename, boundary, encoding) {
+    await this.assertRegularFile(filename);
+    await this.assertContained(await realpath(filename), boundary);
+    return encoding ? readFile(filename, encoding) : readFile(filename);
+  }
+  async assertRegularFile(filename) {
+    const metadata = await lstat(filename);
+    if (!metadata.isFile() || metadata.isSymbolicLink()) throw new Error("Project files must be regular files");
+  }
+  async assertContained(candidate, boundary, allowEqual = false) {
+    const resolvedBoundary = await realpath(boundary);
+    if (allowEqual && candidate === resolvedBoundary || candidate.startsWith(`${resolvedBoundary}${path.sep}`)) return;
+    throw new Error("File is outside the project boundary");
+  }
+  assertMockupImportId(importId) {
+    if (!safeIdentifierPattern.test(importId)) throw new Error("Unsupported mockup import id");
+  }
+  resolveSet(id) {
+    if (!safeIdentifierPattern.test(id)) throw new Error("Unsupported set id");
+    return path.join(this.setsPath, `${id}.json`);
+  }
+};
+var DuplicateAssetError = class extends Error {
+  constructor(existingAssetId) {
+    super(`This file is already in the asset catalog as ${existingAssetId}`);
+    this.existingAssetId = existingAssetId;
+  }
+  existingAssetId;
+};
+function hash(contents) {
+  return createHash("sha256").update(contents).digest("hex");
+}
+function parseConfig(value) {
+  if (!isRecord2(value)) throw new Error("storeshot.json must contain a JSON object");
+  const appName = readString2(value.appName, "appName");
+  const platforms2 = Array.isArray(value.platforms) ? value.platforms.filter((platform) => platform === "ios" || platform === "android") : [];
+  if (platforms2.length === 0) throw new Error("platforms must include ios or android");
+  return { version: 1, appName, platforms: [...new Set(platforms2)] };
+}
+function parseCreateSetInput(value) {
+  if (!isRecord2(value)) throw new Error("Set details must be an object");
+  return {
+    name: readString2(value.name, "Set name"),
+    locale: readString2(value.locale, "Locale"),
+    device: readString2(value.device, "Device"),
+    width: readDimension2(value.width, "Canvas width"),
+    height: readDimension2(value.height, "Canvas height")
+  };
+}
+function duplicateName(sourceName, existingNames) {
+  const names = new Set(existingNames.map((name) => name.toLocaleLowerCase()));
+  const baseName = `${sourceName} copy`;
+  if (!names.has(baseName.toLocaleLowerCase())) return baseName;
+  let copyNumber = 2;
+  while (names.has(`${baseName} ${copyNumber}`.toLocaleLowerCase())) copyNumber += 1;
+  return `${baseName} ${copyNumber}`;
+}
+function parseSetMetadataInput(value) {
+  if (!isRecord2(value)) throw new Error("Set settings must be an object");
+  return {
+    name: readString2(value.name, "Set name"),
+    locale: readString2(value.locale, "Locale"),
+    device: readString2(value.device, "Device")
+  };
+}
+function parseSet(value) {
+  if (!isRecord2(value)) throw new Error("Set file must contain an object");
+  const id = readString2(value.id, "Set id");
+  if (!safeIdentifierPattern.test(id)) throw new Error("Set id is invalid");
+  if (!isRecord2(value.canvas)) throw new Error("Set canvas is invalid");
+  if (!Array.isArray(value.areas) || value.areas.length === 0) throw new Error("A set needs at least one screenshot area");
+  return {
+    version: 1,
+    id,
+    name: readString2(value.name, "Set name"),
+    locale: readString2(value.locale, "Locale"),
+    device: readString2(value.device, "Device"),
+    canvas: {
+      width: readDimension2(value.canvas.width, "Canvas width"),
+      height: readDimension2(value.canvas.height, "Canvas height")
+    },
+    areas: value.areas.map(parseArea),
+    createdAt: readString2(value.createdAt, "Created time"),
+    updatedAt: readString2(value.updatedAt, "Updated time")
+  };
+}
+function parseArea(value) {
+  if (!isRecord2(value)) throw new Error("Screenshot area is invalid");
+  const background = readString2(value.background, "Area background");
+  if (!hexColorPattern.test(background)) throw new Error("Area background must be a hex color");
+  if (!Array.isArray(value.elements)) throw new Error("Area elements must be an array");
+  return {
+    id: readString2(value.id, "Area id"),
+    name: readString2(value.name, "Area name"),
+    background,
+    elements: value.elements.map(parseElement)
+  };
+}
+function parseImageSource(value, legacyAssetId) {
+  if (isRecord2(value)) {
+    if (value.kind === "builtin") return { kind: "builtin", id: readString2(value.id, "Built-in artwork id") };
+    if (value.kind === "asset") return { kind: "asset", assetId: readString2(value.assetId, "Asset id") };
+    throw new Error("Image source type is invalid");
+  }
+  if (legacyAssetId !== void 0) return { kind: "asset", assetId: readString2(legacyAssetId, "Asset id") };
+  throw new Error("Image source is invalid");
+}
+function parseElement(value) {
+  if (!isRecord2(value)) throw new Error("Canvas element is invalid");
+  const base = {
+    id: readString2(value.id, "Element id"),
+    x: readNumber2(value.x, "Element x"),
+    y: readNumber2(value.y, "Element y"),
+    width: readDimension2(value.width, "Element width"),
+    height: readDimension2(value.height, "Element height"),
+    rotation: readNumber2(value.rotation, "Element rotation"),
+    opacity: readOptionalRange(value.opacity, 1, 0, 1, "Element opacity")
+  };
+  if (value.type === "image") {
+    if (value.fit !== "contain" && value.fit !== "cover") throw new Error("Image fit is invalid");
+    const source = parseImageSource(value.source, value.assetId);
+    const fill = value.fill === void 0 ? void 0 : readString2(value.fill, "Image fill");
+    if (fill !== void 0 && !hexColorPattern.test(fill)) throw new Error("Image fill must be a hex color");
+    return { ...base, type: "image", source, fit: value.fit, ...fill === void 0 ? {} : { fill } };
+  }
+  if (value.type === "mockup") {
+    return {
+      ...base,
+      type: "mockup",
+      mockupId: readString2(value.mockupId, "Device mockup id"),
+      assetId: readString2(value.assetId, "Asset id")
+    };
+  }
+  if (value.type === "element") {
+    const source = parseImageSource(value.source);
+    const fill = value.fill === void 0 ? void 0 : readString2(value.fill, "Image fill");
+    if (fill !== void 0 && !hexColorPattern.test(fill)) throw new Error("Image fill must be a hex color");
+    return {
+      ...base,
+      type: "image",
+      source,
+      fit: "contain",
+      ...fill === void 0 ? {} : { fill }
+    };
+  }
+  if (value.type === "text") {
+    const fontWeight = Number(value.fontWeight);
+    if (!Number.isInteger(fontWeight) || fontWeight < 100 || fontWeight > 900 || fontWeight % 100 !== 0) {
+      throw new Error("Text weight is invalid");
+    }
+    if (value.textAlign !== "left" && value.textAlign !== "center" && value.textAlign !== "right") {
+      throw new Error("Text alignment is invalid");
+    }
+    const color = readString2(value.color, "Text color");
+    if (!hexColorPattern.test(color)) throw new Error("Text color must be a hex color");
+    const lineHeight = value.lineHeight === void 0 ? void 0 : readDimension2(value.lineHeight, "Text line height");
+    return {
+      ...base,
+      type: "text",
+      text: typeof value.text === "string" ? value.text : "",
+      fontFamily: readOptionalString(value.fontFamily, "Geist Variable"),
+      fontSize: readDimension2(value.fontSize, "Font size"),
+      fontWeight,
+      ...lineHeight === void 0 ? {} : { lineHeight },
+      color,
+      textAlign: value.textAlign
+    };
+  }
+  if (value.type === "shape") {
+    if (value.shape !== "rectangle") throw new Error("Shape type is invalid");
+    const fill = readString2(value.fill, "Shape fill");
+    if (!hexColorPattern.test(fill)) throw new Error("Shape fill must be a hex color");
+    return {
+      ...base,
+      type: "shape",
+      shape: value.shape,
+      fill,
+      cornerRadius: readOptionalRange(value.cornerRadius, 0, 0, 1e4, "Shape corner radius")
+    };
+  }
+  throw new Error("Unsupported canvas element type");
+}
+function readString2(value, name) {
+  const result = typeof value === "string" ? value.trim() : "";
+  if (!result) throw new Error(`${name} must be a non-empty string`);
+  return result;
+}
+function readNumber2(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${name} must be a number`);
+  return value;
+}
+function readOptionalRange(value, fallback, min, max, name) {
+  if (value === void 0) return fallback;
+  const result = readNumber2(value, name);
+  if (result < min || result > max) throw new Error(`${name} is outside the supported range`);
+  return result;
+}
+function readOptionalString(value, fallback) {
+  return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function readDimension2(value, name) {
+  const result = readNumber2(value, name);
+  if (result <= 0 || result > 2e4) throw new Error(`${name} is outside the supported range`);
+  return result;
+}
+function isAssetCategory(value) {
+  return ASSET_CATEGORIES.includes(value);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function slugify(value) {
+  const result = value.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return result || "set";
+}
+async function writeJson(filename, value) {
+  await writeFileAtomically(filename, `${JSON.stringify(value, null, 2)}
+`);
+}
+async function writeFileAtomically(filename, contents) {
+  const temporary = path.join(path.dirname(filename), `.${path.basename(filename)}.${randomUUID()}.tmp`);
+  try {
+    await writeFile(temporary, contents, { flag: "wx" });
+    await rename(temporary, filename);
+  } finally {
+    await unlink(temporary).catch((error) => {
+      if (error.code !== "ENOENT") throw error;
+    });
+  }
+}
+function isImageFile(filename) {
+  return supportedExtensions.has(path.extname(filename).toLowerCase());
+}
+function assertValidImage(filename, contents) {
+  if (!isImageFile(filename) || !readImageMetadata(contents)) throw new Error("The uploaded file is not a valid supported image");
+}
+
+// src/server.ts
+var MAX_REQUEST_BYTES = 25 * 1024 * 1024;
+async function startServer(options) {
+  const store = new ProjectStore(options.projectDirectory);
+  await store.initialize();
+  let vite;
+  if (options.useVite) {
+    const { createServer: createViteServer } = await import("vite");
+    vite = await createViteServer({
+      configFile: path2.join(options.packageRoot, "vite.config.ts"),
+      server: { middlewareMode: true },
+      appType: "spa"
+    });
+  }
+  const server = createServer(async (request, response) => {
+    try {
+      if ((request.url ?? "").startsWith("/api/")) assertAllowedBrowserRequest(request, options.host);
+      if (await handleApiRequest(request, response, store)) return;
+      if (vite) {
+        vite.middlewares(request, response);
+        return;
+      }
+      await serveBuiltFrontend(request, response, path2.join(options.packageRoot, "dist/ui"));
+    } catch (error) {
+      const failure = httpFailureFor(error, request);
+      if (failure.status >= 500) console.error(error);
+      if (!response.headersSent) sendJson(response, failure.status, { error: failure.message, ...failure.code ? { code: failure.code } : {} });
+      else response.end();
+    }
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(options.port, options.host, resolve);
+  });
+  return {
+    store,
+    port: server.address().port,
+    close: async () => {
+      await vite?.close();
+      await new Promise((resolve, reject) => {
+        server.close((error) => error ? reject(error) : resolve());
+      });
+    }
+  };
+}
+async function handleApiRequest(request, response, store) {
+  const url = new URL(request.url ?? "/", "http://localhost");
+  if (request.method === "GET" && url.pathname === "/api/project") {
+    sendJson(response, 200, await store.readProject());
+    return true;
+  }
+  if (request.method === "GET" && url.pathname === "/api/mockup-bundles") {
+    sendJson(response, 200, await store.listMockupCatalog());
+    return true;
+  }
+  const mockupBundleImportFileMatch = url.pathname.match(/^\/api\/mockup-bundle-imports\/([^/]+)\/([^/]+)\/files\/(.+)$/);
+  if (request.method === "PUT" && mockupBundleImportFileMatch) {
+    const importId = decodeURIComponent(mockupBundleImportFileMatch[1]);
+    const bundleId = decodeURIComponent(mockupBundleImportFileMatch[2]);
+    const relativePath = mockupBundleImportFileMatch[3].split("/").map(decodeURIComponent).join("/");
+    await store.writeMockupBundleImportFile(importId, bundleId, relativePath, await readBody(request));
+    response.writeHead(204).end();
+    return true;
+  }
+  const mockupBundleImportMatch = url.pathname.match(/^\/api\/mockup-bundle-imports\/([^/]+)\/([^/]+)$/);
+  if (request.method === "PUT" && mockupBundleImportMatch) {
+    const importId = decodeURIComponent(mockupBundleImportMatch[1]);
+    const bundleId = decodeURIComponent(mockupBundleImportMatch[2]);
+    await store.commitMockupBundleImport(importId, bundleId, await readJsonBody(request));
+    sendJson(response, 200, await store.listMockupCatalog());
+    return true;
+  }
+  const mockupBundleImportDiscardMatch = url.pathname.match(/^\/api\/mockup-bundle-imports\/([^/]+)$/);
+  if (request.method === "DELETE" && mockupBundleImportDiscardMatch) {
+    await store.discardMockupBundleImport(decodeURIComponent(mockupBundleImportDiscardMatch[1]));
+    response.writeHead(204).end();
+    return true;
+  }
+  const mockupBundleMatch = url.pathname.match(/^\/api\/mockup-bundles\/([^/]+)$/);
+  if (request.method === "PUT" && mockupBundleMatch) {
+    const bundleId = decodeURIComponent(mockupBundleMatch[1]);
+    await store.writeMockupBundleManifest(bundleId, await readJsonBody(request));
+    sendJson(response, 200, await store.listMockupCatalog());
+    return true;
+  }
+  const mockupBundleFileMatch = url.pathname.match(/^\/api\/mockup-bundle-files\/([^/]+)\/(.+)$/);
+  if (mockupBundleFileMatch) {
+    const bundleId = decodeURIComponent(mockupBundleFileMatch[1]);
+    const relativePath = mockupBundleFileMatch[2].split("/").map(decodeURIComponent).join("/");
+    if (request.method === "PUT") {
+      await store.writeMockupBundleFile(bundleId, relativePath, await readBody(request));
+      response.writeHead(204).end();
+      return true;
+    }
+    if (request.method === "GET") {
+      const target = await store.resolveExistingMockupBundleFile(bundleId, relativePath);
+      const metadata = await stat2(target);
+      response.writeHead(200, {
+        "Content-Type": contentTypeFor(target),
+        "Content-Length": metadata.size,
+        "Cache-Control": "no-store",
+        "X-Content-Type-Options": "nosniff",
+        ...path2.extname(target).toLowerCase() === ".svg" ? { "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox" } : {}
+      });
+      createReadStream(target).pipe(response);
+      return true;
+    }
+  }
+  if (request.method === "PATCH" && url.pathname === "/api/config") {
+    const config = await store.writeConfig(await readJsonBody(request));
+    sendJson(response, 200, config);
+    return true;
+  }
+  if (request.method === "POST" && url.pathname === "/api/assets") {
+    const category = url.searchParams.get("category");
+    const filename = url.searchParams.get("filename");
+    if (!category || !filename) {
+      sendJson(response, 400, { error: "A category and filename are required" });
+      return true;
+    }
+    let replaced = false;
+    try {
+      const result = await store.addAsset(category, filename, await readBody(request));
+      replaced = result.replaced;
+    } catch (error) {
+      if (error instanceof DuplicateAssetError) {
+        sendJson(response, 409, { error: error.message, code: "DUPLICATE_ASSET" });
+        return true;
+      }
+      throw error;
+    }
+    sendJson(response, replaced ? 200 : 201, { replaced });
+    return true;
+  }
+  const assetMatch = url.pathname.match(/^\/api\/assets\/([^/]+)\/([^/]+)$/);
+  if (assetMatch) {
+    const category = decodeURIComponent(assetMatch[1]);
+    const filename = decodeURIComponent(assetMatch[2]);
+    if (request.method === "GET") {
+      const target = await store.resolveExistingAsset(category, filename);
+      const metadata = await stat2(target);
+      response.writeHead(200, {
+        "Content-Type": contentTypeFor(target),
+        "Content-Length": metadata.size,
+        "Cache-Control": "no-store",
+        "X-Content-Type-Options": "nosniff",
+        ...path2.extname(target).toLowerCase() === ".svg" ? { "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox" } : {}
+      });
+      createReadStream(target).pipe(response);
+      return true;
+    }
+    if (request.method === "DELETE") {
+      await store.deleteAsset(category, filename);
+      response.writeHead(204).end();
+      return true;
+    }
+    if (request.method === "PATCH") {
+      await store.updateAssetMetadata(category, filename, await readJsonBody(request));
+      sendJson(response, 200, await store.readProject());
+      return true;
+    }
+  }
+  if (request.method === "POST" && url.pathname === "/api/sets") {
+    const set = await store.createSet(await readJsonBody(request));
+    sendJson(response, 201, set);
+    return true;
+  }
+  const duplicateSetMatch = url.pathname.match(/^\/api\/sets\/([^/]+)\/duplicate$/);
+  if (request.method === "POST" && duplicateSetMatch) {
+    const set = await store.duplicateSet(decodeURIComponent(duplicateSetMatch[1]));
+    sendJson(response, 201, set);
+    return true;
+  }
+  const setMatch = url.pathname.match(/^\/api\/sets\/([^/]+)$/);
+  if (setMatch) {
+    const id = decodeURIComponent(setMatch[1]);
+    if (request.method === "PATCH") {
+      const set = await store.updateSetMetadata(id, await readJsonBody(request));
+      sendJson(response, 200, set);
+      return true;
+    }
+    if (request.method === "PUT") {
+      const set = await store.writeSet(id, await readJsonBody(request));
+      sendJson(response, 200, set);
+      return true;
+    }
+    if (request.method === "DELETE") {
+      await store.deleteSet(id);
+      response.writeHead(204).end();
+      return true;
+    }
+  }
+  if (url.pathname.startsWith("/api/")) {
+    sendJson(response, 404, { error: "Not found" });
+    return true;
+  }
+  return false;
+}
+async function serveBuiltFrontend(request, response, uiDirectory) {
+  const url = new URL(request.url ?? "/", "http://localhost");
+  const relativePath = url.pathname === "/" ? "index.html" : decodeURIComponent(url.pathname.slice(1));
+  const candidate = path2.resolve(uiDirectory, relativePath);
+  const safeRoot = `${path2.resolve(uiDirectory)}${path2.sep}`;
+  const target = candidate.startsWith(safeRoot) ? candidate : path2.join(uiDirectory, "index.html");
+  try {
+    const metadata = await stat2(target);
+    if (!metadata.isFile()) throw new Error("Not a file");
+    const body = await readFile2(target);
+    response.writeHead(200, { "Content-Type": contentTypeFor(target), "Content-Length": body.length });
+    response.end(body);
+  } catch {
+    const body = await readFile2(path2.join(uiDirectory, "index.html"));
+    response.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+    response.end(body);
+  }
+}
+async function readJsonBody(request) {
+  const contentType = request.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase();
+  if (contentType !== "application/json") throw new HttpError(415, "Request body must use application/json");
+  const body = await readBody(request);
+  try {
+    return JSON.parse(body.toString("utf8"));
+  } catch {
+    throw new HttpError(400, "Request body must be valid JSON");
+  }
+}
+async function readBody(request) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += buffer.length;
+    if (size > MAX_REQUEST_BYTES) throw new HttpError(413, "Request is larger than 25 MB");
+    chunks.push(buffer);
+  }
+  return Buffer.concat(chunks);
+}
+var HttpError = class extends Error {
+  constructor(status, message, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+};
+function assertAllowedBrowserRequest(request, configuredHost) {
+  const host = request.headers.host;
+  if (!host) throw new HttpError(400, "A Host header is required");
+  let hostUrl;
+  try {
+    hostUrl = new URL(`http://${host}`);
+  } catch {
+    throw new HttpError(400, "The Host header is invalid");
+  }
+  const configuredHostname = normalizedHostname(configuredHost);
+  if (!isLoopbackHostname(hostUrl.hostname) && hostUrl.hostname !== configuredHostname) {
+    throw new HttpError(403, "This StoreShot server does not accept requests for that host");
+  }
+  const origin = request.headers.origin;
+  if (!origin) return;
+  let originUrl;
+  try {
+    originUrl = new URL(origin);
+  } catch {
+    throw new HttpError(403, "The request origin is invalid");
+  }
+  if (originUrl.protocol !== "http:" && originUrl.protocol !== "https:" || originUrl.host !== host) {
+    throw new HttpError(403, "Cross-origin API requests are not allowed");
+  }
+}
+function normalizedHostname(host) {
+  try {
+    return new URL(`http://${host}`).hostname;
+  } catch {
+    return host.replace(/^\[|\]$/g, "");
+  }
+}
+function isLoopbackHostname(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
+}
+function httpFailureFor(error, request) {
+  if (error instanceof HttpError) return error;
+  if (error instanceof DuplicateAssetError) return new HttpError(409, error.message, "DUPLICATE_ASSET");
+  const code = error?.code;
+  if (code === "ENOENT") return new HttpError(404, "The requested project file was not found");
+  if (code === "EACCES" || code === "EPERM") return new HttpError(403, "StoreShot cannot access that project file");
+  if (isMutation(request) && error instanceof Error && !code) return new HttpError(400, error.message);
+  return new HttpError(500, "StoreShot could not complete the request");
+}
+function isMutation(request) {
+  return request.method === "POST" || request.method === "PUT" || request.method === "PATCH" || request.method === "DELETE";
+}
+function sendJson(response, status, value) {
+  const body = JSON.stringify(value);
+  response.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Content-Length": Buffer.byteLength(body)
+  });
+  response.end(body);
+}
+function contentTypeFor(filename) {
+  switch (path2.extname(filename).toLowerCase()) {
+    case ".html":
+      return "text/html; charset=utf-8";
+    case ".js":
+      return "text/javascript; charset=utf-8";
+    case ".css":
+      return "text/css; charset=utf-8";
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".webp":
+      return "image/webp";
+    case ".svg":
+      return "image/svg+xml";
+    case ".md":
+    case ".txt":
+      return "text/plain; charset=utf-8";
+    default:
+      return "application/octet-stream";
+  }
+}
+
+// src/cli.ts
+var sourceFile = fileURLToPath(import.meta.url);
+var packageRoot = path3.resolve(path3.dirname(sourceFile), "..");
+var isSourceExecution = path3.extname(sourceFile) === ".ts";
+var program = new Command().name("storeshot").description("Manage app store screenshots locally").version("0.1.0");
+program.command("dev").description("Open a StoreShot workspace for a local directory").argument("[directory]", "project directory", ".").addOption(new Option("-p, --port <port>", "local server port").default("4173")).addOption(new Option("--host <host>", "local server host").default("127.0.0.1")).option("--no-open", "do not open a browser").action(async (directory, options) => {
+  const port = Number(options.port);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error("Port must be an integer between 1 and 65535");
+  }
+  const projectDirectory = path3.resolve(directory);
+  const service = await startServer({
+    host: options.host,
+    port,
+    packageRoot,
+    projectDirectory,
+    useVite: isSourceExecution
+  });
+  const url = `http://${options.host}:${port}`;
+  console.log(`
+  StoreShot is ready at ${url}`);
+  console.log(`  Project: ${service.store.root}
+`);
+  if (options.open) await open(url);
+  const shutdown = async () => {
+    await service.close();
+    process.exit(0);
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+});
+program.parseAsync().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`storeshot: ${message}`);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map