@hitslop/cli 0.1.4 → 0.2.0

package/dist/cli.js

@@ -1,59 +1,69 @@
 #!/usr/bin/env bun
 // @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
-// src/cli.ts
-import { Crust } from "@crustjs/core";
-import { join as join9 } from "path";
-import { stat as stat7 } from "fs/promises";
-import { createInterface } from "readline/promises";
-import { SlopCategorySchema } from "@hitslop/schema";
-
-// src/project.ts
-import { cp, lstat as lstat2, mkdir as mkdir2, readFile as readFile3, readdir as readdir2, rm, stat as stat3, writeFile as writeFile2 } from "fs/promises";
-import { basename, dirname as dirname2, join as join3, relative, resolve, sep } from "path";
-import { fileURLToPath, pathToFileURL } from "url";
-import { createHash } from "crypto";
-import { zipSync } from "fflate";
-import { decode as decodePng } from "fast-png";
-import { build as viteBuild } from "vite";
-import * as z from "zod";
-import { manifestSchemaURL, parseManifest } from "@hitslop/schema";
 // package.json
-var package_default = {
-  name: "@hitslop/cli",
-  version: "0.1.4",
-  description: "Create, develop, build, register, and publish hitSlop apps.",
-  license: "MIT",
-  repository: { type: "git", url: "git+https://github.com/hitslop/hitslop.git", directory: "packages/cli" },
-  homepage: "https://hitslop.com",
-  bugs: { url: "https://github.com/hitslop/hitslop/issues" },
-  keywords: ["hitslop", "cli", "local-first", "mini-apps"],
-  publishConfig: { access: "public" },
-  type: "module",
-  bin: {
-    slop: "dist/cli.js"
-  },
-  files: ["dist", "templates"],
-  scripts: {
-    build: "bun ../../scripts/clean-dist.ts && bun build src/cli.ts --target bun --format esm --packages external --outfile dist/cli.js && /bin/chmod +x dist/cli.js",
-    check: "tsc -p tsconfig.json",
-    test: "bun run --cwd ../schema build && bun test"
-  },
-  dependencies: {
-    "@crustjs/core": "^0.0.19",
-    "@hitslop/schema": "^0.1.3",
-    "@noble/ed25519": "^3.2.0",
-    "fast-png": "^8.0.0",
-    fflate: "^0.8.3",
-    postcss: "^8.5.6",
-    vite: "^8.2.2",
-    zod: "^4.5.2"
-  },
-  devDependencies: {
-    "@types/bun": "latest",
-    typescript: "^7.0.2"
-  }
-};
+var package_default;
+var init_package = __esm(() => {
+  package_default = {
+    name: "@hitslop/cli",
+    version: "0.2.0",
+    description: "Create, develop, build, register, and publish hitSlop apps.",
+    license: "MIT",
+    repository: {
+      type: "git",
+      url: "git+https://github.com/hitslop/hitslop.git",
+      directory: "packages/cli"
+    },
+    homepage: "https://hitslop.com",
+    bugs: {
+      url: "https://github.com/hitslop/hitslop/issues"
+    },
+    keywords: ["hitslop", "cli", "local-first", "mini-apps"],
+    publishConfig: {
+      access: "public"
+    },
+    type: "module",
+    bin: {
+      slop: "dist/cli.js"
+    },
+    files: ["dist", "templates"],
+    scripts: {
+      build: "bun ../../scripts/clean-dist.ts && bun build src/cli.ts src/module-loader.ts --target bun --format esm --packages external --outdir dist && /bin/chmod +x dist/cli.js",
+      check: "tsc -p tsconfig.json",
+      test: "bun run --cwd ../schema build && bun test"
+    },
+    dependencies: {
+      "@crustjs/core": "^0.0.19",
+      "@hitslop/schema": "^0.2.0",
+      "@noble/ed25519": "^3.2.0",
+      "fast-png": "^8.0.0",
+      fflate: "^0.8.3",
+      parse5: "^8.0.1",
+      postcss: "^8.5.6",
+      vite: "^8.2.2"
+    },
+    devDependencies: {
+      "@types/bun": "latest",
+      typebox: "^1.3.26",
+      typescript: "^7.0.2"
+    }
+  };
+});
 
 // src/document-skill.ts
 import { lstat, mkdir, readFile, readdir, stat, writeFile } from "fs/promises";
@@ -63,11 +73,8 @@ import {
   documentGuideSource,
   documentSkillContent,
   documentSkillPath,
-  isCanonicalDocumentSkill,
   maxDocumentGuideBytes
 } from "@hitslop/schema";
-var decoder = new TextDecoder("utf-8", { fatal: true });
-var exists = async (path) => stat(path).then(() => true).catch(() => false);
 async function emitDocumentSkill(sourceRoot, outputRoot) {
   const skill = join(outputRoot, documentSkillPath);
   await mkdir(dirname(skill), { recursive: true });
@@ -99,7 +106,7 @@ async function readDocumentGuideSource(sourceRoot) {
 async function validateDocumentSkill(root) {
   const agents = join(root, ".agents");
   if (!await exists(agents)) {
-    throw new Error(`Runtime package is missing ${documentSkillPath}.`);
+    return;
   }
   await requireDirectory(agents, ".agents");
   await requireOnly(agents, new Set(["skills"]), ".agents");
@@ -115,14 +122,11 @@ async function validateDocumentSkill(root) {
   });
   if (!skillInfo?.isFile() || skillInfo.isSymbolicLink())
     throw new Error(`${documentSkillPath} must be a regular file.`);
-  let canonical = false;
   try {
-    canonical = isCanonicalDocumentSkill(await readFile(skillPath));
+    decoder.decode(await readFile(skillPath));
   } catch {
     throw new Error(`${documentSkillPath} must be UTF-8.`);
   }
-  if (!canonical)
-    throw new Error(`${documentSkillPath} is not a recognized canonical hitSlop document skill.`);
   const references = join(folder, "references");
   if (!await exists(references))
     return;
@@ -157,13 +161,60 @@ async function requireOnly(directory, allowed, label, optionalReferences = false
     }
   }
 }
+var decoder, exists = async (path) => stat(path).then(() => true).catch(() => false);
+var init_document_skill = __esm(() => {
+  decoder = new TextDecoder("utf-8", { fatal: true });
+});
+
+// src/evaluate-module.ts
+import { fileURLToPath } from "url";
+import { dirname as dirname2, resolve } from "path";
+async function evaluateModule(path, kind, timeoutMs = 1e4) {
+  const absolute = resolve(path);
+  const loader = Bun.resolveSync("./module-loader", dirname2(fileURLToPath(import.meta.url)));
+  let receive;
+  const result = new Promise((resolve2) => {
+    receive = resolve2;
+  });
+  const child = Bun.spawn([process.execPath, loader, absolute, kind], {
+    stdin: "ignore",
+    stdout: process.stderr.fd,
+    stderr: process.stderr.fd,
+    ipc: (message) => receive(message)
+  });
+  let timer;
+  try {
+    const message = await Promise.race([
+      result,
+      child.exited.then((code) => {
+        throw new Error(`Loader exited without a result (status ${code})`);
+      }),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`${kind} evaluation timed out after ${timeoutMs}ms`)), timeoutMs);
+      })
+    ]);
+    if (!message || typeof message !== "object" || !("ok" in message))
+      throw new Error("Invalid loader response");
+    if (message.ok === false && "error" in message && typeof message.error === "string")
+      throw new Error(message.error);
+    if (message.ok !== true || !("value" in message))
+      throw new Error("Invalid loader response");
+    return message.value;
+  } catch (error) {
+    throw new Error(`Could not evaluate ${kind}.ts (${absolute}): ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  } finally {
+    clearTimeout(timer);
+    child.disconnect();
+    child.kill("SIGKILL");
+    await child.exited;
+  }
+}
+var init_evaluate_module = () => {};
 
 // src/theme.ts
 import { readFile as readFile2, stat as stat2 } from "fs/promises";
 import { join as join2 } from "path";
 import postcss from "postcss";
-var exists2 = async (path) => stat2(path).then(() => true).catch(() => false);
-var decoder2 = new TextDecoder("utf-8", { fatal: true });
 async function readUTF8(path, label) {
   try {
     return decoder2.decode(await readFile2(path));
@@ -172,13 +223,31 @@ async function readUTF8(path, label) {
   }
 }
 async function readThemeContract(root) {
+  const source = await readThemeCSS(root);
+  return themeContract(source);
+}
+function themeContract(source) {
+  if (source === undefined)
+    return;
+  const contract = parseTheme(source, "theme defaults");
+  validateThemeReferences(source, contract, "theme defaults");
+  return contract;
+}
+async function readThemeCSS(root) {
+  const definition = join2(root, "theme.ts");
   const path = join2(root, "assets", "theme.css");
+  if (await exists2(definition)) {
+    if (await exists2(path))
+      throw new Error("Define theme defaults in theme.ts or assets/theme.css, not both.");
+    const css = await evaluateModule(definition, "theme");
+    if (typeof css !== "string")
+      throw new Error("theme.ts must default-export defineTheme(...)");
+    parseTheme(css, "theme.ts");
+    return css;
+  }
   if (!await exists2(path))
     return;
-  const source = await readUTF8(path, "assets/theme.css");
-  const contract = parseTheme(source, "assets/theme.css");
-  validateThemeReferences(source, contract, "assets/theme.css");
-  return contract;
+  return readUTF8(path, "assets/theme.css");
 }
 async function validateThemeOverride(root, contract) {
   const path = join2(root, "stores", "theme.css");
@@ -232,109 +301,422 @@ function parseTheme(source, label) {
     throw new Error(`${label} must define at least one --slop-* custom property.`);
   return properties;
 }
+var exists2 = async (path) => stat2(path).then(() => true).catch(() => false), decoder2;
+var init_theme = __esm(() => {
+  init_evaluate_module();
+  decoder2 = new TextDecoder("utf-8", { fatal: true });
+});
 
 // src/vite-build-plugin.ts
-import { version as viteVersion } from "vite";
-var escapePattern = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-function inlineScript(html, fileName, code) {
-  const name = escapePattern(fileName);
-  const tag = new RegExp(`<script([^>]*?)\\ssrc=["'](?:[^"']*\\/)?${name}["']([^>]*)>\\s*</script>`, "g");
-  const safeCode = code.replace(/"?__VITE_PRELOAD__"?/g, "void 0").replace(/<(\/script>|!--)/g, "\\x3C$1");
-  return html.replace(tag, (_match, before, after) => `<script${before}${after}>${safeCode.trim()}</script>`);
+import { parse } from "parse5";
+function elements(html) {
+  const result = [];
+  const visit = (node) => {
+    if ("tagName" in node)
+      result.push(node);
+    if ("childNodes" in node)
+      node.childNodes.forEach(visit);
+  };
+  visit(parse(html, { sourceCodeLocationInfo: true }));
+  return result;
+}
+function replaceElements(html, replace) {
+  for (const element of elements(html).reverse()) {
+    const replacement = replace(element);
+    const location = element.sourceCodeLocation;
+    if (replacement !== undefined && location)
+      html = html.slice(0, location.startOffset) + replacement + html.slice(location.endOffset);
+  }
+  return html;
 }
 function inlineStyle(html, fileName, css) {
-  const name = escapePattern(fileName);
-  const tag = new RegExp(`<link([^>]*?)\\shref=["'](?:[^"']*\\/)?${name}["']([^>]*)>`, "g");
-  return html.replace(tag, (_match, before, after) => `<style${before}${after}>${css.replace('@charset "UTF-8";', "").trim()}</style>`);
-}
-var addThemeLinks = (html) => {
-  if (html.includes("data-hitslop-theme-default"))
-    return html;
-  const links = '<link rel="stylesheet" href="assets/theme.css" data-hitslop-theme-default><link rel="stylesheet" href="theme.css" data-hitslop-theme>';
-  return /<\/head>/i.test(html) ? html.replace(/<\/head>/i, `${links}</head>`) : links + html;
-};
+  return replaceElements(html, (node) => {
+    if (node.tagName !== "link" || !matches(attribute(node, "href"), fileName))
+      return;
+    const media = attribute(node, "media");
+    const attributes = media ? ' media="' + media.replaceAll("&", "&amp;").replaceAll('"', "&quot;") + '"' : "";
+    return "<style" + attributes + ">" + css.replace(/@charset\s+"UTF-8";/i, "").replace(/<\/style/gi, "<\\/style").trim() + "</style>";
+  });
+}
 function hitSlopBuildPlugin(options) {
-  const configure = (config) => {
-    config.base = "./";
-    config.build ??= {};
-    config.build.assetsInlineLimit = () => true;
-    config.build.chunkSizeWarningLimit = 1e8;
-    config.build.cssCodeSplit = false;
-    config.build.assetsDir = "";
-    config.build.rollupOptions ??= {};
-    config.build.rollupOptions.output ??= {};
-    const outputs = Array.isArray(config.build.rollupOptions.output) ? config.build.rollupOptions.output : [config.build.rollupOptions.output];
-    for (const output of outputs) {
-      if (Number.parseInt(viteVersion.split(".")[0] ?? "0", 10) >= 8) {
-        output.codeSplitting = false;
-      } else
-        output.inlineDynamicImports = true;
-    }
-  };
   return {
     name: "hitslop:build",
     enforce: "post",
-    config: configure,
+    config: () => ({ base: "./", build: { cssCodeSplit: false, assetsDir: "assets", sourcemap: false, assetsInlineLimit: 4096 } }),
     generateBundle(_output, bundle) {
-      const htmlAssets = Object.values(bundle).filter((item) => item.type === "asset" && item.fileName.endsWith(".html"));
-      const scripts = Object.values(bundle).filter((item) => item.type === "chunk" && /\.[mc]?js$/.test(item.fileName));
-      const styles = Object.values(bundle).filter((item) => item.type === "asset" && item.fileName.endsWith(".css"));
-      const consumed = new Set;
-      for (const asset of htmlAssets) {
-        let html = typeof asset.source === "string" ? asset.source : new TextDecoder().decode(asset.source);
-        for (const script of scripts) {
-          html = inlineScript(html, script.fileName, script.code);
-          consumed.add(script.fileName);
+      for (const asset of Object.values(bundle)) {
+        if (asset.type !== "asset" || !asset.fileName.endsWith(".html"))
+          continue;
+        let html = String(asset.source);
+        for (const style of Object.values(bundle)) {
+          if (style.type !== "asset" || !style.fileName.endsWith(".css"))
+            continue;
+          const directory = style.fileName.slice(0, style.fileName.lastIndexOf("/") + 1);
+          const css = String(style.source).replace(/url\((['"]?)(\.\/)?([^)'"\s]+)\1\)/g, (match, quote, _dot, url) => /^(?:[a-z]+:|\/|#)/i.test(url) ? match : "url(" + quote + directory + url + quote + ")");
+          const updated = inlineStyle(html, style.fileName, css);
+          if (updated !== html) {
+            html = updated;
+            delete bundle[style.fileName];
+          }
         }
-        for (const style of styles) {
-          const css = typeof style.source === "string" ? style.source : new TextDecoder().decode(style.source);
-          html = inlineStyle(html, style.fileName, css);
-          consumed.add(style.fileName);
+        if (options.hasTheme) {
+          const head = elements(html).find((node) => node.tagName === "head");
+          const offset = head?.sourceCodeLocation?.endTag?.startOffset ?? 0;
+          const links = '<link rel="stylesheet" href="assets/theme.css" data-hitslop-theme-default><link rel="stylesheet" href="theme.css" data-hitslop-theme>';
+          html = html.slice(0, offset) + links + html.slice(offset);
         }
-        if (options.hasTheme)
-          html = addThemeLinks(html);
         asset.source = html;
       }
-      for (const fileName of consumed)
-        delete bundle[fileName];
     }
   };
 }
+var attribute = (node, name) => node.attrs.find((attr) => attr.name === name)?.value, matches = (value, file) => value?.replace(/^\.\//, "") === file;
+var init_vite_build_plugin = () => {};
 
-// src/project.ts
-var manifestPath = (root) => join3(root, "manifest.json");
-async function loadManifest(root) {
-  const manifest = parseManifest(JSON.parse(await readFile3(manifestPath(root), "utf8")));
-  await validateSkin(root, manifest);
+// src/data-schema.ts
+import { dataSchemaFromJSON } from "@hitslop/schema";
+async function loadDataSchema(path, timeoutMs = 1e4) {
+  return dataSchemaFromJSON(await evaluateModule(path, "schema", timeoutMs));
+}
+var init_data_schema = __esm(() => {
+  init_evaluate_module();
+});
+
+// src/static-preview.ts
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { checkPngDimensions } from "@hitslop/schema";
+import { decode as decodePng, encode as encodePng } from "fast-png";
+function validateStaticPng(bytes, label) {
+  if (bytes.byteLength === 0)
+    throw new Error(`${label} is empty.`);
+  if (bytes.byteLength > MAX_PREVIEW_BYTES)
+    throw new Error(`${label} cannot exceed 5 MiB.`);
+  checkPngDimensions(bytes, label);
+  try {
+    return decodePng(bytes, { checkCrc: true });
+  } catch {
+    throw new Error(`${label} must be a valid PNG image.`);
+  }
+}
+function validateIconPng(bytes, label = "The template icon") {
+  checkPngDimensions(bytes, label, { width: ICON_SIZE, height: ICON_SIZE });
+  return validateStaticPng(bytes, label);
+}
+function iconFromPng(bytes, size = ICON_SIZE) {
+  const image = validateStaticPng(bytes, "The template preview");
+  const scale = size / Math.max(image.width, image.height);
+  const width = Math.max(1, Math.round(image.width * scale));
+  const height = Math.max(1, Math.round(image.height * scale));
+  const output = image.depth === 16 ? new Uint16Array(size * size * 4) : new Uint8Array(size * size * 4);
+  const alpha = image.depth === 16 ? 65535 : 255;
+  const offsetX = Math.floor((size - width) / 2);
+  const offsetY = Math.floor((size - height) / 2);
+  const samples = (position, sourceSize, targetSize) => {
+    const ratio = sourceSize / targetSize;
+    if (ratio < 1) {
+      const center = (position + 0.5) * ratio - 0.5;
+      const lower = Math.floor(center), fraction = center - lower;
+      return [[Math.max(0, Math.min(sourceSize - 1, lower)), 1 - fraction], [Math.max(0, Math.min(sourceSize - 1, lower + 1)), fraction]];
+    }
+    const start = position * ratio, end = (position + 1) * ratio;
+    const result = [];
+    for (let index = Math.floor(start);index < Math.ceil(end); index++) {
+      result.push([Math.min(sourceSize - 1, index), Math.max(0, Math.min(end, index + 1) - Math.max(start, index)) / ratio]);
+    }
+    return result;
+  };
+  const columns = Array.from({ length: width }, (_, x) => samples(x, image.width, width));
+  for (let y = 0;y < height; y += 1) {
+    const rows = samples(y, image.height, height);
+    for (let x = 0;x < width; x += 1) {
+      let red = 0, green = 0, blue = 0, opacity = 0;
+      for (const [sy, wy] of rows)
+        for (const [sx, wx] of columns[x]) {
+          const offset = (sy * image.width + sx) * image.channels;
+          const a = (image.channels === 2 || image.channels === 4 ? image.data[offset + image.channels - 1] : alpha) / alpha;
+          const weight = wx * wy * a;
+          const gray = image.channels <= 2;
+          red += image.data[offset] * weight;
+          green += image.data[offset + (gray ? 0 : 1)] * weight;
+          blue += image.data[offset + (gray ? 0 : 2)] * weight;
+          opacity += weight;
+        }
+      const destination = ((offsetY + y) * size + offsetX + x) * 4;
+      output[destination] = Math.round(opacity ? red / opacity : 0);
+      output[destination + 1] = Math.round(opacity ? green / opacity : 0);
+      output[destination + 2] = Math.round(opacity ? blue / opacity : 0);
+      output[destination + 3] = Math.round(opacity * alpha);
+    }
+  }
+  return encodePng({ width: size, height: size, data: output, depth: image.depth, channels: 4 });
+}
+async function writeDefaultIcon(previewPath, iconPath) {
+  await writeFile2(iconPath, iconFromPng(await readFile3(previewPath)));
+}
+var MAX_PREVIEW_BYTES, ICON_SIZE = 512;
+var init_static_preview = __esm(() => {
+  MAX_PREVIEW_BYTES = 5 * 1024 * 1024;
+});
+
+// src/runtime-package.ts
+var exports_runtime_package = {};
+__export(exports_runtime_package, {
+  validateRuntimePackage: () => validateRuntimePackage
+});
+import { Database } from "bun:sqlite";
+import { forbiddenPackageNames, validateTemplatePath } from "@hitslop/schema";
+import { lstat as lstat2, readFile as readFile4, readdir as readdir2, stat as stat3 } from "fs/promises";
+import { basename, join as join3, relative, sep } from "path";
+import { unzipSync } from "fflate";
+import { decode as decodePng2 } from "fast-png";
+import { compileDataSchema } from "@hitslop/schema";
+async function validateRuntimePackage(root, options = {}) {
+  if (basename(root).startsWith("."))
+    throw new Error("Runtime package path is not valid.");
+  const rootInfo = await lstat2(root).catch(() => {
+    return;
+  });
+  if (!rootInfo?.isDirectory() || rootInfo.isSymbolicLink())
+    throw new Error("A runtime .slop must be a directory, not a symlink.");
+  const manifest = await loadManifest(root);
+  await requireUTF8File(join3(root, "app.html"), "app.html");
+  await rejectSymlinks(root);
+  const allowed = new Set(["manifest.json", "app.html", "data.schema.json", "assets", "stores", "QuickLook", ".agents", "Icon\r"]);
+  for (const entry of await readdir2(root))
+    if (!allowed.has(entry))
+      throw new Error(`Runtime packages cannot contain ${entry}.`);
+  for (const path of await walk(root)) {
+    if (forbiddenPackageNames.has(basename(path).toLowerCase()))
+      throw new Error(`Runtime packages cannot contain ${relative(root, path)}.`);
+    if (options.template)
+      validateTemplatePath(relative(root, path).split(sep).join("/"));
+  }
+  if (options.template && await exists3(join3(root, "stores")))
+    throw new Error("Template packages cannot contain stores.");
+  if (options.template && await exists3(join3(root, "Icon\r")))
+    throw new Error("Template packages cannot contain Finder metadata Icon\\r.");
+  const schema = await readDataSchema(root);
+  const contract = await readThemeContract(root);
+  const appHTML = await readFile4(join3(root, "app.html"), "utf8");
+  validateThemeReferences(appHTML, contract, "app.html");
+  await validateStores(root, schema, contract);
+  await validateQuickLook(root, options.requirePreview ?? false);
+  await validateDocumentSkill(root);
   return manifest;
 }
-var exists3 = async (path) => {
+async function readDataSchema(root) {
+  const current = join3(root, "data.schema.json");
+  if (!await exists3(current))
+    return;
+  await requireUTF8File(current, "data.schema.json");
+  try {
+    const value = JSON.parse(await readFile4(current, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      throw new Error("schema root must be an object");
+    compileDataSchema(value);
+    return value;
+  } catch (error) {
+    throw new Error(`data.schema.json must contain valid JSON Schema: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function validateStores(root, schema, contract) {
+  const stores = join3(root, "stores");
+  if (!await exists3(stores))
+    return;
+  const info = await lstat2(stores);
+  if (!info.isDirectory() || info.isSymbolicLink())
+    throw new Error("stores must be a directory.");
+  const allowed = new Set(["data.json", "data.sqlite", "data.sqlite-wal", "data.sqlite-shm", "media", "theme.css"]);
+  for (const entry of await readdir2(stores, { withFileTypes: true })) {
+    if (!allowed.has(entry.name))
+      throw new Error(`Unexpected store entry stores/${entry.name}.`);
+    if (entry.name === "media" ? !entry.isDirectory() : !entry.isFile())
+      throw new Error(`Invalid store entry stores/${entry.name}.`);
+  }
+  const json = join3(stores, "data.json");
+  if (await exists3(json)) {
+    let value;
+    try {
+      value = JSON.parse(decoder3.decode(await readFile4(json)));
+    } catch (error) {
+      throw new Error(`stores/data.json must be valid UTF-8 JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (schema) {
+      let validator;
+      try {
+        validator = compileDataSchema(schema);
+      } catch (error) {
+        throw new Error(`The data schema is not supported: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      validator(value);
+    }
+  }
+  const sqlite = join3(stores, "data.sqlite");
+  for (const sidecar of ["data.sqlite-wal", "data.sqlite-shm"]) {
+    if (await exists3(join3(stores, sidecar)) && !await exists3(sqlite))
+      throw new Error(`stores/${sidecar} requires stores/data.sqlite.`);
+  }
+  if (await exists3(sqlite))
+    validateSQLite(sqlite);
+  const media = join3(stores, "media");
+  if (await exists3(media))
+    await validateMedia(media);
+  await validateThemeOverride(root, contract);
+}
+function validateSQLite(path) {
+  let database;
+  try {
+    database = new Database(path, { readonly: true, strict: true });
+    const rows = database.query("PRAGMA quick_check").all();
+    if (rows.length !== 1 || Object.values(rows[0] ?? {})[0] !== "ok")
+      throw new Error("PRAGMA quick_check did not return ok");
+  } catch (error) {
+    throw new Error(`stores/data.sqlite failed its integrity check: ${error instanceof Error ? error.message : String(error)}`);
+  } finally {
+    database?.close();
+  }
+}
+async function validateMedia(directory) {
+  const entries = await readdir2(directory, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile() || entry.isSymbolicLink())
+      throw new Error(`Named media must be regular files: stores/media/${entry.name}.`);
+    if (!/^[a-z][a-z0-9-]{0,63}$/.test(entry.name))
+      throw new Error(`Invalid named media key: ${entry.name}.`);
+    const bytes = await readFile4(join3(directory, entry.name));
+    if (!isImage(bytes) && !isBoundedZip(bytes))
+      throw new Error(`Unsupported named media content: ${entry.name}.`);
+  }
+}
+function isImage(bytes) {
+  if (bytes.byteLength > 25 * MiB)
+    return false;
+  if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) {
+    try {
+      decodePng2(bytes, { checkCrc: true });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  if (bytes[0] === 255 && bytes[1] === 216 && bytes.at(-2) === 255 && bytes.at(-1) === 217)
+    return true;
+  if (String.fromCharCode(...bytes.subarray(0, 6)).match(/^GIF8[79]a$/))
+    return true;
+  return String.fromCharCode(...bytes.subarray(0, 4)) === "RIFF" && String.fromCharCode(...bytes.subarray(8, 12)) === "WEBP";
+}
+function isBoundedZip(bytes) {
+  if (bytes.byteLength > 10 * MiB || bytes[0] !== 80 || bytes[1] !== 75)
+    return false;
   try {
-    await stat3(path);
+    const files = unzipSync(bytes);
+    const names = Object.keys(files);
+    if (!names.length || names.length > 256)
+      return false;
+    let total = 0;
+    for (const [name, value] of Object.entries(files)) {
+      if (!safeArchivePath(name) || value.byteLength > 25 * MiB)
+        return false;
+      total += value.byteLength;
+      if (total > 50 * MiB)
+        return false;
+    }
     return true;
   } catch {
     return false;
   }
-};
-var sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
+}
+async function validateQuickLook(root, required) {
+  const directory = join3(root, "QuickLook");
+  if (!await exists3(directory)) {
+    if (required)
+      throw new Error("Template packages must contain QuickLook/Preview.png and QuickLook/Icon.png.");
+    return;
+  }
+  const info = await lstat2(directory);
+  if (!info.isDirectory() || info.isSymbolicLink())
+    throw new Error("QuickLook must be a directory.");
+  const allowed = new Set(["Preview.png", "Icon.png"]);
+  for (const entry of await readdir2(directory))
+    if (!allowed.has(entry))
+      throw new Error(`Unexpected QuickLook entry QuickLook/${entry}.`);
+  const preview = join3(directory, "Preview.png");
+  const icon = join3(directory, "Icon.png");
+  if (required && (!await exists3(preview) || !await exists3(icon)))
+    throw new Error("Template packages must contain QuickLook/Preview.png and QuickLook/Icon.png.");
+  if (await exists3(preview))
+    validateStaticPng(await readFile4(preview), "QuickLook/Preview.png");
+  if (await exists3(icon))
+    validateIconPng(await readFile4(icon));
+}
+async function requireUTF8File(path, label) {
+  const info = await lstat2(path).catch(() => {
+    return;
+  });
+  if (!info?.isFile() || info.isSymbolicLink())
+    throw new Error(`${label} must be a regular file.`);
+  try {
+    decoder3.decode(await readFile4(path));
+  } catch {
+    throw new Error(`${label} must be UTF-8.`);
+  }
+}
+async function rejectSymlinks(root) {
+  for (const path of await walk(root))
+    if ((await lstat2(path)).isSymbolicLink())
+      throw new Error(`Runtime packages cannot contain symlinks: ${relative(root, path)}.`);
+}
+async function walk(root, directory = root) {
+  const result = [];
+  for (const entry of await readdir2(directory, { withFileTypes: true })) {
+    const path = join3(directory, entry.name);
+    result.push(path);
+    if (entry.isDirectory() && !entry.isSymbolicLink())
+      result.push(...await walk(root, path));
+  }
+  return result.sort((left, right) => relative(root, left).split(sep).join("/").localeCompare(relative(root, right).split(sep).join("/")));
+}
+var decoder3, exists3 = async (path) => stat3(path).then(() => true).catch(() => false), MiB, safeArchivePath = (path) => Boolean(path) && !path.startsWith("/") && !path.includes("\\") && !path.includes("\x00") && path.replace(/\/$/, "").split("/").every((part) => part && part !== "." && part !== "..");
+var init_runtime_package = __esm(() => {
+  init_document_skill();
+  init_project();
+  init_static_preview();
+  init_theme();
+  decoder3 = new TextDecoder("utf-8", { fatal: true });
+  MiB = 1024 * 1024;
+});
+
+// src/project.ts
+import { cp, lstat as lstat3, mkdir as mkdir2, mkdtemp, readFile as readFile5, readdir as readdir3, rename, rm, stat as stat4, writeFile as writeFile3 } from "fs/promises";
+import { basename as basename2, dirname as dirname3, join as join4, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { createHash } from "crypto";
+import { zipSync } from "fflate";
+import { decode as decodePng3 } from "fast-png";
+import { build as viteBuild } from "vite";
+import { checkPngDimensions as checkPngDimensions2, manifestSchemaURL, parseManifest } from "@hitslop/schema";
+async function loadManifest(root) {
+  const manifest = parseManifest(JSON.parse(await readFile5(manifestPath(root), "utf8")));
+  await validateSkin(root, manifest);
+  return manifest;
+}
 async function validateSkin(root, manifest) {
   if (!("skin" in manifest.presentation))
     return;
-  const path = join3(root, manifest.presentation.skin);
-  if (!await exists3(path))
+  const path = join4(root, manifest.presentation.skin);
+  if (!await exists4(path))
     throw new Error(`Missing window skin: ${manifest.presentation.skin}`);
-  const info = await lstat2(path);
+  const info = await lstat3(path);
   if (!info.isFile() || info.isSymbolicLink())
     throw new Error("The window skin must be a regular file, not a symlink.");
   let png;
+  const bytes = await readFile5(path);
+  checkPngDimensions2(bytes, "The window skin", manifest.presentation);
   try {
-    png = decodePng(await readFile3(path), { checkCrc: true });
+    png = decodePng3(bytes, { checkCrc: true });
   } catch {
     throw new Error("The window skin must be a valid PNG image.");
   }
-  if (png.width !== manifest.presentation.width || png.height !== manifest.presentation.height) {
-    throw new Error(`The window skin must be exactly ${manifest.presentation.width}x${manifest.presentation.height} pixels; received ${png.width}x${png.height}.`);
-  }
   if (png.channels !== 4)
     throw new Error("The window skin must be an RGBA PNG image.");
 }
@@ -342,26 +724,27 @@ async function scaffold(destination, options) {
   const template = options.template ?? "svelte-counter";
   if (!new Set(["svelte", "svelte-counter"]).has(template))
     throw new Error(`Unknown authoring template: ${template}`);
-  if (await exists3(destination) && (await readdir2(destination)).length)
+  if (await exists4(destination) && (await readdir3(destination)).length)
     throw new Error(`Destination is not empty: ${destination}`);
-  const slug = basename(destination).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "my-slop";
+  const slug = basename2(destination).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "my-slop";
   const defaultTitle = slug.split("-").map((part) => part[0]?.toUpperCase() + part.slice(1)).join(" ");
   const title = options.title || defaultTitle;
-  const templateRoot = fileURLToPath(new URL("../templates/svelte", import.meta.url));
+  const templateRoot = fileURLToPath2(new URL("../templates/svelte", import.meta.url));
   await cp(templateRoot, destination, { recursive: true });
-  await writeFile2(join3(destination, "package.json"), JSON.stringify({
+  await writeFile3(join4(destination, "package.json"), JSON.stringify({
     name: slug,
     private: true,
     type: "module",
     scripts: {
       dev: "slop dev",
+      check: "svelte-check --tsgo --tsconfig tsconfig.json",
       validate: "slop validate",
       build: "slop build",
       register: "slop register",
       publish: "slop publish"
     },
-    dependencies: { "@hitslop/runtime": "^0.1.2", "@hitslop/svelte": "^0.1.2", "bits-ui": "^2.19.0", svelte: "^5.0.0", zod: "^4.5.2" },
-    devDependencies: { "@hitslop/cli": `^${package_default.version}`, "@sveltejs/vite-plugin-svelte": "^7.0.0", "@vanilla-extract/css": "^1.17.4", "@vanilla-extract/vite-plugin": "^5.1.1", vite: "^8.0.0" }
+    dependencies: { "@hitslop/runtime": "^0.2.0", "@hitslop/svelte": "^0.2.0", "bits-ui": "^2.19.0", svelte: "^5.57.0", typebox: "^1.3.26" },
+    devDependencies: { "@hitslop/cli": `^${package_default.version}`, "@sveltejs/vite-plugin-svelte": "^7.3.0", "@vanilla-extract/css": "^1.21.2", "@vanilla-extract/vite-plugin": "^5.2.6", vite: "^8.2.2", "svelte-check": "^4.7.6", "@typescript/native": "npm:typescript@^7.0.2", typescript: "^6.0.3" }
   }, null, 2) + `
 `);
   const manifest = parseManifest({
@@ -373,74 +756,89 @@ async function scaffold(destination, options) {
     categories: options.categories?.length ? options.categories : ["utilities"],
     presentation: { width: 560, height: 420 }
   });
-  await writeFile2(join3(destination, "manifest.json"), JSON.stringify(manifest, null, 2) + `
+  await writeFile3(join4(destination, "manifest.json"), JSON.stringify(manifest, null, 2) + `
 `);
-  const appPath = join3(destination, "src/App.svelte");
-  await writeFile2(appPath, (await readFile3(appPath, "utf8")).replace("__SLOP_TITLE_LITERAL__", JSON.stringify(title)));
+  const appPath = join4(destination, "src/App.svelte");
+  await writeFile3(appPath, (await readFile5(appPath, "utf8")).replace("__SLOP_TITLE_LITERAL__", JSON.stringify(title)));
 }
 async function buildSlop(root) {
   const manifest = await loadManifest(root);
-  const dataSchema = await generateDataSchema(root);
+  const schemaPath = join4(root, "schema.ts");
+  const dataSchema = await exists4(schemaPath) ? await loadDataSchema(schemaPath) : undefined;
   await readDocumentGuideSource(root);
-  const distRoot = join3(root, "dist");
-  const output = join3(distRoot, `${manifest.slug}.slop`);
-  const viteOut = join3(root, ".hitslop", "vite-build");
-  const themeContract = await readThemeContract(root);
-  const hasTheme = themeContract !== undefined;
-  await rm(output, { recursive: true, force: true });
-  await rm(viteOut, { recursive: true, force: true });
-  await mkdir2(output, { recursive: true });
-  await viteBuild({ root, plugins: [hitSlopBuildPlugin({ hasTheme })], build: { outDir: viteOut, emptyOutDir: true } });
-  const html = join3(viteOut, "index.html");
-  if (!await exists3(html))
-    throw new Error("Vite did not produce index.html");
-  validateThemeReferences(await readFile3(html, "utf8"), themeContract, "generated app.html");
-  await cp(html, join3(output, "app.html"));
-  await writeFile2(join3(output, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+  const distRoot = join4(root, "dist");
+  await mkdir2(distRoot, { recursive: true });
+  const staging = await mkdtemp(join4(distRoot, ".build-"));
+  const output = join4(staging, `${manifest.slug}.slop`);
+  const destination = join4(distRoot, `${manifest.slug}.slop`);
+  const viteOut = join4(staging, "vite");
+  try {
+    const themeCSS = await readThemeCSS(root);
+    const contract = themeContract(themeCSS);
+    const hasTheme = contract !== undefined;
+    await mkdir2(output, { recursive: true });
+    await viteBuild({ root, plugins: [hitSlopBuildPlugin({ hasTheme })], build: { outDir: viteOut, emptyOutDir: true } });
+    const html = join4(viteOut, "index.html");
+    if (!await exists4(html))
+      throw new Error("Vite did not produce index.html");
+    validateThemeReferences(await readFile5(html, "utf8"), contract, "generated app.html");
+    await cp(html, join4(output, "app.html"));
+    for (const entry of await readdir3(viteOut)) {
+      if (entry === "index.html")
+        continue;
+      if (entry !== "assets")
+        throw new Error(`Unsupported Vite output ${entry}; emit runtime resources under assets/.`);
+      await copyRuntimeTree(join4(viteOut, entry), join4(output, entry));
+    }
+    await writeFile3(join4(output, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `);
-  for (const name of ["assets"]) {
-    const source = join3(root, name);
-    if (await exists3(source))
-      await copyRuntimeTree(source, join3(output, name));
-  }
-  if (dataSchema)
-    await writeFile2(join3(output, "data.schema.json"), `${JSON.stringify(dataSchema, null, 2)}
+    for (const name of ["assets"]) {
+      const source = join4(root, name);
+      if (await exists4(source))
+        await copyRuntimeTree(source, join4(output, name));
+    }
+    if (themeCSS !== undefined) {
+      await mkdir2(join4(output, "assets"), { recursive: true });
+      await writeFile3(join4(output, "assets/theme.css"), themeCSS);
+    }
+    if (dataSchema)
+      await writeFile3(join4(output, "data.schema.json"), `${JSON.stringify(dataSchema, null, 2)}
 `);
-  await emitDocumentSkill(root, output);
-  await rm(viteOut, { recursive: true, force: true });
-  return { directory: output, manifest };
-}
-async function generateDataSchema(root) {
-  const source = join3(root, "schema.ts");
-  if (!await exists3(source))
-    return;
-  const imported = await import(`${pathToFileURL(source).href}?hitslop=${Date.now()}`);
-  if (!imported.default)
-    throw new Error("schema.ts must default-export a Zod 4 schema");
-  let schema;
-  try {
-    schema = z.toJSONSchema(imported.default, { target: "draft-2020-12", io: "input" });
-  } catch (error) {
-    throw new Error(`Could not generate data.schema.json from schema.ts: ${error instanceof Error ? error.message : String(error)}`);
+    await emitDocumentSkill(root, output);
+    const { validateRuntimePackage: validateRuntimePackage2 } = await Promise.resolve().then(() => (init_runtime_package(), exports_runtime_package));
+    await validateRuntimePackage2(output, { template: true });
+    const previous = join4(staging, "previous.slop");
+    if (await exists4(destination))
+      await rename(destination, previous);
+    try {
+      await rename(output, destination);
+    } catch (error) {
+      if (await exists4(previous))
+        await rename(previous, destination);
+      throw error;
+    }
+    return { directory: destination, manifest };
+  } finally {
+    await rm(staging, { recursive: true, force: true });
   }
-  return schema;
 }
 async function validateAuthoringProject(root) {
   const manifest = await loadManifest(root);
   await readThemeContract(root);
-  await generateDataSchema(root);
+  if (await exists4(join4(root, "schema.ts")))
+    await loadDataSchema(join4(root, "schema.ts"));
   await readDocumentGuideSource(root);
   return manifest;
 }
-async function walk(root, directory = root) {
+async function walk2(root, directory = root) {
   const result = [];
-  for (const entry of await readdir2(directory, { withFileTypes: true })) {
-    const absolute = join3(directory, entry.name);
-    const rel = relative(root, absolute).split(sep).join("/");
+  for (const entry of await readdir3(directory, { withFileTypes: true })) {
+    const absolute = join4(directory, entry.name);
+    const rel = relative2(root, absolute).split(sep2).join("/");
     if (entry.isSymbolicLink())
       throw new Error(`Symlinks are not allowed in artifacts: ${rel}`);
     if (entry.isDirectory())
-      result.push(...await walk(root, absolute));
+      result.push(...await walk2(root, absolute));
     else if (entry.isFile())
       result.push(rel);
   }
@@ -449,33 +847,73 @@ async function walk(root, directory = root) {
 async function packSlop(directory) {
   const files = {};
   const epoch = new Date(2000, 0, 1, 0, 0, 0);
-  for (const path of await walk(directory))
-    files[path] = [new Uint8Array(await Bun.file(join3(directory, path)).arrayBuffer()), { mtime: epoch, level: 9 }];
+  for (const path of await walk2(directory))
+    files[path] = [new Uint8Array(await Bun.file(join4(directory, path)).arrayBuffer()), { mtime: epoch, level: 9 }];
   const bytes = zipSync(files, { level: 9 });
   return { bytes, sha256: sha256(bytes) };
 }
 async function copyRuntimeTree(source, destination) {
-  if ((await lstat2(source)).isSymbolicLink())
+  if ((await lstat3(source)).isSymbolicLink())
     throw new Error(`Symlinks are not allowed in artifacts: ${source}`);
-  const info = await stat3(source);
+  const info = await stat4(source);
   if (info.isDirectory()) {
     await mkdir2(destination, { recursive: true });
-    for (const entry of await readdir2(source))
-      await copyRuntimeTree(join3(source, entry), join3(destination, entry));
+    for (const entry of await readdir3(source))
+      await copyRuntimeTree(join4(source, entry), join4(destination, entry));
+    return;
+  }
+  await mkdir2(dirname3(destination), { recursive: true });
+  if (await exists4(destination)) {
+    if (!(await readFile5(source)).equals(await readFile5(destination)))
+      throw new Error(`Runtime asset collision: ${destination}`);
     return;
   }
-  await mkdir2(dirname2(destination), { recursive: true });
   await cp(source, destination);
 }
+var manifestPath = (root) => join4(root, "manifest.json"), exists4 = async (path) => {
+  try {
+    await stat4(path);
+    return true;
+  } catch {
+    return false;
+  }
+}, sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
+var init_project = __esm(() => {
+  init_package();
+  init_document_skill();
+  init_theme();
+  init_vite_build_plugin();
+  init_data_schema();
+});
+
+// src/cli.ts
+init_project();
+import { Crust } from "@crustjs/core";
+import { join as join10 } from "path";
+import { stat as stat6 } from "fs/promises";
+import { createInterface } from "readline/promises";
+import { validate, SlopCategorySchema } from "@hitslop/schema";
 
 // src/dev.ts
-import { stat as stat4 } from "fs/promises";
-import { join as join4, resolve as resolve2 } from "path";
+import { join as join5, resolve as resolve3 } from "path";
 import { createServer } from "vite";
 
 // src/dev-bridge.ts
+import { protocolVersion } from "@hitslop/schema/bridge";
 var hostStyle = `<style data-hitslop-host>*{scrollbar-width:none!important}*::-webkit-scrollbar{width:0!important;height:0!important;display:none!important}</style>`;
 var devHostJavaScript = `(() => {
+  const captureMode = new URL(window.location?.href ?? 'http://localhost/').searchParams.get('capture');
+  if (captureMode === 'icon') document.documentElement.dataset.slopRenderer = 'true';
+  if (captureMode === 'icon' || captureMode === 'export') {
+    window.addEventListener('slop:ready', () => {
+      setTimeout(async () => {
+        try {
+          if (captureMode === 'icon') document.documentElement.style.width = '512px';
+          await window.__hitslopCapture.begin('dev-preview', captureMode, {blockInteraction:false});
+        } catch (error) { console.error('Capture preview failed', error); }
+      }, 0);
+    }, {once:true});
+  }
   const listeners = { json: new Set(), sqlite: new Set(), media: new Set() };
   let jsonValue;
   let jsonRevision = 0;
@@ -494,6 +932,8 @@ var devHostJavaScript = `(() => {
   const drag = async () => undefined;
 
   window.slop = Object.freeze({
+    info: async () => ({ protocolVersion: ${protocolVersion}, capabilities: ['host.info', 'json.open', 'json.read', 'json.write', 'window.resize', 'window.drag'] }),
+    flush: async () => undefined,
     json: Object.freeze({
       open: async (value) => {
         if (!jsonOpened) { jsonValue = clone(value); jsonOpened = true; }
@@ -504,7 +944,7 @@ var devHostJavaScript = `(() => {
         return { value: clone(jsonValue), revision: revision() };
       },
       write: async (value, expectedRevision) => {
-        if (expectedRevision && expectedRevision !== revision()) throw new Error('revision_conflict');
+        if (expectedRevision !== undefined && expectedRevision !== revision()) throw Object.assign(new Error('Document changed'), { code: 'revision_conflict' });
         jsonValue = clone(value); jsonOpened = true; jsonRevision += 1;
         const result = { revision: revision() };
         emit('json', { source: 'app', revision: result.revision });
@@ -547,14 +987,8 @@ var injectHost = (html, options = {}) => {
 };
 
 // src/dev.ts
-var exists4 = async (path) => {
-  try {
-    await stat4(path);
-    return true;
-  } catch {
-    return false;
-  }
-};
+init_project();
+init_theme();
 function mockHostPlugin(options = {}) {
   return {
     name: "hitslop-browser-preview",
@@ -566,8 +1000,8 @@ function mockHostPlugin(options = {}) {
 }
 async function runDev(root) {
   await loadManifest(root);
-  const themeHref = await exists4(join4(root, "assets", "theme.css")) ? "/assets/theme.css" : undefined;
-  const server = await createServer({ root, plugins: [mockHostPlugin(themeHref ? { themeHref } : {})] });
+  const themeHref = await readThemeCSS(root) !== undefined ? "/assets/theme.css" : undefined;
+  const server = await createServer({ root, plugins: [themePreviewPlugin(root), mockHostPlugin(themeHref ? { themeHref } : {})] });
   await server.listen();
   const url = server.resolvedUrls?.local[0];
   if (!url)
@@ -576,42 +1010,46 @@ async function runDev(root) {
   if (process.platform === "darwin")
     Bun.spawn(["open", url], { stdout: "ignore", stderr: "ignore" });
 }
-async function runNative(arguments_) {
-  const override = process.env.HITSLOP_NATIVE_CLI;
-  const arch = process.arch === "arm64" ? "arm64-apple-macosx" : "x86_64-apple-macosx";
-  const repoDebugBin = resolve2(import.meta.dir, `../../../apps/apple/Packages/HitSlopApple/.build/${arch}/debug/hitslop-native`);
-  const repoReleaseBin = resolve2(import.meta.dir, `../../../apps/apple/Packages/HitSlopApple/.build/${arch}/release/hitslop-native`);
-  const candidates = [override, "/Applications/hitSlop.app/Contents/Helpers/hitslop-native", `${process.env.HOME}/Applications/hitSlop.app/Contents/Helpers/hitslop-native`, repoDebugBin, repoReleaseBin, "hitslop-native"].filter(Boolean);
-  for (const executable of candidates) {
-    try {
-      const processResult = Bun.spawn([executable, ...arguments_], { stdin: "inherit", stdout: "inherit", stderr: "inherit" });
-      const status = await processResult.exited;
-      if (status === 0)
-        return;
-      if (executable === candidates.at(-1))
-        throw new Error(`hitslop-native failed with status ${status}`);
-    } catch (error) {
-      if (executable === candidates.at(-1))
-        throw error;
+function themePreviewPlugin(root) {
+  root = resolve3(root);
+  return {
+    name: "hitslop:theme-preview",
+    configureServer(server) {
+      server.middlewares.use(async (request, response, next) => {
+        if (request.url?.split("?")[0] !== "/assets/theme.css")
+          return next();
+        try {
+          const css = await readThemeCSS(root);
+          if (css === undefined)
+            return next();
+          response.setHeader("Content-Type", "text/css; charset=utf-8");
+          response.end(css);
+        } catch (error) {
+          next(error);
+        }
+      });
+    },
+    handleHotUpdate({ file, server }) {
+      if (file === join5(root, "theme.ts"))
+        server.ws.send({ type: "full-reload" });
     }
-  }
-  throw new Error("Install hitSlop or set HITSLOP_NATIVE_CLI to use native rendering.");
+  };
 }
 
 // src/publish.ts
-import { join as join8, resolve as resolve5 } from "path";
-import { cp as cp3, mkdir as mkdir5, rm as rm3 } from "fs/promises";
+init_project();
 import { canonicalPublishEnvelope } from "@hitslop/schema";
 
 // src/identity.ts
+init_project();
 import { getPublicKeyAsync, keygenAsync, signAsync } from "@noble/ed25519";
 import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
-import { chmod, mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import { join as join5, resolve as resolve3 } from "path";
+import { chmod, mkdir as mkdir3, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import { join as join6, resolve as resolve4 } from "path";
 import { homedir } from "os";
 var service = "app.hitslop.cli";
 var account = "publisher";
-var fallback = join5(homedir(), ".hitslop", "identity.json");
+var fallback = join6(homedir(), ".hitslop", "identity.json");
 var encode = (bytes) => Buffer.from(bytes).toString("base64url");
 var decode = (value) => new Uint8Array(Buffer.from(value, "base64url"));
 async function keychainRead() {
@@ -627,14 +1065,14 @@ async function keychainWrite(value) {
   return result.exitCode === 0;
 }
 async function readStored() {
-  const value = await keychainRead() ?? await readFile4(fallback, "utf8").catch(() => null);
+  const value = await keychainRead() ?? await readFile6(fallback, "utf8").catch(() => null);
   return value ? JSON.parse(value) : null;
 }
 async function storeIdentity(identity) {
   const json = JSON.stringify(identity);
   if (!await keychainWrite(json)) {
-    await mkdir3(join5(homedir(), ".hitslop"), { recursive: true });
-    await writeFile3(fallback, json, { mode: 384 });
+    await mkdir3(join6(homedir(), ".hitslop"), { recursive: true });
+    await writeFile4(fallback, json, { mode: 384 });
     await chmod(fallback, 384);
   }
 }
@@ -666,15 +1104,15 @@ async function exportIdentity(path, passphrase) {
   const cipher = createCipheriv("aes-256-gcm", key, iv);
   const ciphertext = Buffer.concat([cipher.update(JSON.stringify(identity), "utf8"), cipher.final()]);
   const payload = { version: 1, kdf: "scrypt", salt: encode(salt), cipher: "aes-256-gcm", iv: encode(iv), tag: encode(cipher.getAuthTag()), ciphertext: encode(ciphertext) };
-  const output = resolve3(path);
-  await writeFile3(output, `${JSON.stringify(payload, null, 2)}
+  const output = resolve4(path);
+  await writeFile4(output, `${JSON.stringify(payload, null, 2)}
 `, { mode: 384 });
   await chmod(output, 384);
 }
 async function importIdentity(path, passphrase, force = false) {
   if (await readStored() && !force)
     throw new Error("A publisher identity already exists. Pass --force to replace it.");
-  const payload = JSON.parse(await readFile4(resolve3(path), "utf8"));
+  const payload = JSON.parse(await readFile6(resolve4(path), "utf8"));
   if (payload.version !== 1 || payload.kdf !== "scrypt" || payload.cipher !== "aes-256-gcm")
     throw new Error("Unsupported identity export format.");
   const key = scryptSync(passphrase, decode(payload.salt), 32, { N: 32768, r: 8, p: 1, maxmem: 64 * 1024 * 1024 });
@@ -692,390 +1130,161 @@ async function importIdentity(path, passphrase, force = false) {
 }
 var sign = async (message, identity) => encode(await signAsync(message, decode(identity.privateKey)));
 
-// src/install.ts
-import { chmod as chmod2, cp as cp2, lstat as lstat4, mkdir as mkdir4, readFile as readFile7, readdir as readdir4, rename, rm as rm2, stat as stat6 } from "fs/promises";
-import { randomUUID } from "crypto";
-import { homedir as homedir2 } from "os";
-import { join as join7, resolve as resolve4 } from "path";
-
-// src/runtime-package.ts
-import { Database } from "bun:sqlite";
-import { lstat as lstat3, readFile as readFile6, readdir as readdir3, stat as stat5 } from "fs/promises";
-import { basename as basename2, join as join6, relative as relative2, sep as sep2 } from "path";
-import { unzipSync } from "fflate";
-import { decode as decodePng3 } from "fast-png";
-import * as z2 from "zod";
-
-// src/static-preview.ts
-import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import { decode as decodePng2, encode as encodePng } from "fast-png";
-var MAX_PREVIEW_BYTES = 5 * 1024 * 1024;
-var ICON_SIZE = 512;
-function validateStaticPng(bytes, label) {
-  if (bytes.byteLength === 0)
-    throw new Error(`${label} is empty.`);
-  if (bytes.byteLength > MAX_PREVIEW_BYTES)
-    throw new Error(`${label} cannot exceed 5 MiB.`);
-  try {
-    return decodePng2(bytes, { checkCrc: true });
-  } catch {
-    throw new Error(`${label} must be a valid PNG image.`);
-  }
-}
-function validateIconPng(bytes, label = "The template icon") {
-  const image = validateStaticPng(bytes, label);
-  if (image.width !== ICON_SIZE || image.height !== ICON_SIZE)
-    throw new Error(`${label} must be exactly ${ICON_SIZE}x${ICON_SIZE} pixels.`);
-  return image;
-}
-function iconFromPng(bytes, size = ICON_SIZE) {
-  const image = validateStaticPng(bytes, "The template preview");
-  const scale = size / Math.max(image.width, image.height);
-  const width = Math.max(1, Math.round(image.width * scale));
-  const height = Math.max(1, Math.round(image.height * scale));
-  const output = image.depth === 16 ? new Uint16Array(size * size * 4) : new Uint8Array(size * size * 4);
-  const alpha = image.depth === 16 ? 65535 : 255;
-  const offsetX = Math.floor((size - width) / 2);
-  const offsetY = Math.floor((size - height) / 2);
-  for (let y = 0;y < height; y += 1) {
-    const sourceY = Math.min(image.height - 1, Math.floor((y + 0.5) * image.height / height));
-    for (let x = 0;x < width; x += 1) {
-      const sourceX = Math.min(image.width - 1, Math.floor((x + 0.5) * image.width / width));
-      const sourceOffset = (sourceY * image.width + sourceX) * image.channels;
-      const destinationOffset = ((offsetY + y) * size + offsetX + x) * 4;
-      if (image.channels === 1 || image.channels === 2) {
-        const gray = image.data[sourceOffset];
-        output[destinationOffset] = gray;
-        output[destinationOffset + 1] = gray;
-        output[destinationOffset + 2] = gray;
-        output[destinationOffset + 3] = image.channels === 2 ? image.data[sourceOffset + 1] : alpha;
-      } else {
-        output[destinationOffset] = image.data[sourceOffset];
-        output[destinationOffset + 1] = image.data[sourceOffset + 1];
-        output[destinationOffset + 2] = image.data[sourceOffset + 2];
-        output[destinationOffset + 3] = image.channels === 4 ? image.data[sourceOffset + 3] : alpha;
-      }
-    }
-  }
-  return encodePng({ width: size, height: size, data: output, depth: image.depth, channels: 4 });
-}
-async function writeDefaultIcon(previewPath, iconPath) {
-  await writeFile4(iconPath, iconFromPng(await readFile5(previewPath)));
-}
+// src/template-capture.ts
+import { cp as cp2, mkdir as mkdir4, readFile as readFile7, rm as rm2 } from "fs/promises";
+import { join as join8, resolve as resolve6 } from "path";
 
-// src/runtime-package.ts
-var decoder3 = new TextDecoder("utf-8", { fatal: true });
-var exists5 = async (path) => stat5(path).then(() => true).catch(() => false);
-var MiB = 1024 * 1024;
-async function validateRuntimePackage(root, options = {}) {
-  if (basename2(root).startsWith("."))
-    throw new Error("Runtime package path is not valid.");
-  const rootInfo = await lstat3(root).catch(() => {
-    return;
-  });
-  if (!rootInfo?.isDirectory() || rootInfo.isSymbolicLink())
-    throw new Error("A runtime .slop must be a directory, not a symlink.");
-  const manifest = await loadManifest(root);
-  await requireUTF8File(join6(root, "app.html"), "app.html");
-  await rejectSymlinks(root);
-  const allowed = new Set(["manifest.json", "app.html", "data.schema.json", "assets", "stores", "QuickLook", ".agents", "Icon\r"]);
-  for (const entry of await readdir3(root))
-    if (!allowed.has(entry))
-      throw new Error(`Runtime packages cannot contain ${entry}.`);
-  const forbidden = new Set(["package.json", "bun.lock", "bun.lockb", "node_modules", "source", "src", "build", "document.json", ".build", ".hitslop", "style.css"]);
-  for (const path of await walk2(root)) {
-    if (forbidden.has(basename2(path).toLowerCase()))
-      throw new Error(`Runtime packages cannot contain ${relative2(root, path)}.`);
-  }
-  if (options.template && await exists5(join6(root, "stores")))
-    throw new Error("Template packages cannot contain stores.");
-  if (options.template && await exists5(join6(root, "Icon\r")))
-    throw new Error("Template packages cannot contain Finder metadata Icon\\r.");
-  const schema = await readDataSchema(root);
-  const contract = await readThemeContract(root);
-  const appHTML = await readFile6(join6(root, "app.html"), "utf8");
-  validateThemeReferences(appHTML, contract, "app.html");
-  await validateStores(root, schema, contract);
-  await validateQuickLook(root, options.requirePreview ?? false);
-  await validateDocumentSkill(root);
-  return manifest;
-}
-async function readDataSchema(root) {
-  const current = join6(root, "data.schema.json");
-  if (!await exists5(current))
-    return;
-  await requireUTF8File(current, "data.schema.json");
-  try {
-    const value = JSON.parse(await readFile6(current, "utf8"));
-    if (!value || typeof value !== "object" || Array.isArray(value))
-      throw new Error("schema root must be an object");
-    z2.fromJSONSchema(value);
-    return value;
-  } catch (error) {
-    throw new Error(`data.schema.json must contain valid JSON Schema: ${error instanceof Error ? error.message : String(error)}`);
-  }
+// src/native.ts
+import { homedir as homedir2 } from "os";
+import { join as join7, resolve as resolve5 } from "path";
+async function runNative(arguments_) {
+  const override = process.env.HITSLOP_NATIVE_CLI;
+  const arch = process.arch === "arm64" ? "arm64-apple-macosx" : "x86_64-apple-macosx";
+  const build = resolve5(import.meta.dir, "../../../apps/apple/Packages/HitSlopApple/.build", arch);
+  const candidates = override !== undefined ? [override] : [
+    "/Applications/hitSlop.app/Contents/Helpers/hitslop-native",
+    join7(homedir2(), "Applications/hitSlop.app/Contents/Helpers/hitslop-native"),
+    join7(build, "debug/hitslop-native"),
+    join7(build, "release/hitslop-native"),
+    "hitslop-native"
+  ];
+  await runNativeCandidates(candidates, arguments_, override !== undefined);
 }
-async function validateStores(root, schema, contract) {
-  const stores = join6(root, "stores");
-  if (!await exists5(stores))
-    return;
-  const info = await lstat3(stores);
-  if (!info.isDirectory() || info.isSymbolicLink())
-    throw new Error("stores must be a directory.");
-  const allowed = new Set(["data.json", "data.sqlite", "data.sqlite-wal", "data.sqlite-shm", "media", "theme.css"]);
-  for (const entry of await readdir3(stores, { withFileTypes: true })) {
-    if (!allowed.has(entry.name))
-      throw new Error(`Unexpected store entry stores/${entry.name}.`);
-    if (entry.name === "media" ? !entry.isDirectory() : !entry.isFile())
-      throw new Error(`Invalid store entry stores/${entry.name}.`);
-  }
-  const json = join6(stores, "data.json");
-  if (await exists5(json)) {
-    let value;
+async function runNativeCandidates(candidates, arguments_, explicit = false) {
+  for (const executable of candidates) {
+    let child;
     try {
-      value = JSON.parse(decoder3.decode(await readFile6(json)));
+      child = Bun.spawn([executable, ...arguments_], { stdin: "inherit", stdout: "inherit", stderr: "inherit" });
     } catch (error) {
-      throw new Error(`stores/data.json must be valid UTF-8 JSON: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    if (schema) {
-      let validator;
-      try {
-        validator = z2.fromJSONSchema(schema);
-      } catch (error) {
-        throw new Error(`The data schema is not supported: ${error instanceof Error ? error.message : String(error)}`);
-      }
-      const result = validator.safeParse(value);
-      if (!result.success)
-        throw new Error(`stores/data.json does not match the data schema: ${z2.prettifyError(result.error)}`);
+      if (!explicit && error && typeof error === "object" && "code" in error && error.code === "ENOENT")
+        continue;
+      throw new Error(`Could not launch native helper ${executable}`, { cause: error });
     }
-  }
-  const sqlite = join6(stores, "data.sqlite");
-  for (const sidecar of ["data.sqlite-wal", "data.sqlite-shm"]) {
-    if (await exists5(join6(stores, sidecar)) && !await exists5(sqlite))
-      throw new Error(`stores/${sidecar} requires stores/data.sqlite.`);
-  }
-  if (await exists5(sqlite))
-    validateSQLite(sqlite);
-  const media = join6(stores, "media");
-  if (await exists5(media))
-    await validateMedia(media);
-  await validateThemeOverride(root, contract);
-}
-function validateSQLite(path) {
-  let database;
-  try {
-    database = new Database(path, { readonly: true, strict: true });
-    const rows = database.query("PRAGMA quick_check").all();
-    if (rows.length !== 1 || Object.values(rows[0] ?? {})[0] !== "ok")
-      throw new Error("PRAGMA quick_check did not return ok");
-  } catch (error) {
-    throw new Error(`stores/data.sqlite failed its integrity check: ${error instanceof Error ? error.message : String(error)}`);
-  } finally {
-    database?.close();
-  }
-}
-async function validateMedia(directory) {
-  const entries = await readdir3(directory, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isFile() || entry.isSymbolicLink())
-      throw new Error(`Named media must be regular files: stores/media/${entry.name}.`);
-    if (!/^[a-z][a-z0-9-]{0,63}$/.test(entry.name))
-      throw new Error(`Invalid named media key: ${entry.name}.`);
-    const bytes = await readFile6(join6(directory, entry.name));
-    if (!isImage(bytes) && !isBoundedZip(bytes))
-      throw new Error(`Unsupported named media content: ${entry.name}.`);
-  }
-}
-function isImage(bytes) {
-  if (bytes.byteLength > 25 * MiB)
-    return false;
-  if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) {
-    try {
-      decodePng3(bytes, { checkCrc: true });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  if (bytes[0] === 255 && bytes[1] === 216 && bytes.at(-2) === 255 && bytes.at(-1) === 217)
-    return true;
-  if (String.fromCharCode(...bytes.subarray(0, 6)).match(/^GIF8[79]a$/))
-    return true;
-  return String.fromCharCode(...bytes.subarray(0, 4)) === "RIFF" && String.fromCharCode(...bytes.subarray(8, 12)) === "WEBP";
-}
-function isBoundedZip(bytes) {
-  if (bytes.byteLength > 10 * MiB || bytes[0] !== 80 || bytes[1] !== 75)
-    return false;
-  try {
-    const files = unzipSync(bytes);
-    const names = Object.keys(files);
-    if (!names.length || names.length > 256)
-      return false;
-    let total = 0;
-    for (const [name, value] of Object.entries(files)) {
-      if (!safeArchivePath(name) || value.byteLength > 25 * MiB)
-        return false;
-      total += value.byteLength;
-      if (total > 50 * MiB)
-        return false;
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-var safeArchivePath = (path) => Boolean(path) && !path.startsWith("/") && !path.includes("\\") && !path.includes("\x00") && path.replace(/\/$/, "").split("/").every((part) => part && part !== "." && part !== "..");
-async function validateQuickLook(root, required) {
-  const directory = join6(root, "QuickLook");
-  if (!await exists5(directory)) {
-    if (required)
-      throw new Error("Template packages must contain QuickLook/Preview.png and QuickLook/Icon.png.");
+    const status = await child.exited;
+    if (status !== 0)
+      throw new Error(`Native helper ${executable} failed with status ${status}`);
     return;
   }
-  const info = await lstat3(directory);
-  if (!info.isDirectory() || info.isSymbolicLink())
-    throw new Error("QuickLook must be a directory.");
-  const allowed = new Set(["Preview.png", "Icon.png"]);
-  for (const entry of await readdir3(directory))
-    if (!allowed.has(entry))
-      throw new Error(`Unexpected QuickLook entry QuickLook/${entry}.`);
-  const preview = join6(directory, "Preview.png");
-  const icon = join6(directory, "Icon.png");
-  if (required && (!await exists5(preview) || !await exists5(icon)))
-    throw new Error("Template packages must contain QuickLook/Preview.png and QuickLook/Icon.png.");
-  if (await exists5(preview))
-    validateStaticPng(await readFile6(preview), "QuickLook/Preview.png");
-  if (await exists5(icon))
-    validateIconPng(await readFile6(icon));
+  throw new Error("Install hitSlop or set HITSLOP_NATIVE_CLI to use native rendering.");
 }
-async function requireUTF8File(path, label) {
-  const info = await lstat3(path).catch(() => {
-    return;
-  });
-  if (!info?.isFile() || info.isSymbolicLink())
-    throw new Error(`${label} must be a regular file.`);
+
+// src/template-capture.ts
+init_static_preview();
+init_runtime_package();
+async function prepareTemplateCaptures(directory, options = {}) {
+  const quickLook = join8(directory, "QuickLook");
+  await mkdir4(quickLook, { recursive: true });
+  const preview = join8(quickLook, "Preview.png");
+  const icon = join8(quickLook, "Icon.png");
   try {
-    decoder3.decode(await readFile6(path));
-  } catch {
-    throw new Error(`${label} must be UTF-8.`);
+    if (options.preview)
+      await cp2(resolve6(options.preview), preview);
+    else
+      await (options.capturePreview ?? ((path, output) => runNative(["screenshot", path, "--output", output])))(directory, preview);
+    validateStaticPng(await readFile7(preview), "The template preview");
+    if (options.icon)
+      await cp2(resolve6(options.icon), icon);
+    else {
+      await rm2(icon, { force: true });
+      const captured = options.captureIcon ? await options.captureIcon(directory, icon) : await runNative(["screenshot", directory, "--target", "icon", "--if-present", "--output", icon]).then(() => Bun.file(icon).exists());
+      if (!captured || !await Bun.file(icon).exists())
+        await writeDefaultIcon(preview, icon);
+    }
+    validateIconPng(await readFile7(icon));
+  } finally {
+    await rm2(join8(directory, "stores"), { recursive: true, force: true });
   }
+  await validateRuntimePackage(directory, { template: true, requirePreview: true });
 }
-async function rejectSymlinks(root) {
-  for (const path of await walk2(root))
-    if ((await lstat3(path)).isSymbolicLink())
-      throw new Error(`Runtime packages cannot contain symlinks: ${relative2(root, path)}.`);
-}
-async function walk2(root, directory = root) {
-  const result = [];
-  for (const entry of await readdir3(directory, { withFileTypes: true })) {
-    const path = join6(directory, entry.name);
-    result.push(path);
-    if (entry.isDirectory() && !entry.isSymbolicLink())
-      result.push(...await walk2(root, path));
-  }
-  return result.sort((left, right) => relative2(root, left).split(sep2).join("/").localeCompare(relative2(root, right).split(sep2).join("/")));
+
+// src/publish.ts
+var blobPart = (bytes) => Uint8Array.from(bytes);
+async function publishSlop(root, flags) {
+  const built = await buildSlop(root);
+  await prepareTemplateCaptures(built.directory, flags);
+  const packed = await packSlop(built.directory);
+  const identity = await getIdentity();
+  const envelope = {
+    format: "hitslop-publish/3",
+    requestId: crypto.randomUUID(),
+    publisherKeyId: identity.keyId,
+    publicKey: identity.publicKey,
+    artifactSha256: packed.sha256,
+    artifactBytes: packed.bytes.byteLength,
+    timestamp: Date.now()
+  };
+  const signature = await sign(canonicalPublishEnvelope(envelope), identity);
+  const form = new FormData;
+  form.set("envelope", JSON.stringify(envelope));
+  form.set("signature", signature);
+  form.set("artifact", new Blob([blobPart(packed.bytes)], { type: "application/zip" }), `${built.manifest.slug}.slop.zip`);
+  const endpoint = flags.registry ?? process.env.HITSLOP_REGISTRY_URL ?? "https://api.hitslop.com/api/publish";
+  const response = await fetch(endpoint, { method: "POST", body: form });
+  const body = await response.text();
+  if (!response.ok)
+    throw new Error(`Publish failed (${response.status}): ${body}`);
+  return body;
 }
 
 // src/install.ts
-var exists6 = async (path) => stat6(path).then(() => true).catch(() => false);
+init_project();
+init_runtime_package();
+import { chmod as chmod2, cp as cp3, lstat as lstat4, mkdir as mkdir5, readdir as readdir4, rename as rename2, rm as rm3, stat as stat5 } from "fs/promises";
+import { randomUUID } from "crypto";
+import { homedir as homedir3 } from "os";
+import { join as join9, resolve as resolve7 } from "path";
+var exists5 = async (path) => stat5(path).then(() => true).catch(() => false);
 async function installTemplate(input, options = {}) {
-  const source = resolve4(input);
+  const source = resolve7(input);
   const runtime = await isRuntimePackage(source) ? source : (await buildSlop(source)).directory;
   const manifest = await loadManifest(runtime);
   await validateTemplatePackage(runtime);
-  const templatesRoot = resolve4(options.templatesRoot ?? process.env.HITSLOP_TEMPLATES_ROOT ?? join7(homedir2(), ".hitslop", "templates"));
-  const target = join7(templatesRoot, `${manifest.slug}.slop`);
-  const replaced = await exists6(target);
+  const templatesRoot = resolve7(options.templatesRoot ?? process.env.HITSLOP_TEMPLATES_ROOT ?? join9(homedir3(), ".hitslop", "templates"));
+  const target = join9(templatesRoot, `${manifest.slug}.slop`);
+  const replaced = await exists5(target);
   if (replaced && !options.force) {
     if (!options.confirmOverwrite)
       throw new Error(`Template ${manifest.slug} is already installed. Pass --force to replace it.`);
     if (!await options.confirmOverwrite(target))
       throw new Error("Install cancelled.");
   }
-  await mkdir4(templatesRoot, { recursive: true });
-  const staging = join7(templatesRoot, `.${manifest.slug}.${randomUUID()}.installing.slop`);
-  const backup = join7(templatesRoot, `.${manifest.slug}.${randomUUID()}.backup.slop`);
+  await mkdir5(templatesRoot, { recursive: true });
+  const stagingRoot = join9(templatesRoot, `.${manifest.slug}.${randomUUID()}.installing`);
+  const staging = join9(stagingRoot, `${manifest.slug}.slop`);
+  const backup = join9(templatesRoot, `.${manifest.slug}.${randomUUID()}.backup.slop`);
   try {
-    await cp2(runtime, staging, { recursive: true, errorOnExist: true });
-    const quickLook = join7(staging, "QuickLook");
-    const preview = join7(quickLook, "Preview.png");
-    await mkdir4(quickLook, { recursive: true });
-    if (options.preview)
-      await cp2(resolve4(options.preview), preview);
-    else {
-      const capture = options.capturePreview ?? ((packageDirectory, output) => runNative(["screenshot", packageDirectory, "--output", output]));
-      await capture(staging, preview);
-    }
-    await validatePreview(preview);
-    const icon = join7(quickLook, "Icon.png");
-    if (options.icon)
-      await cp2(resolve4(options.icon), icon);
-    else {
-      await rm2(icon, { force: true });
-      const captured = options.captureIcon ? await options.captureIcon(staging, icon) : await captureOptionalIcon(staging, icon);
-      if (!captured || !await exists6(icon))
-        await writeDefaultIcon(preview, icon);
-    }
-    validateIconPng(await readFile7(icon));
-    await rm2(join7(staging, "stores"), { recursive: true, force: true });
-    await validateQuickLook2(staging, true);
+    await mkdir5(stagingRoot);
+    await cp3(runtime, staging, { recursive: true, errorOnExist: true });
+    await prepareTemplateCaptures(staging, options);
     if (replaced) {
       await makePackageWritable(target);
-      await rename(target, backup);
+      await rename2(target, backup);
     }
     try {
-      await rename(staging, target);
+      await rename2(staging, target);
     } catch (error) {
-      if (replaced && await exists6(backup))
-        await rename(backup, target);
+      if (replaced && await exists5(backup))
+        await rename2(backup, target);
       throw error;
     }
     await makePackageImmutable(target);
-    await rm2(backup, { recursive: true, force: true });
+    await rm3(backup, { recursive: true, force: true });
     return { directory: target, manifest, replaced };
   } finally {
-    await rm2(staging, { recursive: true, force: true });
-    if (await exists6(backup) && !await exists6(target)) {
-      await rename(backup, target);
+    await rm3(stagingRoot, { recursive: true, force: true });
+    if (await exists5(backup) && !await exists5(target)) {
+      await rename2(backup, target);
       await makePackageImmutable(target).catch(() => {});
     } else
-      await rm2(backup, { recursive: true, force: true });
+      await rm3(backup, { recursive: true, force: true });
   }
 }
-async function captureOptionalIcon(packageDirectory, output) {
-  await runNative(["screenshot", packageDirectory, "--target", "icon", "--if-present", "--output", output]);
-  return await exists6(output);
-}
-async function validatePreview(path) {
-  validateStaticPng(await readFile7(path), "The template preview");
-}
 async function isRuntimePackage(path) {
-  return await exists6(join7(path, "manifest.json")) && await exists6(join7(path, "app.html"));
+  return await exists5(join9(path, "manifest.json")) && await exists5(join9(path, "app.html"));
 }
 async function validateTemplatePackage(path, options = {}) {
   await validateRuntimePackage(path, { template: true, requirePreview: options.requirePreview ?? false });
 }
-async function validateQuickLook2(path, requirePreview) {
-  const directory = join7(path, "QuickLook");
-  if (!await exists6(directory)) {
-    if (requirePreview)
-      throw new Error("Template packages must contain QuickLook/Preview.png and QuickLook/Icon.png.");
-    return;
-  }
-  const allowed = new Set(["Preview.png", "Icon.png"]);
-  for (const entry of await readdir4(directory))
-    if (!allowed.has(entry))
-      throw new Error(`Template packages cannot contain QuickLook/${entry}.`);
-  const preview = join7(directory, "Preview.png");
-  const icon = join7(directory, "Icon.png");
-  if (!await exists6(preview) || !await exists6(icon)) {
-    if (requirePreview)
-      throw new Error("Template packages must contain QuickLook/Preview.png and QuickLook/Icon.png.");
-    return;
-  }
-  await validatePreview(preview);
-  validateIconPng(await readFile7(icon));
-}
 async function makePackageWritable(root) {
   const walk3 = async (path) => {
     const info = await lstat4(path);
@@ -1085,7 +1294,7 @@ async function makePackageWritable(root) {
     await chmod2(path, mode | (info.isDirectory() ? 448 : 384));
     if (info.isDirectory())
       for (const entry of await readdir4(path))
-        await walk3(join7(path, entry));
+        await walk3(join9(path, entry));
   };
   await walk3(root);
 }
@@ -1096,61 +1305,17 @@ async function makePackageImmutable(root) {
       throw new Error(`Runtime packages cannot contain symlinks: ${path}`);
     if (info.isDirectory())
       for (const entry of await readdir4(path))
-        await walk3(join7(path, entry));
+        await walk3(join9(path, entry));
     await chmod2(path, info.mode & 511 & ~146);
   };
   await walk3(root);
 }
 
-// src/publish.ts
-var blobPart = (bytes) => Uint8Array.from(bytes);
-async function publishSlop(root, flags) {
-  const built = await buildSlop(root);
-  const quickLook = join8(built.directory, "QuickLook");
-  const preview = join8(quickLook, "Preview.png");
-  await mkdir5(quickLook, { recursive: true });
-  if (flags.preview)
-    await cp3(resolve5(flags.preview), preview);
-  else
-    await runNative(["screenshot", built.directory, "--output", preview]);
-  validateStaticPng(new Uint8Array(await Bun.file(preview).arrayBuffer()), "The template preview");
-  const icon = join8(quickLook, "Icon.png");
-  if (flags.icon)
-    await cp3(resolve5(flags.icon), icon);
-  else {
-    await rm3(icon, { force: true });
-    await runNative(["screenshot", built.directory, "--target", "icon", "--if-present", "--output", icon]);
-    if (!await Bun.file(icon).exists())
-      await writeDefaultIcon(preview, icon);
-  }
-  validateIconPng(new Uint8Array(await Bun.file(icon).arrayBuffer()));
-  await rm3(join8(built.directory, "stores"), { recursive: true, force: true });
-  await validateTemplatePackage(built.directory, { requirePreview: true });
-  const packed = await packSlop(built.directory);
-  const identity = await getIdentity();
-  const envelope = {
-    format: "hitslop-publish/3",
-    requestId: crypto.randomUUID(),
-    publisherKeyId: identity.keyId,
-    publicKey: identity.publicKey,
-    artifactSha256: packed.sha256,
-    artifactBytes: packed.bytes.byteLength,
-    timestamp: Date.now()
-  };
-  const signature = await sign(canonicalPublishEnvelope(envelope), identity);
-  const form = new FormData;
-  form.set("envelope", JSON.stringify(envelope));
-  form.set("signature", signature);
-  form.set("artifact", new Blob([blobPart(packed.bytes)], { type: "application/zip" }), `${built.manifest.slug}.slop.zip`);
-  const endpoint = flags.registry ?? process.env.HITSLOP_REGISTRY_URL ?? "https://api.hitslop.com/api/publish";
-  const response = await fetch(endpoint, { method: "POST", body: form });
-  const body = await response.text();
-  if (!response.ok)
-    throw new Error(`Publish failed (${response.status}): ${body}`);
-  return body;
-}
+// src/cli.ts
+init_runtime_package();
 
 // src/render.ts
+init_runtime_package();
 async function exportDocument(path, options, native = runNative) {
   await validateRuntimePackage(path);
   await native(["export", path, "--format", options.format, "--output", options.output]);
@@ -1170,7 +1335,7 @@ async function screenshotDocument(path, options, native = runNative) {
 
 // src/cli.ts
 var titleFor = (directory) => directory.split("/").filter(Boolean).at(-1)?.split(/[-_ ]+/).map((part) => part[0]?.toUpperCase() + part.slice(1)).join(" ") || "My Slop";
-var parseCategories = (values) => values.map((value) => SlopCategorySchema.parse(value.trim().toLowerCase()));
+var parseCategories = (values) => values.map((value) => validate(SlopCategorySchema, value.trim().toLowerCase()));
 async function initMetadata(directory, flags) {
   const authorName = flags["author-name"]?.trim();
   const authorURL = flags["author-url"]?.trim();
@@ -1222,7 +1387,7 @@ app = app.command("init", (command) => command.meta({ description: "Create a Sve
   console.log(`Created ${args.directory}`);
 }));
 app = app.command("validate", (command) => command.meta({ description: "Validate an authoring project or built .slop document." }).args([{ name: "path", type: "path", default: "." }]).run(async ({ args }) => {
-  const runtime = await stat7(join9(args.path, "app.html")).then((value) => value.isFile()).catch(() => false);
+  const runtime = await stat6(join10(args.path, "app.html")).then((value) => value.isFile()).catch(() => false);
   const manifest = runtime ? await validateRuntimePackage(args.path) : await validateAuthoringProject(args.path);
   console.log(`valid	${manifest.slug}`);
 }));
@@ -1270,7 +1435,7 @@ async function secret(prompt) {
   process.stdout.write(prompt);
   process.stdin.setRawMode(true);
   process.stdin.resume();
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve8, reject) => {
     let value = "";
     const onData = (chunk) => {
       for (const byte of chunk) {
@@ -1283,7 +1448,7 @@ async function secret(prompt) {
           cleanup();
           process.stdout.write(`
 `);
-          resolve6(value);
+          resolve8(value);
           return;
         }
         if (byte === 127 || byte === 8) {