@hitslop/cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1340 @@
+#!/usr/bin/env bun
+// @bun
+
+// 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.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.app",
+  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": "workspace:*",
+    "@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"
+  }
+};
+
+// src/document-skill.ts
+import { lstat, mkdir, readFile, readdir, stat, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+import {
+  documentGuidePath,
+  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 });
+  await writeFile(skill, documentSkillContent);
+  const guide = await readDocumentGuideSource(sourceRoot);
+  if (!guide)
+    return;
+  const destination = join(outputRoot, documentGuidePath);
+  await mkdir(dirname(destination), { recursive: true });
+  await writeFile(destination, guide);
+}
+async function readDocumentGuideSource(sourceRoot) {
+  const guideSource = join(sourceRoot, documentGuideSource);
+  if (!await exists(guideSource))
+    return;
+  const info = await lstat(guideSource);
+  if (!info.isFile() || info.isSymbolicLink())
+    throw new Error(`${documentGuideSource} must be a regular UTF-8 Markdown file.`);
+  const guide = await readFile(guideSource);
+  if (guide.byteLength > maxDocumentGuideBytes)
+    throw new Error(`${documentGuideSource} cannot exceed 32 KiB.`);
+  try {
+    decoder.decode(guide);
+  } catch {
+    throw new Error(`${documentGuideSource} must be UTF-8.`);
+  }
+  return guide;
+}
+async function validateDocumentSkill(root) {
+  const agents = join(root, ".agents");
+  if (!await exists(agents)) {
+    throw new Error(`Runtime package is missing ${documentSkillPath}.`);
+  }
+  await requireDirectory(agents, ".agents");
+  await requireOnly(agents, new Set(["skills"]), ".agents");
+  const skills = join(agents, "skills");
+  await requireDirectory(skills, ".agents/skills");
+  await requireOnly(skills, new Set(["hitslop-document"]), ".agents/skills");
+  const folder = join(skills, "hitslop-document");
+  await requireDirectory(folder, ".agents/skills/hitslop-document");
+  await requireOnly(folder, new Set(["SKILL.md", "references"]), ".agents/skills/hitslop-document", true);
+  const skillPath = join(root, documentSkillPath);
+  const skillInfo = await lstat(skillPath).catch(() => {
+    return;
+  });
+  if (!skillInfo?.isFile() || skillInfo.isSymbolicLink())
+    throw new Error(`${documentSkillPath} must be a regular file.`);
+  let canonical = false;
+  try {
+    canonical = isCanonicalDocumentSkill(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;
+  await requireDirectory(references, ".agents/skills/hitslop-document/references");
+  await requireOnly(references, new Set(["app-guide.md"]), ".agents/skills/hitslop-document/references");
+  const guide = join(root, documentGuidePath);
+  const guideInfo = await lstat(guide);
+  if (!guideInfo.isFile() || guideInfo.isSymbolicLink())
+    throw new Error(`${documentGuidePath} must be a regular file.`);
+  const contents = await readFile(guide);
+  if (contents.byteLength > maxDocumentGuideBytes)
+    throw new Error(`${documentGuidePath} cannot exceed 32 KiB.`);
+  try {
+    decoder.decode(contents);
+  } catch {
+    throw new Error(`${documentGuidePath} must be UTF-8.`);
+  }
+}
+async function requireDirectory(path, label) {
+  const info = await lstat(path).catch(() => {
+    return;
+  });
+  if (!info?.isDirectory() || info.isSymbolicLink())
+    throw new Error(`${label} must be a directory, not a symlink.`);
+}
+async function requireOnly(directory, allowed, label, optionalReferences = false) {
+  for (const entry of await readdir(directory, { withFileTypes: true })) {
+    if (entry.isSymbolicLink())
+      throw new Error(`${label} cannot contain symlinks.`);
+    if (!allowed.has(entry.name) || optionalReferences && entry.name === "references" && !entry.isDirectory()) {
+      throw new Error(`${label} cannot contain ${entry.name}.`);
+    }
+  }
+}
+
+// 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));
+  } catch {
+    throw new Error(`${label} must be UTF-8.`);
+  }
+}
+async function readThemeContract(root) {
+  const path = join2(root, "assets", "theme.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;
+}
+async function validateThemeOverride(root, contract) {
+  const path = join2(root, "stores", "theme.css");
+  if (!await exists2(path))
+    return;
+  if (!contract)
+    throw new Error("stores/theme.css requires an immutable assets/theme.css contract.");
+  const source = await readUTF8(path, "stores/theme.css");
+  const overrides = parseTheme(source, "stores/theme.css");
+  for (const property of overrides)
+    if (!contract.has(property))
+      throw new Error(`stores/theme.css cannot define unknown theme variable ${property}.`);
+  validateThemeReferences(source, contract, "stores/theme.css");
+}
+function validateThemeReferences(cssOrHTML, contract, label) {
+  const referenced = new Set([...cssOrHTML.matchAll(/var\(\s*(--slop-[a-z0-9-]+)/gi)].map((match) => match[1]));
+  if (!referenced.size)
+    return;
+  if (!contract)
+    throw new Error(`${label} references public --slop-* variables but assets/theme.css is missing.`);
+  for (const property of referenced)
+    if (!contract.has(property))
+      throw new Error(`${label} references ${property}, but assets/theme.css does not provide a default.`);
+}
+function parseTheme(source, label) {
+  let root;
+  try {
+    root = postcss.parse(source, { from: label });
+  } catch (error) {
+    throw new Error(`${label} is not valid CSS: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const rules = root.nodes.filter((node) => node.type !== "comment");
+  if (rules.length !== 1 || rules[0]?.type !== "rule" || rules[0].selector.trim() !== ":root") {
+    throw new Error(`${label} must contain exactly one :root rule.`);
+  }
+  const properties = new Set;
+  for (const node of rules[0].nodes) {
+    if (node.type === "comment")
+      continue;
+    if (node.type !== "decl")
+      throw new Error(`${label} can contain only custom-property declarations.`);
+    if (!/^--slop-[a-z0-9-]+$/.test(node.prop))
+      throw new Error(`${label} can define only lowercase --slop-* custom properties.`);
+    if (!node.value.trim())
+      throw new Error(`${label} cannot leave ${node.prop} empty.`);
+    if (properties.has(node.prop))
+      throw new Error(`${label} defines ${node.prop} more than once.`);
+    properties.add(node.prop);
+  }
+  if (!properties.size)
+    throw new Error(`${label} must define at least one --slop-* custom property.`);
+  return properties;
+}
+
+// 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>`);
+}
+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;
+};
+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,
+    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 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)
+          html = addThemeLinks(html);
+        asset.source = html;
+      }
+      for (const fileName of consumed)
+        delete bundle[fileName];
+    }
+  };
+}
+
+// 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);
+  return manifest;
+}
+var exists3 = async (path) => {
+  try {
+    await stat3(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
+async function validateSkin(root, manifest) {
+  if (!("skin" in manifest.presentation))
+    return;
+  const path = join3(root, manifest.presentation.skin);
+  if (!await exists3(path))
+    throw new Error(`Missing window skin: ${manifest.presentation.skin}`);
+  const info = await lstat2(path);
+  if (!info.isFile() || info.isSymbolicLink())
+    throw new Error("The window skin must be a regular file, not a symlink.");
+  let png;
+  try {
+    png = decodePng(await readFile3(path), { 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.");
+}
+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)
+    throw new Error(`Destination is not empty: ${destination}`);
+  const slug = basename(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));
+  await cp(templateRoot, destination, { recursive: true });
+  await writeFile2(join3(destination, "package.json"), JSON.stringify({
+    name: slug,
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "slop dev",
+      validate: "slop validate",
+      build: "slop build",
+      register: "slop register",
+      publish: "slop publish"
+    },
+    dependencies: { "@hitslop/runtime": `^${package_default.version}`, "@hitslop/svelte": `^${package_default.version}`, "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" }
+  }, null, 2) + `
+`);
+  await writeFile2(join3(destination, "manifest.json"), JSON.stringify({
+    $schema: manifestSchemaURL,
+    slug,
+    title,
+    description: options.description || "A small, lovable hitSlop app.",
+    categories: options.categories?.length ? options.categories : ["utilities"],
+    presentation: { width: 560, height: 420 }
+  }, null, 2) + `
+`);
+  const appPath = join3(destination, "src/App.svelte");
+  await writeFile2(appPath, (await readFile3(appPath, "utf8")).replace("__SLOP_TITLE_LITERAL__", JSON.stringify(title)));
+}
+async function buildSlop(root) {
+  const manifest = await loadManifest(root);
+  const dataSchema = await generateDataSchema(root);
+  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)}
+`);
+  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)}
+`);
+  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)}`);
+  }
+  return schema;
+}
+async function validateAuthoringProject(root) {
+  const manifest = await loadManifest(root);
+  await readThemeContract(root);
+  await generateDataSchema(root);
+  await readDocumentGuideSource(root);
+  return manifest;
+}
+async function walk(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("/");
+    if (entry.isSymbolicLink())
+      throw new Error(`Symlinks are not allowed in artifacts: ${rel}`);
+    if (entry.isDirectory())
+      result.push(...await walk(root, absolute));
+    else if (entry.isFile())
+      result.push(rel);
+  }
+  return result.sort();
+}
+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 }];
+  const bytes = zipSync(files, { level: 9 });
+  return { bytes, sha256: sha256(bytes) };
+}
+async function copyRuntimeTree(source, destination) {
+  if ((await lstat2(source)).isSymbolicLink())
+    throw new Error(`Symlinks are not allowed in artifacts: ${source}`);
+  const info = await stat3(source);
+  if (info.isDirectory()) {
+    await mkdir2(destination, { recursive: true });
+    for (const entry of await readdir2(source))
+      await copyRuntimeTree(join3(source, entry), join3(destination, entry));
+    return;
+  }
+  await mkdir2(dirname2(destination), { recursive: true });
+  await cp(source, destination);
+}
+
+// src/dev.ts
+import { stat as stat4 } from "fs/promises";
+import { join as join4, resolve as resolve2 } from "path";
+import { createServer } from "vite";
+
+// src/dev-bridge.ts
+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 listeners = { json: new Set(), sqlite: new Set(), media: new Set() };
+  let jsonValue;
+  let jsonRevision = 0;
+  let jsonOpened = false;
+  let mediaRevision = 0;
+
+  const clone = (value) => value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+  const emit = (kind, event) => listeners[kind].forEach((callback) => callback({ kind, ...event }));
+  const watch = (kind, callback) => {
+    listeners[kind].add(callback);
+    return () => listeners[kind].delete(callback);
+  };
+  const revision = () => 'dev:' + jsonRevision;
+
+  const resize = async (size) => size;
+  const drag = async () => undefined;
+
+  window.slop = Object.freeze({
+    json: Object.freeze({
+      open: async (value) => {
+        if (!jsonOpened) { jsonValue = clone(value); jsonOpened = true; }
+        return { value: clone(jsonValue), revision: revision() };
+      },
+      read: async () => {
+        if (!jsonOpened) throw new Error('JSON preview store has not been opened');
+        return { value: clone(jsonValue), revision: revision() };
+      },
+      write: async (value, expectedRevision) => {
+        if (expectedRevision && expectedRevision !== revision()) throw new Error('revision_conflict');
+        jsonValue = clone(value); jsonOpened = true; jsonRevision += 1;
+        const result = { revision: revision() };
+        emit('json', { source: 'app', revision: result.revision });
+        return result;
+      },
+      onChange: (callback) => watch('json', callback)
+    }),
+    db: Object.freeze({
+      query: async () => [],
+      execute: async () => { emit('sqlite', { source: 'app' }); return 0; },
+      transaction: async () => { emit('sqlite', { source: 'app' }); return 0; },
+      onChange: (callback) => watch('sqlite', callback)
+    }),
+    media: Object.freeze({
+      open: async () => ({ exists: false, revision: null }),
+      write: async () => {
+        mediaRevision += 1;
+        const result = { revision: 'dev-media:' + mediaRevision };
+        emit('media', { source: 'app', revision: result.revision });
+        return result;
+      },
+      remove: async () => {
+        emit('media', { source: 'app', revision: null });
+        return { revision: null };
+      },
+      onChange: (callback) => watch('media', callback)
+    }),
+    window: Object.freeze({ resize, drag }),
+    ready: () => {
+      document.documentElement.dataset.hitslopReady = 'true';
+      window.dispatchEvent(new Event('slop:ready'));
+    }
+  });
+})();`;
+var bridgeScript = `<script>${devHostJavaScript}</script>`;
+var injectHost = (html, options = {}) => {
+  const theme = options.themeHref ? `<link rel="stylesheet" href="${options.themeHref}" data-hitslop-theme-default>` : "";
+  const payload = hostStyle + theme + bridgeScript;
+  return /<head(?:\s[^>]*)?>/i.test(html) ? html.replace(/<head(?:\s[^>]*)?>/i, (tag) => tag + payload) : payload + html;
+};
+
+// src/dev.ts
+var exists4 = async (path) => {
+  try {
+    await stat4(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+function mockHostPlugin(options = {}) {
+  return {
+    name: "hitslop-browser-preview",
+    transformIndexHtml: {
+      order: "pre",
+      handler: (html) => injectHost(html, 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 } : {})] });
+  await server.listen();
+  const url = server.resolvedUrls?.local[0];
+  if (!url)
+    throw new Error("Vite did not expose a development URL");
+  console.log(`hitSlop UI preview: ${url}`);
+  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;
+    }
+  }
+  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";
+import { canonicalPublishEnvelope } from "@hitslop/schema";
+
+// src/identity.ts
+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 { homedir, userInfo } from "os";
+var service = "app.hitslop.cli";
+var account = "publisher";
+var fallback = join5(homedir(), ".hitslop", "identity.json");
+var encode = (bytes) => Buffer.from(bytes).toString("base64url");
+var decode = (value) => new Uint8Array(Buffer.from(value, "base64url"));
+async function keychainRead() {
+  if (process.platform !== "darwin")
+    return null;
+  const result = Bun.spawnSync(["security", "find-generic-password", "-s", service, "-a", account, "-w"]);
+  return result.exitCode === 0 ? result.stdout.toString().trim() : null;
+}
+async function keychainWrite(value) {
+  if (process.platform !== "darwin")
+    return false;
+  const result = Bun.spawnSync(["security", "add-generic-password", "-U", "-s", service, "-a", account, "-w", value]);
+  return result.exitCode === 0;
+}
+async function readStored() {
+  const value = await keychainRead() ?? await readFile4(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 chmod(fallback, 384);
+  }
+}
+async function validated(identity) {
+  if (!identity.displayName.trim() || identity.displayName.length > 80)
+    throw new Error("Publisher name must contain 1\u201380 characters.");
+  const derivedPublic = await getPublicKeyAsync(decode(identity.privateKey));
+  if (encode(derivedPublic) !== identity.publicKey)
+    throw new Error("Identity public and private keys do not match.");
+  if (sha256(derivedPublic).slice(0, 32) !== identity.keyId)
+    throw new Error("Identity key ID does not match its public key.");
+  return { ...identity, displayName: identity.displayName.trim() };
+}
+async function getIdentity() {
+  const stored = await readStored();
+  if (stored)
+    return validated(stored);
+  const pair = await keygenAsync();
+  const publicKey = pair.publicKey ?? await getPublicKeyAsync(pair.secretKey);
+  const identity = await validated({ privateKey: encode(pair.secretKey), publicKey: encode(publicKey), keyId: sha256(publicKey).slice(0, 32), displayName: userInfo().username });
+  await storeIdentity(identity);
+  return identity;
+}
+async function setIdentityName(displayName) {
+  const identity = await getIdentity();
+  const next = await validated({ ...identity, displayName });
+  await storeIdentity(next);
+  return next;
+}
+async function exportIdentity(path, passphrase) {
+  if (passphrase.length < 10)
+    throw new Error("Identity export passphrases must contain at least 10 characters.");
+  const identity = await getIdentity();
+  const salt = randomBytes(16);
+  const iv = randomBytes(12);
+  const key = scryptSync(passphrase, salt, 32, { N: 32768, r: 8, p: 1, maxmem: 64 * 1024 * 1024 });
+  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)}
+`, { 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"));
+  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 });
+  const decipher = createDecipheriv("aes-256-gcm", key, decode(payload.iv));
+  decipher.setAuthTag(decode(payload.tag));
+  let identity;
+  try {
+    identity = JSON.parse(Buffer.concat([decipher.update(decode(payload.ciphertext)), decipher.final()]).toString("utf8"));
+  } catch {
+    throw new Error("Could not decrypt identity; check the passphrase and file.");
+  }
+  const checked = await validated(identity);
+  await storeIdentity(checked);
+  return checked;
+}
+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/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)}`);
+  }
+}
+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;
+    try {
+      value = JSON.parse(decoder3.decode(await readFile6(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 = 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)}`);
+    }
+  }
+  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.");
+    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));
+}
+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.`);
+  try {
+    decoder3.decode(await readFile6(path));
+  } catch {
+    throw new Error(`${label} must be UTF-8.`);
+  }
+}
+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/install.ts
+var exists6 = async (path) => stat6(path).then(() => true).catch(() => false);
+async function installTemplate(input, options = {}) {
+  const source = resolve4(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);
+  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`);
+  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);
+    if (replaced) {
+      await makePackageWritable(target);
+      await rename(target, backup);
+    }
+    try {
+      await rename(staging, target);
+    } catch (error) {
+      if (replaced && await exists6(backup))
+        await rename(backup, target);
+      throw error;
+    }
+    await makePackageImmutable(target);
+    await rm2(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 makePackageImmutable(target).catch(() => {});
+    } else
+      await rm2(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"));
+}
+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);
+    if (info.isSymbolicLink())
+      throw new Error(`Runtime packages cannot contain symlinks: ${path}`);
+    const mode = info.mode & 511;
+    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(root);
+}
+async function makePackageImmutable(root) {
+  const walk3 = async (path) => {
+    const info = await lstat4(path);
+    if (info.isSymbolicLink())
+      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 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/2",
+    requestId: crypto.randomUUID(),
+    publisherKeyId: identity.keyId,
+    publicKey: identity.publicKey,
+    displayName: identity.displayName,
+    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://hitslop.app/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/render.ts
+async function exportDocument(path, options, native = runNative) {
+  await validateRuntimePackage(path);
+  await native(["export", path, "--format", options.format, "--output", options.output]);
+}
+async function screenshotDocument(path, options, native = runNative) {
+  await validateRuntimePackage(path);
+  await native([
+    "screenshot",
+    path,
+    "--target",
+    options.target ?? "preview",
+    "--output",
+    options.output,
+    ...options.ifPresent ? ["--if-present"] : []
+  ]);
+}
+
+// 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()));
+async function initMetadata(directory, flags) {
+  const defaults = { title: flags.title || titleFor(directory), description: flags.description || "A small, lovable hitSlop app.", categories: parseCategories(flags.category?.length ? flags.category : ["utilities"]) };
+  if (flags.yes || !process.stdin.isTTY)
+    return defaults;
+  const prompt = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const title = (await prompt.question(`Title (${defaults.title}): `)).trim() || defaults.title;
+    const description = (await prompt.question(`Description (${defaults.description}): `)).trim() || defaults.description;
+    const rawCategories = (await prompt.question(`Categories, maximum 2 (${defaults.categories.join(", ")}): `)).trim();
+    const categories = rawCategories ? parseCategories(rawCategories.split(",").filter(Boolean)) : defaults.categories;
+    if (categories.length < 1 || categories.length > 2)
+      throw new Error("Choose one or two categories.");
+    return { title, description, categories };
+  } finally {
+    prompt.close();
+  }
+}
+async function confirmReplacement(target) {
+  if (!process.stdin.isTTY)
+    throw new Error(`Template already exists at ${target}. Pass --force to replace it non-interactively.`);
+  const prompt = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return ["y", "yes"].includes((await prompt.question(`Replace the installed template at ${target}? [y/N] `)).trim().toLowerCase());
+  } finally {
+    prompt.close();
+  }
+}
+var app = new Crust("slop").meta({ description: "Build small, self-contained hitSlop apps.", usage: "slop <command>" });
+app = app.command("init", (command) => command.meta({ description: "Create a Svelte hitSlop project and manifest." }).args([{ name: "directory", type: "path", default: "my-slop" }]).flags({
+  template: { type: "string", description: "Svelte authoring template (svelte or svelte-counter)." },
+  title: { type: "string", description: "Manifest title." },
+  description: { type: "string", description: "Manifest description." },
+  category: { type: "string", multiple: true, description: "Manifest category; pass once or twice." },
+  yes: { type: "boolean", description: "Accept manifest defaults without prompting." }
+}).run(async ({ args, flags }) => {
+  const metadata = await initMetadata(args.directory, flags);
+  await scaffold(args.directory, { template: flags.template ?? "svelte-counter", ...metadata });
+  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 manifest = runtime ? await validateRuntimePackage(args.path) : await validateAuthoringProject(args.path);
+  console.log(`valid	${manifest.slug}`);
+}));
+app = app.command("dev", (command) => command.meta({ description: "Preview the UI in a browser with disposable fake stores." }).args([{ name: "path", type: "path", default: "." }]).run(({ args }) => runDev(args.path)));
+app = app.command("build", (command) => command.args([{ name: "path", type: "path", default: "." }]).run(async ({ args }) => {
+  const result = await buildSlop(args.path);
+  console.log(result.directory);
+}));
+app = app.command("register", (command) => command.meta({ description: "Build and register a template in the local hitSlop catalog." }).args([{ name: "path", type: "path", default: "." }]).flags({
+  force: { type: "boolean", description: "Replace an existing local template without prompting." },
+  preview: { type: "path", description: "Use this PNG instead of capturing a fresh native preview." },
+  icon: { type: "path", description: "Use this 512x512 PNG as the catalog and Finder icon." }
+}).run(async ({ args, flags }) => {
+  const result = await installTemplate(args.path, { force: flags.force ?? false, ...flags.preview ? { preview: flags.preview } : {}, ...flags.icon ? { icon: flags.icon } : {}, confirmOverwrite: confirmReplacement });
+  console.log(`${result.replaced ? "Updated" : "Installed"} ${result.manifest.title} at ${result.directory}`);
+}));
+app = app.command("publish", (command) => command.args([{ name: "path", type: "path", default: "." }]).flags({ registry: { type: "string", description: "Catalog publish endpoint. Defaults to https://hitslop.app/api/publish. Set HITSLOP_REGISTRY_URL=http://localhost:3000/api/publish for a local catalog." }, preview: { type: "path" }, icon: { type: "path", description: "Use this 512x512 PNG as the catalog and Finder icon." } }).run(async ({ args, flags }) => {
+  console.log(await publishSlop(args.path, { ...flags.registry ? { registry: flags.registry } : {}, ...flags.preview ? { preview: flags.preview } : {}, ...flags.icon ? { icon: flags.icon } : {} }));
+}));
+app = app.command("export", (command) => command.meta({ description: "Export a built .slop document as a full-height PNG or PDF." }).args([{ name: "path", type: "path", default: "." }]).flags({
+  format: { type: "string", description: "Required output format: png or pdf." },
+  output: { type: "path", description: "Required destination path." }
+}).run(async ({ args, flags }) => {
+  if (flags.format !== "png" && flags.format !== "pdf")
+    throw new Error("--format must be png or pdf.");
+  if (!flags.output)
+    throw new Error("--output is required.");
+  await exportDocument(args.path, { format: flags.format, output: flags.output });
+}));
+app = app.command("screenshot", (command) => command.meta({ description: "Capture a built .slop preview or icon render target." }).args([{ name: "path", type: "path", default: "." }]).flags({
+  target: { type: "string", description: "Render target: preview (default) or icon." },
+  output: { type: "path", description: "Required destination path." },
+  "if-present": { type: "boolean", description: "Succeed without output when the target is absent." }
+}).run(async ({ args, flags }) => {
+  const target = flags.target ?? "preview";
+  if (target !== "preview" && target !== "icon")
+    throw new Error("--target must be preview or icon.");
+  if (!flags.output)
+    throw new Error("--output is required.");
+  await screenshotDocument(args.path, { target, output: flags.output, ifPresent: flags["if-present"] ?? false });
+}));
+async function secret(prompt) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY)
+    throw new Error("A TTY is required for identity passphrases.");
+  process.stdout.write(prompt);
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  return new Promise((resolve6, reject) => {
+    let value = "";
+    const onData = (chunk) => {
+      for (const byte of chunk) {
+        if (byte === 3) {
+          cleanup();
+          reject(new Error("Cancelled."));
+          return;
+        }
+        if (byte === 13 || byte === 10) {
+          cleanup();
+          process.stdout.write(`
+`);
+          resolve6(value);
+          return;
+        }
+        if (byte === 127 || byte === 8) {
+          value = value.slice(0, -1);
+          continue;
+        }
+        value += String.fromCharCode(byte);
+      }
+    };
+    const cleanup = () => {
+      process.stdin.off("data", onData);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    };
+    process.stdin.on("data", onData);
+  });
+}
+async function runIdentity(arguments_) {
+  if (arguments_[0] !== "identity")
+    return false;
+  const action = arguments_[1] ?? "show";
+  if (action === "show") {
+    const identity = await getIdentity();
+    console.log(`${identity.keyId}	${identity.displayName}`);
+    return true;
+  }
+  if (action === "set-name") {
+    const name = arguments_.slice(2).join(" ").trim();
+    if (!name)
+      throw new Error("Usage: slop identity set-name <name>");
+    const identity = await setIdentityName(name);
+    console.log(`${identity.keyId}	${identity.displayName}`);
+    return true;
+  }
+  if (action === "export") {
+    const path = arguments_[2];
+    if (!path)
+      throw new Error("Usage: slop identity export <file>");
+    const passphrase = await secret("Export passphrase: ");
+    const confirmation = await secret("Confirm passphrase: ");
+    if (passphrase !== confirmation)
+      throw new Error("Passphrases do not match.");
+    await exportIdentity(path, passphrase);
+    console.log(`Exported publisher identity to ${path}`);
+    return true;
+  }
+  if (action === "import") {
+    const path = arguments_[2];
+    if (!path)
+      throw new Error("Usage: slop identity import <file> [--force]");
+    const identity = await importIdentity(path, await secret("Import passphrase: "), arguments_.includes("--force"));
+    console.log(`${identity.keyId}	${identity.displayName}`);
+    return true;
+  }
+  throw new Error(`Unknown identity command: ${action}`);
+}
+if (!await runIdentity(process.argv.slice(2)))
+  await app.execute();