markswift 0.0.0-stage → 2.0.0

package/dist/cli.js

@@ -0,0 +1,637 @@
+#!/usr/bin/env node
+import {
+  mimeType,
+  convert2,
+  buildLibrary2
+} from "./cli-jdrbzqfa.js";
+import {
+  validateName,
+  VERSION,
+  validateLibrary2
+} from "./cli-qchh0m4d.js";
+
+// src/cli/args.ts
+class UsageError extends Error {
+}
+var HELP = `Markswift — convert rendered HTML and CSS to SwiftUI.
+
+Usage:
+  markswift convert <file.html|-> --out <directory> [options]
+  markswift convert --url <http(s)://...> --out <directory> [options]
+  markswift build [markswift.json] [--force]
+                    Build every component of the config into one Swift package
+                    (directory "out" of the config; replaces only files it wrote)
+  markswift --help | --version
+
+Inputs:
+  <file.html>       HTML document or fragment; relative assets use its directory
+  -                 Read HTML from stdin (inline/data assets only)
+  --url <url>       Capture a running HTTP or HTTPS page
+  --css <file>      Optional compiled CSS file
+
+Options:
+  --out <directory> Required. Must not exist yet, unless --update
+  --update          Regenerate into an existing --out written by Markswift: rewrites only the files
+                    listed in its .markswift.json, removes listed files no longer produced, never
+                    touches other files; refuses (exit 2) when a listed file was edited by hand
+  --force           With --update: overwrite hand-edited listed files
+  --name <Name>     Swift view name (default: ConvertedView)
+  --root <selector> Capture only this CSS selector
+  --width <px>      Viewport width (default: 390)
+  --height <px>     Viewport height (default: 844)
+  --theme <value>   adaptive, light or dark (default: adaptive). adaptive captures the page in
+                    light and dark (prefers-color-scheme) and emits one view that follows both
+  --dark-class <name>
+                    Class added to <html> for the dark capture (class-based themes, e.g. dark)
+  --mode <value>    app or fidelity (default: app)
+  --palette <file>  JSON map from CSS variables or hex colours to app colours
+                    (e.g. {"--primary": "Color.accentColor"})
+  --breakpoints <auto|W[xH],…>  Capture one layout per CSS width band (auto: 390, 834x1210, 1210x834, 1376x1032) and emit one view that switches at the CSS thresholds
+  -h, --help        Show this help
+  -v, --version     Show version
+
+Requires Node.js 20+ (or Bun 1.4.2+) and Google Chrome; webfonts need python3 with fontTools and brotli. CSS must already be compiled; JavaScript behavior is not translated.
+`;
+var valueFlags = new Set([
+  "--out",
+  "--url",
+  "--css",
+  "--name",
+  "--root",
+  "--width",
+  "--height",
+  "--theme",
+  "--dark-class",
+  "--mode",
+  "--palette",
+  "--breakpoints"
+]);
+function parseArgs(args) {
+  if (args.length === 0 || args.length === 1 && ["--help", "-h"].includes(args[0]))
+    return { kind: "help" };
+  if (args.length === 1 && ["--version", "-v"].includes(args[0]))
+    return { kind: "version" };
+  if (args[0] === "build")
+    return parseBuild(args.slice(1));
+  if (args[0] !== "convert")
+    throw new UsageError(`Unknown command: ${args[0]}`);
+  if (args.slice(1).some((arg) => arg === "--help" || arg === "-h"))
+    return { kind: "help" };
+  const values = new Map;
+  const flags = new Set;
+  const positional = [];
+  let afterDoubleDash = false;
+  for (let i = 1;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--" && !afterDoubleDash) {
+      afterDoubleDash = true;
+      continue;
+    }
+    if (!afterDoubleDash && (arg === "--update" || arg === "--force")) {
+      if (flags.has(arg))
+        throw new UsageError(`Repeated option: ${arg}`);
+      flags.add(arg);
+    } else if (!afterDoubleDash && valueFlags.has(arg)) {
+      if (values.has(arg))
+        throw new UsageError(`Repeated option: ${arg}`);
+      const value = args[++i];
+      if (!value || value.startsWith("--"))
+        throw new UsageError(`Missing value for ${arg}`);
+      values.set(arg, value);
+    } else if (!afterDoubleDash && arg.startsWith("-") && arg !== "-") {
+      throw new UsageError(`Unknown option: ${arg}`);
+    } else
+      positional.push(arg);
+  }
+  const outDir = values.get("--out");
+  if (!outDir)
+    throw new UsageError("--out is required");
+  if (flags.has("--force") && !flags.has("--update"))
+    throw new UsageError("--force only applies with --update");
+  const url = values.get("--url");
+  if (positional.length + (url ? 1 : 0) !== 1)
+    throw new UsageError("Choose exactly one HTML file, -, or --url");
+  if (url) {
+    try {
+      const parsed = new URL(url);
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+        throw new Error("unsupported protocol");
+    } catch {
+      throw new UsageError("--url requires an HTTP or HTTPS URL");
+    }
+  }
+  const source = url ? { url } : positional[0] === "-" ? { stdin: true } : { file: positional[0] };
+  const width = dimension(values.get("--width"), "--width", 390);
+  const height = dimension(values.get("--height"), "--height", 844);
+  const theme = values.get("--theme") ?? "adaptive";
+  const mode = values.get("--mode") ?? "app";
+  const name = values.get("--name");
+  if (name !== undefined) {
+    try {
+      validateName(name);
+    } catch (error) {
+      throw new UsageError(error instanceof Error ? error.message : String(error));
+    }
+  }
+  if (theme !== "light" && theme !== "dark" && theme !== "adaptive")
+    throw new UsageError("--theme must be adaptive, light or dark");
+  const darkClass = values.get("--dark-class");
+  if (darkClass !== undefined && !/^\S+$/.test(darkClass))
+    throw new UsageError("--dark-class must be a single class name");
+  if (mode !== "app" && mode !== "fidelity")
+    throw new UsageError("--mode must be app or fidelity");
+  const bands = values.get("--breakpoints");
+  const breakpoints = bands === undefined ? undefined : bands === "auto" ? true : {
+    devices: bands.split(",").map((device) => {
+      const m = /^(\d+)(?:x(\d+))?$/.exec(device);
+      const size = m && { width: Number(m[1]), height: m[2] === undefined ? height : Number(m[2]) };
+      if (!size || !(size.width > 0 && size.height > 0))
+        throw new UsageError("--breakpoints must be auto or a comma list of WIDTH or WIDTHxHEIGHT");
+      return size;
+    })
+  };
+  return {
+    kind: "convert",
+    source,
+    outDir,
+    cssPath: values.get("--css"),
+    palettePath: values.get("--palette"),
+    update: flags.has("--update"),
+    force: flags.has("--force"),
+    options: {
+      name,
+      root: values.get("--root"),
+      theme,
+      darkClass,
+      mode,
+      viewport: { width, height },
+      ...breakpoints ? { breakpoints } : {}
+    }
+  };
+}
+function parseBuild(args) {
+  if (args.some((arg) => arg === "--help" || arg === "-h"))
+    return { kind: "help" };
+  let force = false;
+  const positional = [];
+  for (const arg of args) {
+    if (arg === "--force") {
+      if (force)
+        throw new UsageError("Repeated option: --force");
+      force = true;
+    } else if (arg.startsWith("-"))
+      throw new UsageError(`Unknown option: ${arg}`);
+    else
+      positional.push(arg);
+  }
+  if (positional.length > 1)
+    throw new UsageError("Choose at most one config file");
+  return { kind: "build", configPath: positional[0] ?? "markswift.json", force };
+}
+function dimension(value, flag, fallback) {
+  if (value === undefined)
+    return fallback;
+  const parsed = Number(value);
+  if (!/^\d+$/.test(value) || !Number.isSafeInteger(parsed) || parsed <= 0)
+    throw new UsageError(`${flag} must be a positive integer`);
+  return parsed;
+}
+
+// src/cli/manifest.ts
+import { createHash } from "node:crypto";
+import { lstat, readFile } from "node:fs/promises";
+import { isAbsolute, join, win32 } from "node:path";
+var MANIFEST = ".markswift.json";
+
+class EditedFilesError extends Error {
+  files;
+  constructor(files, message) {
+    super(message);
+    this.files = files;
+  }
+}
+function unsafePath(name) {
+  return !name || isAbsolute(name) || win32.isAbsolute(name) || name.includes("\\") || name.split("/").some((part) => !part || part === "." || part === "..");
+}
+function manifestFor(files, version) {
+  const hashes = Object.entries(files).filter(([name]) => name !== MANIFEST).map(([name, contents]) => [name, createHash("sha256").update(contents).digest("hex")]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  return { tool: "markswift", version, files: Object.fromEntries(hashes) };
+}
+function serializeManifest(manifest) {
+  return `${JSON.stringify(manifest, null, 2)}
+`;
+}
+async function readManifest(dir) {
+  let text;
+  try {
+    text = await readFile(join(dir, MANIFEST), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    value = undefined;
+  }
+  const m = value;
+  const valid = typeof m === "object" && m !== null && m.tool === "markswift" && typeof m.version === "string" && typeof m.files === "object" && m.files !== null && !Array.isArray(m.files) && Object.entries(m.files).every(([name, hash]) => !unsafePath(name) && typeof hash === "string" && /^[0-9a-f]{64}$/.test(hash));
+  if (!valid)
+    throw new Error(`${dir}/${MANIFEST} is not a Markswift manifest`);
+  return m;
+}
+async function editedFiles(dir, manifest) {
+  const edited = [];
+  for (const name of Object.keys(manifest.files).sort()) {
+    const file = join(dir, name);
+    let stats;
+    try {
+      stats = await lstat(file);
+    } catch (error) {
+      if (error.code === "ENOENT")
+        continue;
+      throw error;
+    }
+    if (!stats.isFile() || createHash("sha256").update(await readFile(file)).digest("hex") !== manifest.files[name])
+      edited.push(name);
+  }
+  return edited;
+}
+
+// src/cli/run.ts
+import { access as access2, readFile as readFile4 } from "node:fs/promises";
+import { text } from "node:stream/consumers";
+
+// src/cli/config.ts
+import { access, readFile as readFile3 } from "node:fs/promises";
+import { dirname as dirname2, resolve as resolve2 } from "node:path";
+import { z } from "zod";
+
+// src/cli/css.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+async function inlineRelativeUrls(css, cssPath) {
+  const dir = dirname(resolve(cssPath));
+  const missing = [];
+  const pattern = /url\(\s*(?:"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|([^)]*))\s*\)/g;
+  const inlined = [];
+  for (const match of css.matchAll(pattern)) {
+    const ref = (match[1] ?? match[2] ?? match[3] ?? "").trim();
+    if (!ref || ref.startsWith("#") || ref.startsWith("/") || /^[a-z][a-z0-9+.-]*:/i.test(ref)) {
+      inlined.push(match[0]);
+      continue;
+    }
+    const name = ref.replace(/[?#].*$/, "");
+    let bytes;
+    try {
+      bytes = await readFile2(resolve(dir, decodeURIComponent(name)));
+    } catch {
+      missing.push(ref);
+      inlined.push(match[0]);
+      continue;
+    }
+    inlined.push(`url("data:${mimeType(name)};base64,${bytes.toString("base64")}")`);
+  }
+  let i = 0;
+  return { css: css.replace(pattern, () => inlined[i++]), missing };
+}
+
+// src/cli/config.ts
+var Viewport = z.object({ width: z.number().int().positive(), height: z.number().int().positive() }).strict();
+var Shared = {
+  root: z.string().min(1).optional(),
+  viewport: Viewport.optional(),
+  theme: z.enum(["adaptive", "light", "dark"]).optional(),
+  darkClass: z.string().regex(/^\S+$/).optional(),
+  mode: z.enum(["app", "fidelity"]).optional(),
+  css: z.string().min(1).optional(),
+  waitFor: z.string().min(1).optional(),
+  breakpoints: z.union([
+    z.boolean(),
+    z.object({ devices: z.array(Viewport).min(1).optional(), max: z.number().int().min(320).optional() }).strict()
+  ]).optional()
+};
+var BuildConfig = z.object({
+  library: z.string(),
+  out: z.string().min(1),
+  serve: z.string().min(1).optional(),
+  timeoutMs: z.number().positive().optional(),
+  palette: z.string().min(1).optional(),
+  ...Shared,
+  components: z.array(z.object({ name: z.string(), source: z.string().min(1), ...Shared }).strict()).min(1)
+}).strict();
+var PaletteMapFile = z.record(z.string().regex(/^(--[A-Za-z0-9_-]+|#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?(\/#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?)?)$/, "key must be --name, #rrggbb[aa] or #light/#dark"), z.string().min(1).refine((v) => !/[\r\n\u2028\u2029]/.test(v), "value must be a single-line Swift expression"));
+async function loadPalette(path) {
+  const text = await readFile3(path, "utf8").catch(() => {
+    return;
+  });
+  if (text === undefined)
+    throw new Error(`palette map not found: ${path}`);
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch (error) {
+    throw new UsageError(`${path} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const parsed = PaletteMapFile.safeParse(json);
+  if (!parsed.success)
+    throw new UsageError(`Invalid palette map ${path}:
+${parsed.error.issues.map((i) => `  ${i.path.join(".") || "(top level)"}: ${i.code === "invalid_key" ? i.issues[0]?.message : i.message}`).join(`
+`)}`);
+  return parsed.data;
+}
+async function loadBuildConfig(path) {
+  const text = await readFile3(path, "utf8").catch(() => {
+    return;
+  });
+  if (text === undefined)
+    throw new Error(`Config file not found: ${path}`);
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch (error) {
+    throw new UsageError(`${path} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const parsed = BuildConfig.safeParse(json);
+  if (!parsed.success)
+    throw new UsageError(`Invalid config ${path}:
+${parsed.error.issues.map((i) => `  ${i.path.join(".") || "(top level)"}: ${i.message}`).join(`
+`)}`);
+  const config = parsed.data;
+  try {
+    validateLibrary2(config.library, config.components.map((c) => c.name));
+  } catch (error) {
+    throw new UsageError(`Invalid config ${path}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const base = dirname2(resolve2(path));
+  const warnings = [];
+  const readCss = async (file, component) => {
+    const cssPath = resolve2(base, file);
+    const cssText = await readFile3(cssPath, "utf8").catch(() => {
+      return;
+    });
+    if (cssText === undefined)
+      throw new Error(`CSS file not found: ${cssPath}`);
+    const inlined = await inlineRelativeUrls(cssText, cssPath);
+    for (const ref of inlined.missing)
+      warnings.push({
+        source: "build",
+        message: `--css reference not found next to ${cssPath}: ${ref}`,
+        ...component ? { component } : {}
+      });
+    return inlined.css;
+  };
+  const sharedCss = config.css === undefined ? undefined : await readCss(config.css);
+  const components = [];
+  for (const c of config.components) {
+    const isURL = URL.canParse(c.source) && ["http:", "https:"].includes(new URL(c.source).protocol);
+    const file = resolve2(base, c.source);
+    if (!isURL && !await access(file).then(() => true, () => false))
+      throw new Error(`component ${c.name}: HTML file not found: ${file}`);
+    const pick = (key) => c[key] ?? config[key];
+    components.push({
+      name: c.name,
+      source: isURL ? { url: c.source } : { file },
+      root: pick("root"),
+      viewport: pick("viewport"),
+      theme: pick("theme"),
+      darkClass: pick("darkClass"),
+      mode: pick("mode"),
+      css: c.css === undefined ? sharedCss : await readCss(c.css, c.name),
+      waitFor: pick("waitFor"),
+      breakpoints: pick("breakpoints") || undefined
+    });
+  }
+  return {
+    out: resolve2(base, config.out),
+    options: {
+      library: config.library,
+      components,
+      serveRoot: resolve2(base, config.serve ?? "."),
+      timeoutMs: config.timeoutMs,
+      palette: config.palette === undefined ? undefined : await loadPalette(resolve2(base, config.palette))
+    },
+    warnings
+  };
+}
+
+// src/cli/output.ts
+import { lstat as lstat2, mkdir, rename, rm, rmdir, writeFile } from "node:fs/promises";
+import { dirname as dirname3, join as join2, resolve as resolve3 } from "node:path";
+async function ensureVacant(directory) {
+  try {
+    await lstat2(directory);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  throw new Error(`Output directory already exists: ${directory} (use --update to regenerate a Markswift output)`);
+}
+function checkPaths(entries) {
+  const folded = new Set;
+  for (const [name] of entries) {
+    if (unsafePath(name))
+      throw new Error(`Unsafe output path: ${name}`);
+    if (folded.has(name.toLowerCase()))
+      throw new Error(`Duplicate output path: ${name}`);
+    folded.add(name.toLowerCase());
+  }
+}
+async function updatable(directory, force = false) {
+  const output = resolve3(directory);
+  try {
+    await lstat2(output);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  const manifest = await readManifest(output);
+  if (!manifest)
+    throw new Error(`${output} exists but has no ${MANIFEST}; --update only rewrites directories Markswift wrote. Convert into a new --out or move this directory away.`);
+  const edited = await editedFiles(output, manifest);
+  if (edited.length && !force)
+    throw new EditedFilesError(edited, `Refusing to overwrite hand-edited files in ${output}: ${edited.join(", ")}. Move your changes into your own files (Markswift never touches files it did not write) or rerun with --force to discard them.`);
+  return manifest;
+}
+async function writeBundle(result, directory, options) {
+  const entries = [...Object.entries(result.files), ...Object.entries(result.assets)];
+  checkPaths(entries);
+  const output = resolve3(directory);
+  await ensureVacant(output);
+  await mkdir(dirname3(output), { recursive: true });
+  try {
+    await mkdir(output);
+  } catch (error) {
+    if (error.code === "EEXIST")
+      throw new Error(`Output directory already exists: ${output}`);
+    throw error;
+  }
+  try {
+    for (const [name, contents] of entries) {
+      const file = join2(output, name);
+      await mkdir(dirname3(file), { recursive: true });
+      await writeFile(file, contents);
+    }
+    await writeFile(join2(output, MANIFEST), serializeManifest(manifestFor(Object.fromEntries(entries), options.version)));
+  } catch (error) {
+    await rm(output, { recursive: true, force: true });
+    throw error;
+  }
+  return entries.map(([name]) => name).sort();
+}
+async function updateBundle(result, directory, options) {
+  const entries = [...Object.entries(result.files), ...Object.entries(result.assets)];
+  checkPaths(entries);
+  const output = resolve3(directory);
+  const old = await updatable(output, options.force);
+  if (!old)
+    return writeBundle(result, output, options);
+  const fresh = new Set(entries.map(([name]) => name));
+  const stale = Object.keys(old.files).filter((name) => !fresh.has(name));
+  const unlisted = [];
+  for (const name of [...fresh].sort()) {
+    if (Object.hasOwn(old.files, name))
+      continue;
+    try {
+      await lstat2(join2(output, name));
+      unlisted.push(name);
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+  }
+  if (unlisted.length)
+    throw new EditedFilesError(unlisted, `Refusing to overwrite files Markswift did not write in ${output}: ${unlisted.join(", ")}. Rename or move them.`);
+  for (const [name, contents] of entries) {
+    const file = join2(output, name);
+    await mkdir(dirname3(file), { recursive: true });
+    await writeFile(file, contents);
+  }
+  for (const name of stale) {
+    await rm(join2(output, name), { force: true });
+    for (let parent = dirname3(name);parent !== "."; parent = dirname3(parent)) {
+      try {
+        await rmdir(join2(output, parent));
+      } catch (error) {
+        const code = error.code;
+        if (code === "ENOTEMPTY" || code === "ENOENT")
+          break;
+        throw error;
+      }
+    }
+  }
+  const tmp = join2(output, `${MANIFEST}.tmp`);
+  await writeFile(tmp, serializeManifest(manifestFor(Object.fromEntries(entries), options.version)));
+  await rename(tmp, join2(output, MANIFEST));
+  return [...fresh].sort();
+}
+function formatWarning(w) {
+  const loss = w.level && w.feature ? `${w.level} ${w.feature}: ` : "";
+  return `${w.component ? `[${w.component}] ` : ""}${loss}${w.message}`;
+}
+function formatDiagnostics(report) {
+  const groups = new Map;
+  for (const node of report) {
+    for (const d of node.diagnostics) {
+      const key = `${d.level}\x00${d.feature}\x00${d.message}`;
+      const group = groups.get(key) ?? { d, ids: [] };
+      group.ids.push(node.id || node.kind);
+      groups.set(key, group);
+    }
+  }
+  return [...groups.values()].sort((a, b) => Number(b.d.level === "unmapped") - Number(a.d.level === "unmapped") || a.d.feature.localeCompare(b.d.feature)).map(({ d, ids }) => `${d.level} ${d.feature}: ${d.message} [${ids.length} node${ids.length === 1 ? "" : "s"}: ${ids.slice(0, 5).join(", ")}${ids.length > 5 ? ", …" : ""}]`);
+}
+
+// src/cli/run.ts
+async function runBuild(command) {
+  const config = await loadBuildConfig(command.configPath);
+  await updatable(config.out, command.force);
+  const result = await buildLibrary2(config.options);
+  const files = await updateBundle(result, config.out, { version: VERSION, force: command.force });
+  process.stdout.write(`Wrote ${files.length} files for ${config.options.library} (${config.options.components.length} components) to ${config.out}
+`);
+  for (const warning of [...config.warnings, ...result.warnings])
+    process.stderr.write(`Warning: ${formatWarning(warning)}
+`);
+  for (const [component, report] of Object.entries(result.diagnostics))
+    for (const line of formatDiagnostics(report))
+      process.stderr.write(`Note [${component}] ${line}
+`);
+}
+async function runConversion(command) {
+  if (command.update)
+    await updatable(command.outDir, command.force);
+  else
+    await ensureVacant(command.outDir);
+  if ("file" in command.source && !await access2(command.source.file).then(() => true, () => false)) {
+    throw new Error(`HTML file not found: ${command.source.file}`);
+  }
+  const source = "stdin" in command.source ? { html: await text(process.stdin) } : command.source;
+  let css;
+  if (command.cssPath) {
+    const cssText = await readFile4(command.cssPath, "utf8").catch(() => {
+      return;
+    });
+    if (cssText === undefined)
+      throw new Error(`CSS file not found: ${command.cssPath} (--css is optional)`);
+    const inlined = await inlineRelativeUrls(cssText, command.cssPath);
+    css = inlined.css;
+    for (const ref of inlined.missing)
+      process.stderr.write(`Warning: --css reference not found next to ${command.cssPath}: ${ref}
+`);
+  }
+  const palette = command.palettePath === undefined ? undefined : await loadPalette(command.palettePath);
+  const result = await convert2(source, { ...command.options, css, palette });
+  const files = command.update ? await updateBundle(result, command.outDir, { version: VERSION, force: command.force }) : await writeBundle(result, command.outDir, { version: VERSION });
+  process.stdout.write(command.update ? `Updated ${files.length} files for ${result.name} in ${command.outDir}
+` : `Wrote ${files.length} files for ${result.name} to ${command.outDir}
+`);
+  for (const warning of result.warnings)
+    process.stderr.write(`Warning: ${formatWarning(warning)}
+`);
+  for (const line of formatDiagnostics(result.diagnostics))
+    process.stderr.write(`Note ${line}
+`);
+}
+
+// src/cli.ts
+async function main() {
+  try {
+    const command = parseArgs(process.argv.slice(2));
+    if (command.kind === "help") {
+      process.stdout.write(HELP);
+      return 0;
+    }
+    if (command.kind === "version") {
+      process.stdout.write(`${VERSION}
+`);
+      return 0;
+    }
+    if (command.kind === "build")
+      await runBuild(command);
+    else
+      await runConversion(command);
+    return 0;
+  } catch (error) {
+    if (error instanceof UsageError) {
+      const help = process.argv[2] === "build" ? "build" : "convert";
+      process.stderr.write(`${error.message}
+Run markswift ${help} --help for usage.
+`);
+      return 2;
+    }
+    if (error instanceof EditedFilesError) {
+      process.stderr.write(`${error.message}
+`);
+      return 2;
+    }
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    return 1;
+  }
+}
+process.exitCode = await main();

package/dist/compiler/index.js

@@ -0,0 +1,20 @@
+import {
+  BAND_MIN2,
+  BAND_CAP2,
+  DEFAULT_BAND_DEVICES2,
+  planBands2,
+  compileLayout2,
+  needsProbe2,
+  validateLibrary2,
+  compileLayouts2
+} from "../cli-qchh0m4d.js";
+export {
+  BAND_CAP2 as BAND_CAP,
+  BAND_MIN2 as BAND_MIN,
+  DEFAULT_BAND_DEVICES2 as DEFAULT_BAND_DEVICES,
+  compileLayout2 as compileLayout,
+  compileLayouts2 as compileLayouts,
+  needsProbe2 as needsProbe,
+  planBands2 as planBands,
+  validateLibrary2 as validateLibrary
+};

package/dist/index.js

@@ -0,0 +1,22 @@
+import {
+  convert2,
+  convertHtml2,
+  buildLibrary2
+} from "./cli-jdrbzqfa.js";
+import {
+  HTML_ELEMENTS2,
+  INPUT_CONTROLS2,
+  classifyElement2,
+  compileLayout2,
+  compileLayouts2
+} from "./cli-qchh0m4d.js";
+export {
+  HTML_ELEMENTS2 as HTML_ELEMENTS,
+  INPUT_CONTROLS2 as INPUT_CONTROLS,
+  buildLibrary2 as buildLibrary,
+  classifyElement2 as classifyElement,
+  compileLayout2 as compileLayout,
+  compileLayouts2 as compileLayouts,
+  convert2 as convert,
+  convertHtml2 as convertHtml
+};

package/dist/types/analysis/alignment.d.ts

@@ -0,0 +1,12 @@
+/** CSS flex alignment and distribution mapped to semantic axes, in visual terms (start = left/top). */
+import type { LayoutNode } from "../model/layout.ts";
+import type { CrossAlign, Distribution } from "../model/semantic.ts";
+export declare function crossAlign(n: LayoutNode): CrossAlign;
+/** A flex item's own `align-self`, resolved like `align-items`; undefined for `auto` (follow the container). */
+export declare function alignSelfOf(child: LayoutNode, container: LayoutNode): CrossAlign | undefined;
+/**
+ * Main-axis packing in *visual* terms (children are ordered by measured position: start =
+ * left/top). flex-start/flex-end follow the flex direction, start/end the writing direction,
+ * left/right are physical (start in a column) — all verified against Chrome.
+ */
+export declare function distributionOf(n: LayoutNode): Distribution;