storeshot 0.1.0 → 0.2.0

package/dist/cli.js

@@ -1,258 +1,32 @@
 #!/usr/bin/env node
+import {
+  ASSET_CATEGORIES,
+  BUILT_IN_ARTWORK,
+  MOCKUP_BUNDLE_FILENAME,
+  SCREENSHOT_DEVICE_TYPES,
+  bundleAssetPaths,
+  emptyDeviceMockupCatalog,
+  isSafeBundlePath,
+  mergeDeviceMockupCatalogs,
+  parseMockupBundleManifest,
+  resolveMockupBundle,
+  resolvePackagePublicDirectory
+} from "./chunk-I7JOE7XJ.js";
 
 // src/cli.ts
-import path3 from "path";
+import { constants as constants2 } from "fs";
+import { access as access2, readFile as readFile4 } from "fs/promises";
+import path4 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);
@@ -385,10 +159,6 @@ function cloneScreenshotArea(area, { idFactory = defaultIdFactory, name = area.n
   };
 }
 
-// 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";
@@ -444,10 +214,10 @@ var ProjectStore = class {
   }
   async readConfig() {
     const value = JSON.parse(await this.readManagedFile(this.configPath, this.root, "utf8"));
-    return parseConfig(value);
+    return parseStoreShotConfig(value);
   }
   async writeConfig(config) {
-    const value = parseConfig(config);
+    const value = parseStoreShotConfig(config);
     await this.runExclusive(this.configPath, async () => {
       await this.assertSafeWriteTarget(this.configPath, this.root);
       await writeJson(this.configPath, value);
@@ -523,7 +293,7 @@ var ProjectStore = class {
   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"))))
+      entries.filter((entry) => entry.isFile() && path.extname(entry.name) === ".json").map(async (entry) => parseScreenshotSet(JSON.parse(await this.readManagedFile(path.join(this.setsPath, entry.name), this.setsPath, "utf8"))))
     );
     return sets.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
   }
@@ -598,7 +368,7 @@ var ProjectStore = class {
     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() });
+      const value = parseScreenshotSet({ ...set, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
       await this.assertSafeWriteTarget(target, this.setsPath);
       await writeJson(target, value);
       return value;
@@ -608,8 +378,8 @@ var ProjectStore = class {
     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() });
+      const current = parseScreenshotSet(JSON.parse(await this.readManagedFile(target, this.setsPath, "utf8")));
+      const value = parseScreenshotSet({ ...current, ...metadata, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
       await writeJson(target, value);
       return value;
     });
@@ -775,9 +545,9 @@ var ProjectStore = class {
     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 {};
+      if (!isRecord(value) || value.version !== 1 || !isRecord(value.assets)) return {};
       return Object.fromEntries(Object.entries(value.assets).flatMap(([id, entry]) => {
-        if (!isRecord2(entry) || !SCREENSHOT_DEVICE_TYPES.includes(entry.deviceType)) return [];
+        if (!isRecord(entry) || !SCREENSHOT_DEVICE_TYPES.includes(entry.deviceType)) return [];
         return [[id, { deviceType: entry.deviceType }]];
       }));
     } catch (error) {
@@ -808,7 +578,7 @@ var ProjectStore = class {
   }
   async readSet(id) {
     const target = this.resolveSet(id);
-    return parseSet(JSON.parse(await this.readManagedFile(target, this.setsPath, "utf8")));
+    return parseScreenshotSet(JSON.parse(await this.readManagedFile(target, this.setsPath, "utf8")));
   }
   async runExclusive(key, operation) {
     const previous = this.operations.get(key) ?? Promise.resolve();
@@ -888,21 +658,24 @@ var DuplicateAssetError = class extends Error {
 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 parseStoreShotConfig(value) {
+  if (!isRecord(value)) throw new Error("storeshot.json must contain a JSON object");
+  if (value.version !== 1) throw new Error("Unsupported storeshot.json version");
+  const appName = readString(value.appName, "appName");
+  if (!Array.isArray(value.platforms) || value.platforms.length === 0 || value.platforms.some((platform) => platform !== "ios" && platform !== "android")) {
+    throw new Error("platforms must contain only ios or android");
+  }
+  const platforms = value.platforms;
+  return { version: 1, appName, platforms: [...new Set(platforms)] };
 }
 function parseCreateSetInput(value) {
-  if (!isRecord2(value)) throw new Error("Set details must be an object");
+  if (!isRecord(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")
+    name: readString(value.name, "Set name"),
+    locale: readString(value.locale, "Locale"),
+    device: readString(value.device, "Device"),
+    width: readDimension(value.width, "Canvas width"),
+    height: readDimension(value.height, "Canvas height")
   };
 }
 function duplicateName(sourceName, existingNames) {
@@ -914,70 +687,73 @@ function duplicateName(sourceName, existingNames) {
   return `${baseName} ${copyNumber}`;
 }
 function parseSetMetadataInput(value) {
-  if (!isRecord2(value)) throw new Error("Set settings must be an object");
+  if (!isRecord(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")
+    name: readString(value.name, "Set name"),
+    locale: readString(value.locale, "Locale"),
+    device: readString(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");
+function parseScreenshotSet(value) {
+  if (!isRecord(value)) throw new Error("Set file must contain an object");
+  if (value.version !== 1) throw new Error("Unsupported set file version");
+  const id = readString(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 (!isRecord(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"),
+    name: readString(value.name, "Set name"),
+    locale: readString(value.locale, "Locale"),
+    device: readString(value.device, "Device"),
     canvas: {
-      width: readDimension2(value.canvas.width, "Canvas width"),
-      height: readDimension2(value.canvas.height, "Canvas height")
+      width: readDimension(value.canvas.width, "Canvas width"),
+      height: readDimension(value.canvas.height, "Canvas height")
     },
     areas: value.areas.map(parseArea),
-    createdAt: readString2(value.createdAt, "Created time"),
-    updatedAt: readString2(value.updatedAt, "Updated time")
+    createdAt: readString(value.createdAt, "Created time"),
+    updatedAt: readString(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 (!isRecord(value)) throw new Error("Screenshot area is invalid");
+  const background = readString(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"),
+    id: readString(value.id, "Area id"),
+    name: readString(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") };
+  if (isRecord(value)) {
+    if (value.kind === "builtin") return { kind: "builtin", id: readString(value.id, "Built-in artwork id") };
+    if (value.kind === "asset") return { kind: "asset", assetId: readString(value.assetId, "Asset id") };
     throw new Error("Image source type is invalid");
   }
-  if (legacyAssetId !== void 0) return { kind: "asset", assetId: readString2(legacyAssetId, "Asset id") };
+  if (legacyAssetId !== void 0) return { kind: "asset", assetId: readString(legacyAssetId, "Asset id") };
   throw new Error("Image source is invalid");
 }
 function parseElement(value) {
-  if (!isRecord2(value)) throw new Error("Canvas element is invalid");
+  if (!isRecord(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")
+    id: readString(value.id, "Element id"),
+    x: readNumber(value.x, "Element x"),
+    y: readNumber(value.y, "Element y"),
+    width: readDimension(value.width, "Element width"),
+    height: readDimension(value.height, "Element height"),
+    rotation: readNumber(value.rotation, "Element rotation"),
+    opacity: readOptionalRange(value.opacity, 1, 0, 1, "Element opacity"),
+    flipX: readOptionalBoolean(value.flipX, false, "Element horizontal flip"),
+    flipY: readOptionalBoolean(value.flipY, false, "Element vertical flip")
   };
   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");
+    const fill = value.fill === void 0 ? void 0 : readString(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 } };
   }
@@ -985,13 +761,13 @@ function parseElement(value) {
     return {
       ...base,
       type: "mockup",
-      mockupId: readString2(value.mockupId, "Device mockup id"),
-      assetId: readString2(value.assetId, "Asset id")
+      mockupId: readString(value.mockupId, "Device mockup id"),
+      assetId: readString(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");
+    const fill = value.fill === void 0 ? void 0 : readString(value.fill, "Image fill");
     if (fill !== void 0 && !hexColorPattern.test(fill)) throw new Error("Image fill must be a hex color");
     return {
       ...base,
@@ -1009,15 +785,15 @@ function parseElement(value) {
     if (value.textAlign !== "left" && value.textAlign !== "center" && value.textAlign !== "right") {
       throw new Error("Text alignment is invalid");
     }
-    const color = readString2(value.color, "Text color");
+    const color = readString(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");
+    const lineHeight = value.lineHeight === void 0 ? void 0 : readDimension(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"),
+      fontSize: readDimension(value.fontSize, "Font size"),
       fontWeight,
       ...lineHeight === void 0 ? {} : { lineHeight },
       color,
@@ -1026,7 +802,7 @@ function parseElement(value) {
   }
   if (value.type === "shape") {
     if (value.shape !== "rectangle") throw new Error("Shape type is invalid");
-    const fill = readString2(value.fill, "Shape fill");
+    const fill = readString(value.fill, "Shape fill");
     if (!hexColorPattern.test(fill)) throw new Error("Shape fill must be a hex color");
     return {
       ...base,
@@ -1038,33 +814,38 @@ function parseElement(value) {
   }
   throw new Error("Unsupported canvas element type");
 }
-function readString2(value, name) {
+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 readNumber2(value, name) {
+function readNumber(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);
+  const result = readNumber(value, name);
   if (result < min || result > max) throw new Error(`${name} is outside the supported range`);
   return result;
 }
+function readOptionalBoolean(value, fallback, name) {
+  if (value === void 0) return fallback;
+  if (typeof value !== "boolean") throw new Error(`${name} must be a boolean`);
+  return value;
+}
 function readOptionalString(value, fallback) {
   return typeof value === "string" && value.trim() ? value.trim() : fallback;
 }
-function readDimension2(value, name) {
-  const result = readNumber2(value, name);
+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 isAssetCategory(value) {
   return ASSET_CATEGORIES.includes(value);
 }
-function isRecord2(value) {
+function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function slugify(value) {
@@ -1094,10 +875,15 @@ function assertValidImage(filename, contents) {
 }
 
 // src/server.ts
+import { createReadStream, watch } from "fs";
+import { readFile as readFile2, stat as stat2 } from "fs/promises";
+import { createServer } from "http";
+import path2 from "path";
 var MAX_REQUEST_BYTES = 25 * 1024 * 1024;
 async function startServer(options) {
   const store = new ProjectStore(options.projectDirectory);
   await store.initialize();
+  const projectEvents = new ProjectEventHub(store.root);
   let vite;
   if (options.useVite) {
     const { createServer: createViteServer } = await import("vite");
@@ -1110,7 +896,7 @@ async function startServer(options) {
   const server = createServer(async (request, response) => {
     try {
       if ((request.url ?? "").startsWith("/api/")) assertAllowedBrowserRequest(request, options.host);
-      if (await handleApiRequest(request, response, store)) return;
+      if (await handleApiRequest(request, response, store, projectEvents)) return;
       if (vite) {
         vite.middlewares(request, response);
         return;
@@ -1131,6 +917,7 @@ async function startServer(options) {
     store,
     port: server.address().port,
     close: async () => {
+      projectEvents.close();
       await vite?.close();
       await new Promise((resolve, reject) => {
         server.close((error) => error ? reject(error) : resolve());
@@ -1138,8 +925,12 @@ async function startServer(options) {
     }
   };
 }
-async function handleApiRequest(request, response, store) {
+async function handleApiRequest(request, response, store, projectEvents) {
   const url = new URL(request.url ?? "/", "http://localhost");
+  if (request.method === "GET" && url.pathname === "/api/events") {
+    projectEvents.subscribe(request, response);
+    return true;
+  }
   if (request.method === "GET" && url.pathname === "/api/project") {
     sendJson(response, 200, await store.readProject());
     return true;
@@ -1418,41 +1209,577 @@ function contentTypeFor(filename) {
       return "application/octet-stream";
   }
 }
+var ProjectEventHub = class {
+  clients = /* @__PURE__ */ new Set();
+  scopes = /* @__PURE__ */ new Set();
+  watcher;
+  heartbeat;
+  broadcastTimer;
+  revision = 0;
+  constructor(root) {
+    this.watcher = watch(root, { recursive: true, encoding: "utf8" }, (_event, filename) => {
+      const relativePath = typeof filename === "string" ? filename.split(path2.sep).join("/") : "";
+      const scope = changeScope(relativePath);
+      if (!scope) return;
+      this.scopes.add(scope);
+      if (this.broadcastTimer) clearTimeout(this.broadcastTimer);
+      this.broadcastTimer = setTimeout(() => this.broadcast(), 75);
+    });
+    this.watcher.on("error", (error) => console.error("StoreShot project watcher failed", error));
+    this.heartbeat = setInterval(() => {
+      for (const response of this.clients) response.write(": keep-alive\n\n");
+    }, 15e3);
+    this.heartbeat.unref();
+  }
+  subscribe(request, response) {
+    response.writeHead(200, {
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no"
+    });
+    response.write(`event: ready
+data: ${JSON.stringify({ revision: this.revision })}
+
+`);
+    this.clients.add(response);
+    request.once("close", () => this.clients.delete(response));
+  }
+  close() {
+    if (this.broadcastTimer) clearTimeout(this.broadcastTimer);
+    clearInterval(this.heartbeat);
+    this.watcher.close();
+    for (const response of this.clients) response.end();
+    this.clients.clear();
+  }
+  broadcast() {
+    this.broadcastTimer = void 0;
+    if (this.scopes.size === 0) return;
+    this.revision += 1;
+    const data = JSON.stringify({ revision: this.revision, scopes: [...this.scopes].sort() });
+    this.scopes.clear();
+    for (const response of this.clients) response.write(`event: project
+data: ${data}
+
+`);
+  }
+};
+function changeScope(relativePath) {
+  if (!relativePath) return "project";
+  if (relativePath === "storeshot.json" || relativePath.startsWith(".storeshot.json.")) return "config";
+  if (relativePath === "sets" || relativePath.startsWith("sets/")) return "sets";
+  if (relativePath === "assets" || relativePath.startsWith("assets/")) return "assets";
+  if (relativePath.startsWith("mockup-bundles/.imports/")) return void 0;
+  if (relativePath === "mockup-bundles" || relativePath.startsWith("mockup-bundles/")) return "mockups";
+  if (relativePath === "renders" || relativePath.startsWith("renders/")) return void 0;
+  return "project";
+}
+
+// src/validation.ts
+import { lstat as lstat2, readFile as readFile3, readdir as readdir2 } from "fs/promises";
+import path3 from "path";
+async function validateProject(directory, packageRoot2) {
+  const root = path3.resolve(directory);
+  const issues = [];
+  const store = new ProjectStore(root);
+  let config;
+  let assets;
+  let mockupCatalog;
+  const sets = [];
+  if (!await checkDirectory(root, ".", issues)) return validationResult(root, issues, sets);
+  const configPath = path3.join(root, CONFIG_FILENAME);
+  try {
+    config = parseStoreShotConfig(JSON.parse(await readRegularFile(configPath, root)));
+  } catch (error) {
+    issues.push(issue("error", "config.invalid", CONFIG_FILENAME, messageFor(error)));
+  }
+  const assetsReady = await checkDirectory(path3.join(root, ASSETS_DIRECTORY), ASSETS_DIRECTORY, issues);
+  const setsReady = await checkDirectory(path3.join(root, SETS_DIRECTORY), SETS_DIRECTORY, issues);
+  const mockupsReady = await checkDirectory(path3.join(root, MOCKUP_BUNDLES_DIRECTORY), MOCKUP_BUNDLES_DIRECTORY, issues);
+  if (setsReady) {
+    const entries = await readdir2(store.setsPath, { withFileTypes: true });
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+      if (!entry.name.endsWith(".json")) continue;
+      const relativePath = `${SETS_DIRECTORY}/${entry.name}`;
+      if (!entry.isFile() || entry.isSymbolicLink()) {
+        issues.push(issue("error", "set.notRegularFile", relativePath, "Set documents must be regular JSON files"));
+        continue;
+      }
+      try {
+        const set = parseScreenshotSet(JSON.parse(await readRegularFile(path3.join(store.setsPath, entry.name), store.setsPath)));
+        sets.push(set);
+        if (entry.name !== `${set.id}.json`) {
+          issues.push(issue("error", "set.filenameMismatch", relativePath, `Set id ${set.id} must be stored in ${set.id}.json`));
+        }
+      } catch (error) {
+        issues.push(issue("error", "set.invalid", relativePath, messageFor(error)));
+      }
+    }
+  }
+  if (assetsReady) {
+    try {
+      assets = await store.listAssets();
+      for (const asset of Object.values(assets).flat()) {
+        if (!asset.width || !asset.height) {
+          issues.push(issue("error", "asset.invalidImage", `${ASSETS_DIRECTORY}/${asset.id}`, "Asset is not a valid supported image"));
+        }
+      }
+    } catch (error) {
+      issues.push(issue("error", "assets.invalid", ASSETS_DIRECTORY, messageFor(error)));
+    }
+  }
+  if (mockupsReady) {
+    try {
+      const [builtInCatalog, projectCatalog] = await Promise.all([
+        loadBuiltInMockupCatalog(packageRoot2),
+        store.listMockupCatalog()
+      ]);
+      mockupCatalog = mergeDeviceMockupCatalogs(builtInCatalog, projectCatalog);
+    } catch (error) {
+      issues.push(issue("error", "mockups.invalid", MOCKUP_BUNDLES_DIRECTORY, messageFor(error)));
+    }
+  }
+  validateSetSemantics(sets, assets, mockupCatalog, issues);
+  return validationResult(root, issues, sets, config, assets, mockupCatalog);
+}
+async function loadBuiltInMockupCatalog(packageRoot2) {
+  const publicDirectory = await resolvePackagePublicDirectory(packageRoot2);
+  const bundleDirectory = path3.join(publicDirectory, "mockup-bundles/frameup-free");
+  const manifest = parseMockupBundleManifest(JSON.parse(await readRegularFile(
+    path3.join(bundleDirectory, MOCKUP_BUNDLE_FILENAME),
+    bundleDirectory
+  )));
+  return resolveMockupBundle(manifest, "/mockup-bundles/frameup-free/", "built-in");
+}
+function validateSetSemantics(sets, assets, mockupCatalog, issues) {
+  const setIds = /* @__PURE__ */ new Set();
+  const assetIds = new Set(Object.values(assets ?? {}).flat().map((asset) => asset.id));
+  const mockupIds = new Set(mockupCatalog?.mockups.map((mockup) => mockup.id) ?? []);
+  const artworkIds = new Set(BUILT_IN_ARTWORK.map((artwork) => artwork.id));
+  for (const set of sets) {
+    const setPath = `${SETS_DIRECTORY}/${set.id}.json`;
+    if (setIds.has(set.id)) issues.push(issue("error", "set.duplicateId", setPath, `Duplicate set id: ${set.id}`));
+    setIds.add(set.id);
+    try {
+      Intl.getCanonicalLocales(set.locale);
+    } catch {
+      issues.push(issue("warning", "set.locale", setPath, `${set.locale} is not a recognized locale identifier`));
+    }
+    if (!isIsoTimestamp(set.createdAt)) issues.push(issue("warning", "set.createdAt", setPath, "createdAt should be an ISO 8601 timestamp"));
+    if (!isIsoTimestamp(set.updatedAt)) issues.push(issue("warning", "set.updatedAt", setPath, "updatedAt should be an ISO 8601 timestamp"));
+    if (set.areas.length > 10) issues.push(issue("warning", "set.areaCount", setPath, "Apple App Store sets normally contain at most 10 screenshots"));
+    const ids = /* @__PURE__ */ new Set();
+    for (const area of set.areas) {
+      if (ids.has(area.id)) issues.push(issue("error", "set.duplicateObjectId", setPath, `Duplicate area or element id: ${area.id}`));
+      ids.add(area.id);
+      for (const element of area.elements) {
+        if (ids.has(element.id)) issues.push(issue("error", "set.duplicateObjectId", setPath, `Duplicate area or element id: ${element.id}`));
+        ids.add(element.id);
+        if (element.type === "mockup") {
+          if (!assetIds.has(element.assetId)) issues.push(issue("error", "reference.asset", setPath, `Element ${element.id} references missing asset ${element.assetId}`));
+          if (!mockupIds.has(element.mockupId)) issues.push(issue("error", "reference.mockup", setPath, `Element ${element.id} references missing mockup ${element.mockupId}`));
+        } else if (element.type === "image" && element.source.kind === "asset" && !assetIds.has(element.source.assetId)) {
+          issues.push(issue("error", "reference.asset", setPath, `Element ${element.id} references missing asset ${element.source.assetId}`));
+        } else if (element.type === "image" && element.source.kind === "builtin" && !artworkIds.has(element.source.id)) {
+          issues.push(issue("error", "reference.artwork", setPath, `Element ${element.id} references missing built-in artwork ${element.source.id}`));
+        }
+      }
+    }
+  }
+}
+async function checkDirectory(directory, displayPath, issues) {
+  try {
+    const metadata = await lstat2(directory);
+    if (!metadata.isDirectory() || metadata.isSymbolicLink()) throw new Error("must be a regular directory");
+    return true;
+  } catch (error) {
+    issues.push(issue("error", "project.directory", displayPath, messageFor(error)));
+    return false;
+  }
+}
+async function readRegularFile(filename, boundary) {
+  const metadata = await lstat2(filename);
+  if (!metadata.isFile() || metadata.isSymbolicLink()) throw new Error("must be a regular file");
+  const relative = path3.relative(boundary, filename);
+  if (relative.startsWith("..") || path3.isAbsolute(relative)) throw new Error("is outside the project boundary");
+  return readFile3(filename, "utf8");
+}
+function validationResult(directory, issues, sets, config, assets, mockupCatalog) {
+  const errors = issues.filter((entry) => entry.severity === "error");
+  const warnings = issues.filter((entry) => entry.severity === "warning");
+  const allAssets = Object.values(assets ?? {}).flat();
+  return {
+    report: {
+      ok: errors.length === 0,
+      directory,
+      errors,
+      warnings,
+      summary: {
+        assets: allAssets.length,
+        sets: sets.length,
+        screenshots: assets?.screenshots.length ?? 0,
+        areas: sets.reduce((total, set) => total + set.areas.length, 0)
+      }
+    },
+    ...config ? { config } : {},
+    ...assets ? { assets } : {},
+    sets,
+    ...mockupCatalog ? { mockupCatalog } : {}
+  };
+}
+function issue(severity, code, issuePath, message) {
+  return { severity, code, path: issuePath, message };
+}
+function messageFor(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isIsoTimestamp(value) {
+  const date = new Date(value);
+  return !Number.isNaN(date.getTime()) && date.toISOString() === value;
+}
 
 // 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
+var packageRoot = path4.resolve(path4.dirname(sourceFile), "..");
+var isSourceExecution = path4.extname(sourceFile) === ".ts";
+var DEVICE_PRESETS = {
+  iphone: { device: "iPhone", width: 1320, height: 2868 },
+  ipad: { device: "iPad", width: 2064, height: 2752 },
+  watch: { device: "Apple Watch", width: 422, height: 514 },
+  mac: { device: "Mac", width: 2880, height: 1800 }
+};
+function createCli() {
+  const program2 = new Command().name("storeshot").description("Manage app store screenshots locally").version("0.1.0").option("-C, --project <directory>", "project directory", ".").option("--json", "write machine-readable JSON").showSuggestionAfterError().addHelpText("after", `
+Agent workflow:
+  storeshot -C ./screenshots status --json
+  storeshot -C ./screenshots validate --json
+  storeshot -C ./screenshots set show <id>
+  storeshot -C ./screenshots render --set <id> --scale 0.25 --json
+
+Complex canvas edits can be written as complete set JSON documents with
+"set write", or edited directly in sets/ and checked with "validate".`);
+  program2.command("init").description("Initialize a StoreShot project").argument("[directory]", "project directory").option("--app-name <name>", "application name").option("--platform <platform...>", "ios, android, or both").action(async (directory, options) => {
+    const target = path4.resolve(directory ?? projectDirectory(program2));
+    const configPath = path4.join(target, CONFIG_FILENAME);
+    const created = !await fileExists(configPath);
+    const store = new ProjectStore(target);
+    await store.initialize();
+    const current = await store.readConfig();
+    const platforms = options.platform ? parsePlatforms(options.platform) : current.platforms;
+    const config = options.appName || options.platform ? await store.writeConfig({ ...current, appName: options.appName ?? current.appName, platforms }) : current;
+    emit(program2, `Initialized ${store.root}
+Config: ${store.configPath}`, { ok: true, created, directory: store.root, config });
+  });
+  program2.command("status").alias("inspect").description("Summarize the project for a human or agent").action(async () => {
+    const store = await openProject(program2);
+    const project = await store.readProject();
+    const assets = Object.values(project.assets).flat();
+    const value = {
+      ok: true,
+      project: {
+        directory: project.directory,
+        configPath: store.configPath,
+        appName: project.config.appName,
+        platforms: project.config.platforms
+      },
+      summary: {
+        assets: assets.length,
+        screenshots: project.assets.screenshots.length,
+        sets: project.sets.length,
+        areas: project.sets.reduce((total, set) => total + set.areas.length, 0)
+      },
+      sets: project.sets.map((set) => ({
+        id: set.id,
+        name: set.name,
+        locale: set.locale,
+        device: set.device,
+        canvas: set.canvas,
+        areas: set.areas.length,
+        path: path4.join(store.setsPath, `${set.id}.json`)
+      }))
+    };
+    const lines = [
+      `${project.config.appName} \u2014 ${project.directory}`,
+      `${value.summary.sets} sets, ${value.summary.areas} screenshots, ${value.summary.assets} assets`,
+      ...value.sets.map((set) => `  ${set.id}  ${set.locale} \xB7 ${set.device} \xB7 ${set.areas} screenshots`)
+    ];
+    emit(program2, lines.join("\n"), value);
+  });
+  program2.command("validate").description("Validate project files and cross-references").option("--strict", "treat warnings as failures").action(async (options) => {
+    const validation = await validateProject(projectDirectory(program2), packageRoot);
+    const failed = !validation.report.ok || Boolean(options.strict && validation.report.warnings.length > 0);
+    emit(program2, formatValidation(validation.report), { ...validation.report, ok: !failed });
+    if (failed) process.exitCode = 1;
+  });
+  program2.command("render").description("Render screenshot sets to PNG files").option("--set <id>", "render one set (repeatable)", collect, []).option("--area <id-or-number>", "render one area by id, exact name, or 1-based number").option("-o, --output <directory>", "output directory (default: <project>/renders)").option("--scale <scale>", "render scale from 0 to 1", "1").option("--clean", "remove each selected set's existing output directory first").action(async (options) => {
+    const directory = projectDirectory(program2);
+    const validation = await validateProject(directory, packageRoot);
+    if (!validation.report.ok || !validation.assets) {
+      emit(program2, formatValidation(validation.report), { ...validation.report, ok: false });
+      process.exitCode = 1;
+      return;
+    }
+    const selectedSets = options.set.length === 0 ? validation.sets : options.set.map((id) => {
+      const set = validation.sets.find((candidate) => candidate.id === id);
+      if (!set) throw new Error(`Unknown set id: ${id}`);
+      return set;
+    });
+    if (selectedSets.length === 0) throw new Error("The project has no screenshot sets to render");
+    const scale = parseNumber(options.scale, "Scale");
+    const store = await openProject(program2);
+    const { renderScreenshotSets } = await import("./node-renderer-FMVPIQAG.js");
+    const result = await renderScreenshotSets({
+      clean: Boolean(options.clean),
+      outputDirectory: path4.resolve(options.output ?? path4.join(directory, "renders")),
+      packageRoot,
+      scale,
+      sets: selectedSets,
+      store,
+      ...options.area ? { area: options.area } : {}
+    });
+    emit(
+      program2,
+      [`Rendered ${result.files.length} PNG file${result.files.length === 1 ? "" : "s"} to ${result.outputDirectory}`, ...result.files.map((file) => `  ${file.path}`)].join("\n"),
+      { ok: true, render: result, warnings: validation.report.warnings }
+    );
+  });
+  configureConfigCommands(program2);
+  configureSetCommands(program2);
+  configureAssetCommands(program2);
+  configureDevCommand(program2);
+  return program2;
+}
+function configureConfigCommands(program2) {
+  const config = program2.command("config").description("Inspect or update storeshot.json");
+  config.command("get").description("Print the project configuration").action(async () => {
+    const store = await openProject(program2);
+    const value = await store.readConfig();
+    emitDocument(program2, value, { ok: true, config: value });
+  });
+  config.command("set").description("Update project configuration").option("--app-name <name>", "application name").option("--platform <platform...>", "ios, android, or both").action(async (options) => {
+    if (!options.appName && !options.platform) throw new Error("Provide --app-name or --platform");
+    const store = await openProject(program2);
+    const current = await store.readConfig();
+    const value = await store.writeConfig({
+      ...current,
+      appName: options.appName ?? current.appName,
+      platforms: options.platform ? parsePlatforms(options.platform) : current.platforms
+    });
+    emit(program2, `Updated ${store.configPath}`, { ok: true, config: value });
+  });
+}
+function configureSetCommands(program2) {
+  const set = program2.command("set").alias("sets").description("Create, inspect, edit, duplicate, or delete screenshot sets");
+  set.command("list").description("List screenshot sets").action(async () => {
+    const store = await openProject(program2);
+    const sets = await store.listSets();
+    emit(
+      program2,
+      sets.length === 0 ? "No screenshot sets" : sets.map((value) => `${value.id}	${value.locale}	${value.device}	${value.name}`).join("\n"),
+      { ok: true, sets }
+    );
+  });
+  set.command("show").description("Print one complete set document").argument("<id>", "set id").action(async (id) => {
+    const store = await openProject(program2);
+    const value = await store.readSet(id);
+    emitDocument(program2, value, { ok: true, set: value, path: path4.join(store.setsPath, `${id}.json`) });
   });
-  const url = `http://${options.host}:${port}`;
-  console.log(`
-  StoreShot is ready at ${url}`);
-  console.log(`  Project: ${service.store.root}
+  set.command("create").description("Create a screenshot set").requiredOption("--name <name>", "set name").requiredOption("--locale <locale>", "locale identifier").addOption(new Option("--preset <preset>", "iphone, ipad, watch, or mac").choices(Object.keys(DEVICE_PRESETS)).default("iphone")).option("--device <name>", "device label").option("--width <pixels>", "custom canvas width").option("--height <pixels>", "custom canvas height").action(async (options) => {
+    if (options.width && !options.height || !options.width && options.height) throw new Error("Provide both --width and --height");
+    const preset = DEVICE_PRESETS[options.preset];
+    const store = await openProject(program2);
+    const value = await store.createSet({
+      name: options.name,
+      locale: options.locale,
+      device: options.device ?? preset.device,
+      width: options.width ? parseInteger(options.width, "Canvas width") : preset.width,
+      height: options.height ? parseInteger(options.height, "Canvas height") : preset.height
+    });
+    emit(program2, `Created ${value.id} at ${path4.join(store.setsPath, `${value.id}.json`)}`, { ok: true, set: value });
+  });
+  set.command("update").description("Update common set metadata").argument("<id>", "set id").option("--name <name>", "set name").option("--locale <locale>", "locale identifier").option("--device <name>", "device label").action(async (id, options) => {
+    if (!options.name && !options.locale && !options.device) throw new Error("Provide --name, --locale, or --device");
+    const store = await openProject(program2);
+    const current = await store.readSet(id);
+    const value = await store.updateSetMetadata(id, {
+      name: options.name ?? current.name,
+      locale: options.locale ?? current.locale,
+      device: options.device ?? current.device
+    });
+    emit(program2, `Updated ${id}`, { ok: true, set: value });
+  });
+  set.command("write").description("Replace a complete set document with schema-validated JSON").argument("<id>", "set id").requiredOption("--file <file>", "JSON file, or - for stdin").action(async (id, options) => {
+    const input = options.file === "-" ? await readStandardInput() : await readFile4(path4.resolve(options.file), "utf8");
+    let document;
+    try {
+      document = JSON.parse(input);
+    } catch {
+      throw new Error("Set input must be valid JSON");
+    }
+    const value = parseScreenshotSet(document);
+    if (value.id !== id) throw new Error(`Set input id ${value.id} does not match ${id}`);
+    const store = await openProject(program2);
+    const saved = await store.writeSet(id, value);
+    emit(program2, `Wrote ${path4.join(store.setsPath, `${id}.json`)}`, { ok: true, set: saved });
+  });
+  set.command("duplicate").description("Duplicate a set with fresh object ids").argument("<id>", "set id").action(async (id) => {
+    const store = await openProject(program2);
+    const value = await store.duplicateSet(id);
+    emit(program2, `Created duplicate ${value.id}`, { ok: true, set: value });
+  });
+  set.command("delete").description("Delete a screenshot set").argument("<id>", "set id").requiredOption("--yes", "confirm deletion").action(async (id) => {
+    const store = await openProject(program2);
+    await store.deleteSet(id);
+    emit(program2, `Deleted ${id}`, { ok: true, deleted: id });
+  });
+}
+function configureAssetCommands(program2) {
+  const asset = program2.command("asset").alias("assets").description("List, add, classify, or remove project assets");
+  asset.command("list").description("List project assets").addOption(new Option("--category <category>", "filter by category").choices([...ASSET_CATEGORIES])).action(async (options) => {
+    const store = await openProject(program2);
+    const catalog = await store.listAssets();
+    const assets = options.category ? catalog[options.category] : Object.values(catalog).flat();
+    emit(
+      program2,
+      assets.length === 0 ? "No assets" : assets.map((value) => `${value.id}	${value.width ?? "?"}x${value.height ?? "?"}	${value.size} bytes`).join("\n"),
+      { ok: true, assets }
+    );
+  });
+  asset.command("add").description("Copy image files into the project asset catalog").argument("<files...>", "image files").addOption(new Option("--category <category>", "asset category").choices([...ASSET_CATEGORIES]).default("screenshots")).option("--replace", "allow replacement of an existing same-name asset").action(async (files, options) => {
+    const store = await openProject(program2);
+    const added = [];
+    for (const source of files) {
+      const filename = path4.basename(source);
+      const target = store.resolveAsset(options.category, filename);
+      if (!options.replace && await fileExists(target)) throw new Error(`${options.category}/${filename} already exists; pass --replace to overwrite it`);
+      const result = await store.addAsset(options.category, filename, await readFile4(path4.resolve(source)));
+      added.push({ id: `${options.category}/${filename}`, replaced: result.replaced });
+    }
+    emit(program2, added.map((entry) => `${entry.replaced ? "Replaced" : "Added"} ${entry.id}`).join("\n"), { ok: true, assets: added });
+  });
+  asset.command("set-device").description("Override or clear raw screenshot device classification").argument("<id>", "asset id such as screenshots/home.png").argument("<device>", "iphone, ipad, mac, watch, or auto").action(async (id, device) => {
+    if (device !== "auto" && !SCREENSHOT_DEVICE_TYPES.includes(device)) throw new Error("Device must be iphone, ipad, mac, watch, or auto");
+    const { category, filename } = parseAssetId(id);
+    const store = await openProject(program2);
+    await store.updateAssetMetadata(category, filename, { deviceType: device === "auto" ? null : device });
+    emit(program2, `Updated ${id}`, { ok: true, assetId: id, deviceType: device === "auto" ? null : device });
+  });
+  asset.command("remove").description("Delete assets that are not referenced by screenshot sets").argument("<ids...>", "asset ids").requiredOption("--yes", "confirm deletion").option("--force", "delete even when a set references the asset").action(async (ids, options) => {
+    const store = await openProject(program2);
+    const sets = await store.listSets();
+    for (const id of ids) {
+      const references = assetReferences(id, sets);
+      if (references.length > 0 && !options.force) throw new Error(`${id} is referenced by ${references.join(", ")}; pass --force to delete it anyway`);
+    }
+    for (const id of ids) {
+      const { category, filename } = parseAssetId(id);
+      await store.deleteAsset(category, filename);
+    }
+    emit(program2, ids.map((id) => `Deleted ${id}`).join("\n"), { ok: true, deleted: ids });
+  });
+}
+function configureDevCommand(program2) {
+  program2.command("dev").description("Open a live 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 = parseInteger(options.port, "Port");
+    if (port > 65535) throw new Error("Port must be an integer between 1 and 65535");
+    const projectDirectory2 = path4.resolve(directory ?? globalOptions(program2).project);
+    const service = await startServer({ host: options.host, port, packageRoot, projectDirectory: projectDirectory2, useVite: isSourceExecution });
+    const url = `http://${options.host}:${service.port}`;
+    if (globalOptions(program2).json) console.log(JSON.stringify({ ok: true, url, directory: service.store.root }));
+    else console.log(`
+  StoreShot is ready at ${url}
+  Project: ${service.store.root}
+  Filesystem changes refresh the preview automatically.
 `);
-  if (options.open) await open(url);
-  const shutdown = async () => {
-    await service.close();
-    process.exit(0);
-  };
-  process.once("SIGINT", shutdown);
-  process.once("SIGTERM", shutdown);
-});
+    if (options.open) await open(url);
+    const shutdown = async () => {
+      await service.close();
+      process.exit(0);
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+  });
+}
+async function openProject(program2) {
+  const store = new ProjectStore(projectDirectory(program2));
+  try {
+    await access2(store.configPath, constants2.R_OK);
+  } catch {
+    throw new Error(`No StoreShot project found at ${store.root}; run storeshot init first`);
+  }
+  await store.readConfig();
+  return store;
+}
+function globalOptions(program2) {
+  return program2.opts();
+}
+function projectDirectory(program2) {
+  return path4.resolve(globalOptions(program2).project);
+}
+function emit(program2, human, json) {
+  console.log(globalOptions(program2).json ? JSON.stringify(json, null, 2) : human);
+}
+function emitDocument(program2, document, json) {
+  console.log(JSON.stringify(globalOptions(program2).json ? json : document, null, 2));
+}
+function formatValidation(report) {
+  const lines = [
+    report.ok ? `Valid StoreShot project: ${report.directory}` : `Invalid StoreShot project: ${report.directory}`,
+    `${report.summary.sets} sets, ${report.summary.areas} screenshots, ${report.summary.assets} assets`
+  ];
+  for (const entry of [...report.errors, ...report.warnings]) {
+    lines.push(`${entry.severity === "error" ? "error" : "warning"} [${entry.code}] ${entry.path}: ${entry.message}`);
+  }
+  return lines.join("\n");
+}
+function parsePlatforms(values) {
+  const platforms = [...new Set(values.flatMap((value) => value.split(",")).map((value) => value.trim().toLowerCase()))];
+  if (platforms.length === 0 || platforms.some((value) => value !== "ios" && value !== "android")) {
+    throw new Error("Platforms must be ios, android, or both");
+  }
+  return platforms;
+}
+function parseInteger(value, name) {
+  const result = Number(value);
+  if (!Number.isInteger(result) || result <= 0) throw new Error(`${name} must be a positive integer`);
+  return result;
+}
+function parseNumber(value, name) {
+  const result = Number(value);
+  if (!Number.isFinite(result)) throw new Error(`${name} must be a number`);
+  return result;
+}
+function parseAssetId(id) {
+  const separator = id.indexOf("/");
+  const category = id.slice(0, separator);
+  const filename = id.slice(separator + 1);
+  if (separator < 1 || !ASSET_CATEGORIES.includes(category) || !filename || filename.includes("/")) throw new Error(`Invalid asset id: ${id}`);
+  return { category, filename };
+}
+function assetReferences(assetId, sets) {
+  return sets.flatMap((set) => set.areas.some((area) => area.elements.some(
+    (element) => element.type === "mockup" && element.assetId === assetId || element.type === "image" && element.source.kind === "asset" && element.source.assetId === assetId
+  )) ? [set.id] : []);
+}
+async function readStandardInput() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function fileExists(filename) {
+  return access2(filename, constants2.F_OK).then(() => true).catch(() => false);
+}
+function collect(value, previous) {
+  return [...previous, value];
+}
+var program = createCli();
 program.parseAsync().catch((error) => {
   const message = error instanceof Error ? error.message : String(error);
-  console.error(`storeshot: ${message}`);
+  if (globalOptions(program).json) console.error(JSON.stringify({ ok: false, error: { message } }, null, 2));
+  else console.error(`storeshot: ${message}`);
   process.exitCode = 1;
 });
+export {
+  createCli
+};
 //# sourceMappingURL=cli.js.map