@vinena/vectoys-cli 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1133 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { resolve as resolve6 } from "node:path";
+// package.json
+var version = "0.1.0";
+
+// src/args.ts
+var VALUES = new Map([
+  ["--registry", "registry"],
+  ["--cwd", "cwd"],
+  ["--dir", "dir"]
+]);
+function parseArgs(argv) {
+  const flags = {
+    help: false,
+    version: false,
+    yes: false,
+    overwrite: false,
+    install: true,
+    open: false,
+    dryRun: false,
+    registry: undefined,
+    cwd: undefined,
+    dir: undefined
+  };
+  const positional = [];
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    const [name, inline] = arg.startsWith("--") && arg.includes("=") ? [arg.slice(0, arg.indexOf("=")), arg.slice(arg.indexOf("=") + 1)] : [arg, undefined];
+    const key = VALUES.get(name);
+    if (key) {
+      const value = inline ?? argv[++i];
+      if (!value)
+        throw new Error(`${name} needs a value.`);
+      flags[key] = value;
+    } else if (name === "-h" || name === "--help")
+      flags.help = true;
+    else if (name === "-v" || name === "--version")
+      flags.version = true;
+    else if (name === "-y" || name === "--yes")
+      flags.yes = true;
+    else if (name === "-o" || name === "--overwrite")
+      flags.overwrite = true;
+    else if (name === "--no-install")
+      flags.install = false;
+    else if (name === "--open")
+      flags.open = true;
+    else if (name === "--dry-run")
+      flags.dryRun = true;
+    else if (name.startsWith("-"))
+      throw new Error(`Unknown option ${name}. Run "vectoys --help" to see the options.`);
+    else
+      positional.push(arg);
+  }
+  return { command: positional[0], rest: positional.slice(1), flags };
+}
+
+// src/check.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync5, lstatSync, mkdtempSync, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, extname, join as join5, relative as relative3, resolve as resolve3, sep as sep3 } from "node:path";
+
+// ../registry-build/src/index.ts
+function checkItem(value, file) {
+  const item = value;
+  for (const key of ["name", "title", "description", "license"]) {
+    if (typeof item[key] !== "string" || item[key] === "")
+      throw new Error(`${file} needs a "${key}"`);
+  }
+  if (!Array.isArray(item.files) || item.files.length === 0)
+    throw new Error(`${file} needs "files"`);
+  return item;
+}
+
+// src/commands.ts
+import { spawnSync } from "node:child_process";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname, relative, resolve, sep } from "node:path";
+
+// src/config.ts
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var CONFIG_FILE = "vectoys.json";
+var DEFAULT_REGISTRY = "https://vectoys.com/r";
+function defaults(cwd, registry = DEFAULT_REGISTRY) {
+  const dir = existsSync(join(cwd, "src")) ? "src/components/vectoys" : "components/vectoys";
+  return { dir, registry, registries: {} };
+}
+function readConfig(cwd) {
+  const path = join(cwd, CONFIG_FILE);
+  if (!existsSync(path))
+    return;
+  let value;
+  try {
+    value = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    throw new Error(`${CONFIG_FILE} is not valid JSON. Fix it or delete it and run "vectoys init".`);
+  }
+  const fallback = defaults(cwd);
+  return {
+    dir: typeof value.dir === "string" ? value.dir : fallback.dir,
+    registry: typeof value.registry === "string" ? value.registry : fallback.registry,
+    registries: value.registries && typeof value.registries === "object" ? value.registries : {}
+  };
+}
+function writeConfig(cwd, config) {
+  writeFileSync(join(cwd, CONFIG_FILE), `${JSON.stringify(config, null, 2)}
+`);
+}
+
+// src/fetch.ts
+async function fetchJson(url) {
+  let response;
+  try {
+    response = await fetch(url);
+  } catch (error) {
+    const cause = error.cause?.message ?? error.message;
+    throw new Error(`Could not reach ${url}: ${cause}`);
+  }
+  if (!response.ok)
+    throw new Error(`${url} answered ${response.status}${response.status === 404 ? ", no such item" : ""}.`);
+  try {
+    return await response.json();
+  } catch {
+    throw new Error(`${url} did not return JSON.`);
+  }
+}
+
+// src/files.ts
+import { posix } from "node:path";
+function place(given) {
+  const files = given.map((file) => ({ ...file, path: posix.normalize(file.path.replace(/\\/g, "/")) }));
+  const root = shared(files.map((file) => posix.dirname(file.path)));
+  return files.map((file) => {
+    const to = posix.relative(root, file.path);
+    if (to.startsWith("../") || posix.isAbsolute(to))
+      throw new Error(`"${file.path}" would land outside the item's folder.`);
+    return { from: file.path, to, content: file.content };
+  });
+}
+function shared(dirs) {
+  const parts = dirs.map((dir) => dir === "." ? [] : dir.split("/"));
+  const first = parts[0] ?? [];
+  let length = 0;
+  while (length < first.length && parts.every((part) => part[length] === first[length]))
+    length++;
+  return first.slice(0, length).join("/") || ".";
+}
+
+// src/pm.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+var LOCKFILES = [
+  ["bun.lock", "bun"],
+  ["bun.lockb", "bun"],
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["package-lock.json", "npm"]
+];
+var SPEC = /^(@[a-z0-9][\w.-]*\/)?[a-z0-9][\w.-]*(@[\w.^~*+-]+)?$/i;
+function isPackageSpec(value) {
+  return typeof value === "string" && SPEC.test(value);
+}
+function detect(cwd) {
+  return LOCKFILES.find(([file]) => existsSync2(join2(cwd, file)))?.[1] ?? "npm";
+}
+function installCommand(pm, packages) {
+  return [pm, [pm === "npm" ? "install" : "add", ...packages]];
+}
+function missing(cwd, wanted) {
+  const path = join2(cwd, "package.json");
+  if (!existsSync2(path))
+    return wanted;
+  const pkg = JSON.parse(readFileSync2(path, "utf8"));
+  const have = new Set(["dependencies", "devDependencies", "peerDependencies"].flatMap((field) => Object.keys(pkg[field] ?? {})));
+  return wanted.filter((spec) => !have.has(packageName(spec)));
+}
+function packageName(spec) {
+  const at = spec.indexOf("@", 1);
+  return at === -1 ? spec : spec.slice(0, at);
+}
+
+// src/prompt.ts
+import { createInterface } from "node:readline";
+function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`${question} (y/N) `, (answer) => {
+      rl.close();
+      resolve(/^y(es)?$/i.test(answer.trim()));
+    });
+  });
+}
+
+// src/resolve.ts
+function itemUrl(spec, config, registry = config.registry) {
+  if (/^https?:\/\//.test(spec))
+    return spec;
+  const scoped = /^(@[^/]+)\/(.+)$/.exec(spec);
+  if (scoped)
+    return join3(registryFor(scoped[1], config), scoped[2]);
+  if (!/^[\w.-]+$/.test(spec))
+    throw new Error(`"${spec}" is not an item name, an @scope/name or a URL.`);
+  return join3(registry, spec);
+}
+function indexUrl(scope, config, registry = config.registry) {
+  return join3(scope ? registryFor(scope, config) : registry, "index");
+}
+function registryFor(scope, config) {
+  const registry = config.registries[scope];
+  if (!registry) {
+    throw new Error(`No registry is set for ${scope}. Add it to "registries" in vectoys.json, as { "${scope}": "https://example.com/r" }.`);
+  }
+  return registry;
+}
+function join3(registry, name) {
+  if (registry.includes("{name}"))
+    return registry.replace("{name}", name);
+  return `${registry.replace(/\/+$/, "")}/${name}.json`;
+}
+
+// src/commands.ts
+var ITEM_NAME = /^(?!\.{1,2}$)[\w.-]+$/;
+function init(context) {
+  const found = readConfig(context.cwd);
+  if (found) {
+    context.log(`${CONFIG_FILE} is already here. Items go to ${found.dir}.`);
+    return found;
+  }
+  const config = defaults(context.cwd, context.registryFlag ?? DEFAULT_REGISTRY);
+  writeConfig(context.cwd, config);
+  context.log(`Wrote ${CONFIG_FILE}. Items go to ${config.dir}, from ${config.registry}.`);
+  context.log(`Packages install with ${detect(context.cwd)}.`);
+  return config;
+}
+async function add(context, specs) {
+  if (specs.length === 0)
+    throw new Error('Name an item to add, as "vectoys add phone". Run "vectoys list" to see them.');
+  const found = readConfig(context.cwd);
+  const config = found ?? defaults(context.cwd, context.registryFlag ?? DEFAULT_REGISTRY);
+  const items = await Promise.all(specs.map(async (spec) => {
+    const url = itemUrl(spec, config, context.registry);
+    return { url, item: check(await fetchJson(url), url) };
+  }));
+  const root = resolve(context.cwd, config.dir);
+  const writes = items.flatMap(({ url, item }) => {
+    const folder = resolve(root, item.name);
+    return place(item.files).map((file) => {
+      const path = resolve(folder, file.to);
+      if (!folder.startsWith(root + sep) || !path.startsWith(folder + sep))
+        throw new Error(`${url} has a file that would land outside ${config.dir}.`);
+      return { path, content: file.content };
+    });
+  });
+  if (!found)
+    init(context);
+  for (const { path, content } of writes)
+    await write(context, path, content);
+  for (const { item } of items)
+    if (item.docs)
+      context.log(item.docs);
+  installMissing(context, [...new Set(items.flatMap(({ item }) => item.dependencies ?? []))]);
+}
+async function list(context, scope) {
+  const config = readConfig(context.cwd) ?? defaults(context.cwd);
+  const url = scope && /^https?:\/\//.test(scope) ? indexUrl(undefined, config, scope) : indexUrl(scope, config, scope ? undefined : context.registry);
+  const index = await fetchJson(url);
+  if (!Array.isArray(index.items) || index.items.length === 0) {
+    context.log(`${url} lists no items.`);
+    return;
+  }
+  const width = Math.max(...index.items.map((item) => item.name.length));
+  const prefix = scope?.startsWith("@") ? `${scope}/` : "";
+  for (const item of index.items) {
+    const license = item.license ? ` (license: ${item.license})` : "";
+    context.log(`${(prefix + item.name).padEnd(width + prefix.length)}  ${item.title ?? ""}${license}`);
+  }
+}
+function check(value, url) {
+  const item = value;
+  const fine = typeof item.name === "string" && ITEM_NAME.test(item.name) && Array.isArray(item.files) && item.files.every((file) => typeof file?.path === "string" && typeof file.content === "string");
+  if (!fine)
+    throw new Error(`${url} is not a registry item with a name and files that have content.`);
+  if (item.dependencies !== undefined && !(Array.isArray(item.dependencies) && item.dependencies.every(isPackageSpec))) {
+    throw new Error(`${url} lists dependencies that are not plain npm package names.`);
+  }
+  return item;
+}
+async function write(context, path, content) {
+  const shown = relative(context.cwd, path);
+  if (existsSync3(path)) {
+    if (readFileSync3(path, "utf8") === content) {
+      context.log(`Same     ${shown}`);
+      return;
+    }
+    const replace = context.overwrite || context.yes || process.stdin.isTTY && await confirm(`${shown} is already there. Replace it?`);
+    if (!replace) {
+      context.log(`Kept     ${shown} (pass --overwrite to replace it)`);
+      return;
+    }
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync2(path, content);
+  context.log(`Wrote    ${shown}`);
+}
+function installMissing(context, dependencies) {
+  const needed = missing(context.cwd, dependencies);
+  if (needed.length === 0)
+    return;
+  const [command, args] = installCommand(detect(context.cwd), needed);
+  const line = [command, ...args].join(" ");
+  if (!context.install) {
+    context.log(`Install what the items need with: ${line}`);
+    return;
+  }
+  context.log(`Running  ${line}`);
+  const windows = process.platform === "win32";
+  const result = spawnSync(command, windows ? args.map((arg) => `"${arg}"`) : args, { cwd: context.cwd, stdio: "inherit", shell: windows });
+  if (result.status !== 0)
+    throw new Error(`"${line}" failed. Run it yourself to see why.`);
+}
+
+// src/create.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join4, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+// ../../package.json
+var devDependencies = {
+  "@happy-dom/global-registrator": "20.14.5",
+  "@types/bun": "1.3.14",
+  typescript: "7.0.2"
+};
+
+// ../../tsconfig.base.json
+var compilerOptions = {
+  target: "ES2022",
+  lib: ["ES2022", "DOM"],
+  module: "ESNext",
+  moduleResolution: "bundler",
+  strict: true,
+  noUncheckedIndexedAccess: true,
+  exactOptionalPropertyTypes: true,
+  verbatimModuleSyntax: true,
+  isolatedModules: true,
+  rewriteRelativeImportExtensions: true,
+  skipLibCheck: true,
+  noEmit: true,
+  types: ["bun"],
+  paths: {
+    "@vinena/vectoys": ["./packages/engine/src/index.ts"],
+    "@vinena/vectoys-react": ["./packages/react/src/index.ts"]
+  }
+};
+
+// src/create.ts
+var BASE_TSCONFIG = "../../tsconfig.base.json";
+function itemTsconfig(inRepo) {
+  const include = ["src", "test"];
+  if (inRepo)
+    return { extends: BASE_TSCONFIG, compilerOptions: { jsx: "react-jsx" }, include };
+  const { paths, rewriteRelativeImportExtensions, ...own } = compilerOptions;
+  return { compilerOptions: { ...own, jsx: "react-jsx" }, include };
+}
+function inVectoysRepo(folder) {
+  for (let dir = dirname2(folder);; dir = dirname2(dir)) {
+    const pkg = join4(dir, "package.json");
+    if (existsSync4(pkg) && existsSync4(join4(dir, "registry"))) {
+      const value = JSON.parse(readFileSync4(pkg, "utf8"));
+      const named = typeof value === "object" && value !== null && "name" in value && value.name === "vectoys-workspace";
+      if (named)
+        return folder.startsWith(join4(dir, "registry") + sep2);
+    }
+    if (dirname2(dir) === dir)
+      return false;
+  }
+}
+function componentName(name) {
+  const joined = name.split(/[^a-zA-Z0-9]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  return /^[A-Za-z]/.test(joined) ? joined : `Item${joined}`;
+}
+function titleOf(name) {
+  const words = name.replace(/[-_.]+/g, " ").trim() || "item";
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function gitAuthor(cwd) {
+  const result = spawnSync2("git", ["config", "user.name"], { cwd, encoding: "utf8" });
+  return result.status === 0 ? result.stdout.trim() || undefined : undefined;
+}
+function scaffold(name, author, inRepo = false) {
+  const component = componentName(name);
+  const title = titleOf(name);
+  const item = {
+    name,
+    title,
+    description: `${title}: a tilted slab drawn as SVG paths. Say what it is and what it does.`,
+    files: ["src/geometry.ts", `src/${name}.tsx`],
+    dependencies: ["@vinena/vectoys", "@vinena/vectoys-react"],
+    license: "MIT",
+    ...author ? { author } : {}
+  };
+  const vectoys = inRepo ? "workspace:*" : `^${version}`;
+  const pkg = {
+    name: `@vectoys/${name}`,
+    version: "0.0.0",
+    private: true,
+    description: `${title} drawn with the vectoys engine.`,
+    type: "module",
+    sideEffects: false,
+    exports: { ".": "./src/index.ts" },
+    scripts: { typecheck: "tsc --noEmit", test: "bun test" },
+    dependencies: { "@vinena/vectoys": vectoys, "@vinena/vectoys-react": vectoys },
+    peerDependencies: { react: ">=19" },
+    devDependencies: {
+      ...inRepo ? {} : { "@types/bun": devDependencies["@types/bun"] },
+      "@types/react": "19.0.0",
+      "@types/react-dom": "19.0.0",
+      react: "19.0.0",
+      "react-dom": "19.0.0"
+    }
+  };
+  const tsconfig = itemTsconfig(inRepo);
+  const json = (value) => `${JSON.stringify(value, null, 2)}
+`;
+  return {
+    "item.json": json(item),
+    ".gitignore": `preview.html
+`,
+    "package.json": json(pkg),
+    "tsconfig.json": json(tsconfig),
+    "src/geometry.ts": `import { camera, draw, plate, rotateX, slab, type Part, type Pose } from "@vinena/vectoys";
+
+// A slab 60 by 40 scene units and 4 deep, with a plate on its face. In the
+// slab's own plane x runs across from its middle, y down from its middle and
+// z out of its face. Change the parts to make the item yours.
+export const WIDTH = 60;
+export const HEIGHT = 40;
+export const THICKNESS = 4;
+const INSET = 6;
+
+/** How the slab turns towards the eye at rest, in degrees. */
+export const TILT = { yaw: -24, pitch: -16 } as const;
+
+function parts(pose: Pose): Part[] {
+  return [
+    slab({
+      name: "body",
+      box: [-WIDTH / 2, -HEIGHT / 2, WIDTH / 2, HEIGHT / 2],
+      radii: [4, 4],
+      thickness: THICKNESS,
+      edge: 1,
+      pose,
+      children: [plate({ name: "face", box: [-WIDTH / 2 + INSET, -HEIGHT / 2 + INSET, WIDTH / 2 - INSET, HEIGHT / 2 - INSET], radii: [2, 2], role: "face" })],
+    }),
+  ];
+}
+
+/** The slab as the eye sees it, turned by \`yaw\` and \`pitch\`: the camera and the parts drawn. */
+export function seen(yaw: number = TILT.yaw, pitch: number = TILT.pitch) {
+  const eye = camera({ width: 100, height: 80, perspective: 280, yaw, pitch });
+  // Upright, the slab's face looks at the eye.
+  const pose: Pose = { position: [0, THICKNESS / 2, 0], rotation: rotateX(-90) };
+  return { camera: eye, drawn: draw(parts(pose), eye) };
+}
+
+export type View = ReturnType<typeof seen>;
+`,
+    [`src/${name}.tsx`]: `import { Faces, Stage, type Look, type StyleWithVariables } from "@vinena/vectoys-react";
+import { useMemo, type CSSProperties } from "react";
+import { TILT, seen } from "./geometry";
+
+// The page's colours, as CSS variables, each with a tone so the item shows as
+// meant before they are set.
+const HAIRLINE = "var(--vectoys-hairline, #8a8a8a)";
+const SURFACE = "var(--vectoys-surface, #f5f5f5)";
+const FINISH = "var(--vectoys-finish, #5b7cfa)";
+
+const fill = (color: string): Look => ({ style: { fill: color } });
+const STYLES: Record<string, Look> = {
+  top: fill(FINISH),
+  bottom: fill(FINISH),
+  side: fill(FINISH),
+  face: fill(SURFACE),
+};
+
+const OUTLINE: Look = {
+  vectorEffect: "non-scaling-stroke",
+  strokeWidth: 1,
+  strokeLinejoin: "round",
+  style: { stroke: HAIRLINE, fill: "none" },
+};
+
+export type ${component}Props = {
+  /** What the item shows, for assistive technology. */
+  label?: string;
+  /** The slab's colour; by default the page's \`--vectoys-finish\`. */
+  finish?: string;
+  /** How far it turns about its up axis, in degrees. */
+  yaw?: number;
+  /** How far it tips towards or away from the eye, in degrees. */
+  pitch?: number;
+  className?: string;
+  style?: CSSProperties;
+};
+
+/** ${title}: a slab tilted towards the eye, drawn the same on the server and the client. */
+export function ${component}({ label = ${JSON.stringify(title)}, finish, yaw = TILT.yaw, pitch = TILT.pitch, className, style }: ${component}Props) {
+  const view = useMemo(() => seen(yaw, pitch), [yaw, pitch]);
+  const body = view.drawn.hulls.find((hull) => hull.part === "body");
+  const vars: StyleWithVariables = finish ? { "--vectoys-finish": finish } : {};
+  return (
+    <div role="img" aria-label={label} className={className} style={style}>
+      <Stage camera={view.camera} style={vars}>
+        <Faces faces={view.drawn.faces} hulls={view.drawn.hulls} styles={STYLES} shading />
+        {body && <path d={body.d} {...OUTLINE} />}
+      </Stage>
+    </div>
+  );
+}
+`,
+    "src/index.ts": `export { HEIGHT, THICKNESS, TILT, WIDTH, seen, type View } from "./geometry";
+export { ${component}, type ${component}Props } from "./${name}";
+`,
+    [`test/${name}.test.tsx`]: `import { expect, test } from "bun:test";
+import { renderToStaticMarkup } from "react-dom/server";
+import { ${component} } from "../src";
+
+test("renders on the server as a labelled image with no NaN", () => {
+  const html = renderToStaticMarkup(<${component} label="A blue slab" finish="#3b82f6" />);
+  expect(html).toStartWith('<div role="img" aria-label="A blue slab"');
+  expect(html).toContain("--vectoys-finish:#3b82f6");
+  expect(html).not.toContain("NaN");
+});
+`
+  };
+}
+function create(context, name, under) {
+  if (!name)
+    throw new Error('Name the new item, as "vectoys create spinner".');
+  if (!ITEM_NAME.test(name))
+    throw new Error(`"${name}" is not an item name. Use letters, digits, dots, dashes and underscores.`);
+  const folder = resolve2(context.cwd, under ?? ".", name);
+  const shown = relative2(context.cwd, folder) || ".";
+  if (existsSync4(folder) && !context.overwrite)
+    throw new Error(`${shown} is already there. Pass --overwrite to write over it.`);
+  for (const [path, content] of Object.entries(scaffold(name, gitAuthor(context.cwd), inVectoysRepo(folder)))) {
+    const to = join4(folder, path);
+    mkdirSync2(dirname2(to), { recursive: true });
+    writeFileSync3(to, content);
+    context.log(`Wrote    ${relative2(context.cwd, to)}`);
+  }
+  context.log(`Draw it in ${shown}/src, then run "vectoys check ${shown}" before you submit it.`);
+}
+
+// src/check.ts
+var BRANDS = [
+  "apple watch",
+  "galaxy tab",
+  "pixel phone",
+  "surface pro",
+  "iphone",
+  "ipad",
+  "macbook",
+  "imac",
+  "airpods",
+  "apple",
+  "google",
+  "microsoft",
+  "samsung",
+  "playstation",
+  "xbox",
+  "nintendo"
+];
+var BRAND = new RegExp(`\\b(${BRANDS.map((brand) => brand.replace(" ", "\\s+")).join("|")})\\b`, "gi");
+var MAX_SOURCE = 64 * 1024;
+function brands(text) {
+  return [...new Set([...text.matchAll(BRAND)].map((match) => match[0].toLowerCase().replace(/\s+/g, " ")))];
+}
+var MARK = "@@vectoys-check@@";
+function bunScript(body) {
+  return `
+const [entry, dir, wanted] = process.argv.slice(2);
+const done = (value) => process.stdout.write("\\n${MARK}" + JSON.stringify(value));
+try {
+  const { createElement } = await import(Bun.resolveSync("react", dir));
+  const { renderToStaticMarkup } = await import(Bun.resolveSync("react-dom/server", dir));
+  const mod = await import(entry);
+  const isComponent = (value) => typeof value === "function" || (typeof value === "object" && value !== null && "$$typeof" in value);
+  const name = isComponent(mod[wanted]) ? wanted : Object.keys(mod).find((key) => /^[A-Z]/.test(key) && isComponent(mod[key]));
+  if (!name) throw new Error("it exports no component");
+  ${body}
+} catch (error) {
+  done({ error: error instanceof Error ? error.message : String(error) });
+}
+`;
+}
+var RUNNER = bunScript(`const render = () => renderToStaticMarkup(createElement(mod[name]));
+  done({ name, html: [render(), render()] });`);
+function isRendered(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if ("error" in value)
+    return typeof value.error === "string";
+  return "name" in value && typeof value.name === "string" && "html" in value && Array.isArray(value.html) && value.html.length === 2 && value.html.every((html) => typeof html === "string");
+}
+function runInBun(script, entry, dir, wanted) {
+  const work = mkdtempSync(join5(tmpdir(), "vectoys-check-"));
+  try {
+    const runner = join5(work, "render.mjs");
+    writeFileSync4(runner, script);
+    const result = spawnSync3("bun", [runner, entry, dir, wanted], { cwd: dir, encoding: "utf8", timeout: 60000, maxBuffer: 64 * 1024 * 1024 });
+    if (result.error) {
+      const missing2 = "code" in result.error && result.error.code === "ENOENT";
+      return { error: missing2 ? "it needs bun to load the item's TSX: https://bun.sh" : result.error.message };
+    }
+    const at = result.stdout.lastIndexOf(MARK);
+    if (at === -1)
+      return { error: result.stderr.trim() || "bun stopped without rendering it" };
+    const value = JSON.parse(result.stdout.slice(at + MARK.length));
+    if (typeof value === "object" && value !== null && "error" in value && typeof value.error === "string")
+      return { error: value.error };
+    return { value };
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+  }
+}
+function render(entry, dir, wanted) {
+  const ran = runInBun(RUNNER, entry, dir, wanted);
+  if ("error" in ran)
+    return ran;
+  return isRendered(ran.value) ? ran.value : { error: "bun gave back something other than markup" };
+}
+function textOf(html) {
+  const labels = [...html.matchAll(/\s(?:aria-label|title|alt)="([^"]*)"/g)].map((match) => match[1]);
+  const text = html.replace(/<(style|script)\b[\s\S]*?<\/\1>/gi, " ").replace(/<[^>]*>/g, " ");
+  return [text, ...labels].join(" ");
+}
+var labelled = (attributes) => /\saria-label="[^"]*\S[^"]*"/.test(attributes) || /\saria-labelledby="[^"]+"/.test(attributes);
+function accessibleName(html) {
+  const root = /^<[a-z][\w-]*([^>]*)>/i.exec(html);
+  const role = /\srole="(img|group)"/.exec(root?.[1] ?? "")?.[1];
+  if (role && labelled(root?.[1] ?? ""))
+    return `the root is role="${role}" with an aria-label`;
+  const controls = [...html.matchAll(/<(button|a|input|select|textarea)\b([^>]*)>/gi)].filter(([, tag, attributes]) => tag?.toLowerCase() !== "a" || /\shref=/.test(attributes ?? ""));
+  if (controls.length === 0)
+    return;
+  const named = controls.every((control) => {
+    const [, tag = "", attributes = ""] = control;
+    if (labelled(attributes))
+      return true;
+    const kind = tag.toLowerCase();
+    if (kind !== "button" && kind !== "a")
+      return false;
+    const after = html.slice((control.index ?? 0) + control[0].length);
+    const end = after.search(new RegExp(`</${kind}>`, "i"));
+    return after.slice(0, end === -1 ? 0 : end).replace(/<[^>]*>/g, "").trim() !== "";
+  });
+  return named ? `its ${controls.length} control${controls.length === 1 ? " is" : "s are"} labelled` : undefined;
+}
+function itemProblem(item, dir) {
+  if (!ITEM_NAME.test(item.name))
+    return `"${item.name}" is not an item name`;
+  const file = item.files.find((path) => typeof path !== "string" || !resolve3(dir, path).startsWith(dir + sep3) || !existsSync5(resolve3(dir, path)));
+  if (file !== undefined)
+    return `files lists ${JSON.stringify(file)}, which is not a file in the folder`;
+  const other = item.files.find((path) => !lstatSync(resolve3(dir, path)).isFile());
+  if (other !== undefined) {
+    const stat = lstatSync(resolve3(dir, other));
+    const kind = stat.isSymbolicLink() ? "a symlink, " : stat.isDirectory() ? "a folder, " : "";
+    return `files lists ${JSON.stringify(other)}, which is ${kind}not a regular file`;
+  }
+  if (item.dependencies !== undefined && !(Array.isArray(item.dependencies) && item.dependencies.every(isPackageSpec))) {
+    return "dependencies are not all plain npm package names";
+  }
+  return;
+}
+function readItem(dir) {
+  const path = join5(dir, "item.json");
+  if (!existsSync5(path))
+    return "there is no item.json";
+  let value;
+  try {
+    value = JSON.parse(readFileSync5(path, "utf8"));
+  } catch (error) {
+    return `item.json is not valid JSON: ${error instanceof Error ? error.message : String(error)}`;
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return "item.json is not an object";
+  try {
+    const item = checkItem(value, "item.json");
+    return itemProblem(item, dir) ?? item;
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+function componentFile(item) {
+  return item.files.find((file) => basename(file, ".tsx") === item.name && extname(file) === ".tsx") ?? item.files.find((file) => extname(file) === ".tsx");
+}
+function checks(dir) {
+  const item = readItem(dir);
+  if (typeof item === "string")
+    return [{ pass: false, line: item }];
+  const results = [{ pass: true, line: "item.json has what the registry needs" }];
+  const size = item.files.reduce((sum, file) => sum + lstatSync(resolve3(dir, file)).size, 0);
+  const kb = (bytes) => `${(bytes / 1024).toFixed(1)} KB`;
+  results.push({ pass: size < MAX_SOURCE, line: `the files are ${kb(size)}, ${size < MAX_SOURCE ? "under" : "over"} ${kb(MAX_SOURCE)}` });
+  const named = brands([item.name, item.title, item.description].join(" "));
+  results.push({ pass: named.length === 0, line: named.length ? `item.json names brands: ${named.join(", ")}` : "item.json names no brands" });
+  const component = componentFile(item);
+  if (!component)
+    return [...results, { pass: false, line: "files lists no .tsx component to render" }];
+  const rendered = render(resolve3(dir, component), dir, componentName(item.name));
+  if ("error" in rendered)
+    return [...results, { pass: false, line: `${component} does not render on the server: ${rendered.error}` }];
+  const [html, again] = rendered.html;
+  results.push({ pass: true, line: `${rendered.name} renders on the server` });
+  const broken = ["NaN", "Infinity"].filter((word) => html.includes(word));
+  results.push({ pass: broken.length === 0, line: broken.length ? `the markup has ${broken.join(" and ")} in it` : "the markup has no NaN or Infinity" });
+  results.push({ pass: html === again, line: html === again ? "two renders give the same markup" : "two renders give different markup" });
+  const shown = brands(textOf(html));
+  results.push({ pass: shown.length === 0, line: shown.length ? `the rendered text names brands: ${shown.join(", ")}` : "the rendered text names no brands" });
+  const name = accessibleName(html);
+  results.push({ pass: name !== undefined, line: name ?? 'the root is not role="img" or "group" with an aria-label, and it has no labelled controls' });
+  return results;
+}
+function check2(context, given) {
+  const dir = resolve3(context.cwd, given ?? ".");
+  context.log(`Checking ${relative3(context.cwd, dir) || "."}`);
+  const results = checks(dir);
+  for (const result of results)
+    context.log(`  ${result.pass ? "pass" : "FAIL"}  ${result.line}`);
+  const failed = results.filter((result) => !result.pass).length;
+  if (failed > 0)
+    throw new Error(`${failed} of ${results.length} checks fail.`);
+  context.log(`All ${results.length} checks pass.`);
+}
+
+// src/preview.ts
+import { spawn } from "node:child_process";
+import { writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join6, relative as relative4, resolve as resolve4 } from "node:path";
+var YAWS = [-45, -20, 0, 20, 45];
+var RUNNER2 = bunScript(`const render = (props) => renderToStaticMarkup(createElement(mod[name], props));
+  const yaws = ${JSON.stringify(YAWS)}.map((yaw) => ({ yaw, html: render({ yaw }) }));
+  const turns = yaws[0].html !== yaws[yaws.length - 1].html;
+  done({ name, html: render(), yaws: turns ? yaws : [] });`);
+function isPreview(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (!(("name" in value) && typeof value.name === "string" && ("html" in value) && typeof value.html === "string"))
+    return false;
+  if (!(("yaws" in value) && Array.isArray(value.yaws)))
+    return false;
+  return value.yaws.every((turn) => typeof turn === "object" && turn !== null && ("yaw" in turn) && typeof turn.yaw === "number" && ("html" in turn) && typeof turn.html === "string");
+}
+var THEMES = {
+  light: `--page: #f3f4f6; --ink: #15171c; --muted: #5f6571; --vectoys-bg: #f3f4f6; --vectoys-surface: #f5f6f8; --vectoys-hairline: #8a8e96; --vectoys-border: #d2d5db; --vectoys-shadow: rgba(10, 14, 22, 0.1); --vectoys-focus: #5f6571; color-scheme: light;`,
+  dark: `--page: #0f1114; --ink: #eceef2; --muted: #959baa; --vectoys-bg: #0f1114; --vectoys-surface: #3a3e46; --vectoys-hairline: #6c717c; --vectoys-border: #4b505a; --vectoys-shadow: rgba(0, 0, 0, 0.55); --vectoys-focus: #959baa; color-scheme: dark;`
+};
+var escape = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function scoped(html, scope) {
+  return html.replace(/(\s(?:id|for|aria-labelledby|aria-describedby|aria-controls)=")([^"]+)"/g, (_, attribute, ids) => `${attribute}${ids.split(/\s+/).map((id) => scope + id).join(" ")}"`).replace(/url\(#/g, `url(#${scope}`).replace(/href="#/g, `href="#${scope}`);
+}
+function previewPage(title, preview) {
+  const panel = (theme) => {
+    const turns = preview.yaws.map(({ yaw, html }, at) => `<figure><div class="item">${scoped(html, `${theme}-${at}-`)}</div><figcaption>yaw ${yaw}</figcaption></figure>`).join("");
+    return `<section class="${theme}">
+<h2>${theme}</h2>
+<figure class="hero"><div class="item">${scoped(preview.html, `${theme}-`)}</div><figcaption>as it comes</figcaption></figure>
+${turns ? `<div class="turns">${turns}</div>` : ""}
+</section>`;
+  };
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escape(title)} preview</title>
+<style>
+* { box-sizing: border-box; }
+body { margin: 0; font: 14px/1.5 ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif; background: #f3f4f6; }
+header { padding: 16px 24px; color: #15171c; }
+h1 { margin: 0; font-size: 18px; font-weight: 500; }
+header p { margin: 0; color: #5f6571; }
+main { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(100%, 420px), 1fr)); }
+section { padding: 24px; background: var(--page); color: var(--ink); }
+section.light { ${THEMES.light} }
+section.dark { ${THEMES.dark} }
+h2 { margin: 0 0 16px; font-size: 13px; font-weight: 500; color: var(--muted); text-transform: uppercase; letter-spacing: 0.06em; }
+figure { margin: 0; display: grid; gap: 8px; justify-items: center; }
+figcaption { font-size: 12px; color: var(--muted); }
+.hero .item { width: min(100%, 360px); }
+.turns { margin-top: 24px; display: grid; grid-template-columns: repeat(auto-fill, minmax(120px, 1fr)); gap: 16px; }
+.turns .item { width: 100%; }
+</style>
+</head>
+<body>
+<header><h1>${escape(title)}</h1><p>${escape(preview.name)}, rendered on the server${preview.yaws.length ? ` and turned to yaw ${preview.yaws.map(({ yaw }) => yaw).join(", ")}` : ""}</p></header>
+<main>
+${panel("light")}
+${panel("dark")}
+</main>
+</body>
+</html>
+`;
+}
+function open(path) {
+  const [command, args] = process.platform === "darwin" ? ["open", [path]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", path]] : ["xdg-open", [path]];
+  spawn(command, args, { detached: true, stdio: "ignore" }).unref();
+}
+function preview(context, given, opening = false) {
+  const dir = resolve4(context.cwd, given ?? ".");
+  const item = readItem(dir);
+  if (typeof item === "string")
+    throw new Error(`${relative4(context.cwd, dir) || "."} is not an item to preview: ${item}.`);
+  const component = componentFile(item);
+  if (!component)
+    throw new Error("item.json lists no .tsx component to render.");
+  const ran = runInBun(RUNNER2, resolve4(dir, component), dir, componentName(item.name));
+  if ("error" in ran)
+    throw new Error(`${component} does not render on the server: ${ran.error}`);
+  if (!isPreview(ran.value))
+    throw new Error("bun gave back something other than markup.");
+  const path = join6(dir, "preview.html");
+  writeFileSync5(path, previewPage(item.title, ran.value));
+  context.log(path);
+  if (opening)
+    open(path);
+  return path;
+}
+
+// src/skill.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "node:fs";
+import { fileURLToPath } from "node:url";
+var SKILL = fileURLToPath(new URL("../SKILL.md", import.meta.url));
+function skill(context, path = SKILL) {
+  if (!existsSync6(path))
+    throw new Error(`${path} is missing. Reinstall vectoys.`);
+  context.log(readFileSync6(path, "utf8").trimEnd());
+}
+
+// src/submit.ts
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { cpSync, existsSync as existsSync7, mkdirSync as mkdirSync3, mkdtempSync as mkdtempSync2, readFileSync as readFileSync7, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { dirname as dirname3, join as join7, relative as relative5, resolve as resolve5 } from "node:path";
+var SUBMISSIONS_OPEN = false;
+var UPSTREAM = "vinenastudio/vectoys";
+var CLOSED = "Submissions open when vectoys launches. Nothing was sent.";
+var run = (command, args, cwd) => {
+  const result = spawnSync4(command, args, { cwd, encoding: "utf8" });
+  if (result.error) {
+    const missing2 = "code" in result.error && result.error.code === "ENOENT";
+    throw new Error(missing2 ? `submit needs ${command}${command === "gh" ? ", the GitHub CLI: https://cli.github.com" : ""}.` : result.error.message);
+  }
+  return { status: result.status ?? 1, stdout: result.stdout, stderr: result.stderr };
+};
+function must(runner, command, args, cwd) {
+  const result = runner(command, args, cwd);
+  if (result.status !== 0)
+    throw new Error(`${command} ${args.join(" ")} failed: ${(result.stderr || result.stdout).trim()}`);
+  return result.stdout.trim();
+}
+function openPullRequestFrom(head, runner, cwd) {
+  const found = JSON.parse(must(runner, "gh", ["pr", "list", "--repo", UPSTREAM, "--head", head, "--state", "open", "--json", "url"], cwd) || "[]");
+  const first = Array.isArray(found) ? found[0] : undefined;
+  return typeof first === "object" && first !== null && "url" in first && typeof first.url === "string" ? first.url : undefined;
+}
+function openPullRequest(change, runner, cwd) {
+  const login = must(runner, "gh", ["api", "user", "--jq", ".login"], cwd);
+  must(runner, "gh", ["repo", "fork", UPSTREAM, "--clone=false"], cwd);
+  must(runner, "gh", ["repo", "sync", `${login}/vectoys`, "--branch", "main"], cwd);
+  const work = mkdtempSync2(join7(tmpdir2(), "vectoys-submit-"));
+  try {
+    const clone = join7(work, "vectoys");
+    must(runner, "gh", ["repo", "clone", `${login}/vectoys`, clone, "--", "--depth", "1"], work);
+    must(runner, "git", ["checkout", "-b", change.branch], clone);
+    change.write(clone);
+    must(runner, "git", ["add", "--all"], clone);
+    must(runner, "git", ["commit", "-m", change.title], clone);
+    const ref = `refs/heads/${change.branch}`;
+    const pushed = must(runner, "git", ["ls-remote", "origin", ref], clone).split("\t")[0] ?? "";
+    must(runner, "git", ["push", `--force-with-lease=${ref}:${pushed}`, "--set-upstream", "origin", change.branch], clone);
+    const head = `${login}:${change.branch}`;
+    const open2 = openPullRequestFrom(head, runner, clone);
+    if (open2)
+      return { url: open2, opened: false };
+    return { url: must(runner, "gh", ["pr", "create", "--repo", UPSTREAM, "--base", "main", "--head", head, "--title", change.title, "--body", change.body], clone), opened: true };
+  } finally {
+    rmSync2(work, { recursive: true, force: true });
+  }
+}
+function steps(change, own) {
+  return [
+    `Fork ${UPSTREAM} to your GitHub account with gh and bring its main up to date`,
+    "Clone the fork into a temporary folder",
+    `Make the branch ${change.branch}`,
+    ...own,
+    `Commit "${change.title}" and push the branch to the fork`,
+    `Open a pull request to ${UPSTREAM} main, or update the one already open from the branch`
+  ];
+}
+function itemFiles(dir, listed) {
+  const extra = ["package.json", "tsconfig.json", "test"].filter((path) => existsSync7(join7(dir, path)));
+  return [...new Set(["item.json", ...listed, ...extra])];
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function inRepoForm(folder) {
+  const pkgPath = join7(folder, "package.json");
+  if (existsSync7(pkgPath)) {
+    const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
+    if (!isRecord(pkg))
+      throw new Error("The item's package.json is not an object.");
+    for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
+      const deps = pkg[field];
+      if (!isRecord(deps))
+        continue;
+      for (const name of Object.keys(deps))
+        if (name.startsWith("@vectoys/") || name === "@vinena/vectoys" || name.startsWith("@vinena/vectoys-"))
+          deps[name] = "workspace:*";
+      if (field === "devDependencies")
+        delete deps["@types/bun"];
+    }
+    writeFileSync6(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`);
+  }
+  const tsPath = join7(folder, "tsconfig.json");
+  if (existsSync7(tsPath)) {
+    const tsconfig = JSON.parse(readFileSync7(tsPath, "utf8"));
+    if (!isRecord(tsconfig))
+      throw new Error("The item's tsconfig.json is not an object.");
+    const own = isRecord(tsconfig.compilerOptions) ? tsconfig.compilerOptions : {};
+    const kept = Object.fromEntries(Object.entries(own).filter(([key]) => !(key in compilerOptions)));
+    writeFileSync6(tsPath, `${JSON.stringify({ extends: BASE_TSCONFIG, ...tsconfig, compilerOptions: kept }, null, 2)}
+`);
+  }
+}
+function itemChange(context, dir) {
+  const shown = relative5(context.cwd, dir) || ".";
+  context.log(`Checking ${shown}`);
+  const results = checks(dir);
+  for (const result of results)
+    context.log(`  ${result.pass ? "pass" : "FAIL"}  ${result.line}`);
+  const failed = results.filter((result) => !result.pass).length;
+  if (failed > 0)
+    throw new Error(`${failed} of ${results.length} checks fail. Fix them, then submit again.`);
+  const item = readItem(dir);
+  if (typeof item === "string")
+    throw new Error(item);
+  const files = itemFiles(dir, item.files);
+  const branch = `item/${item.name}`;
+  const title = `Add the ${item.name} item`;
+  const body = [
+    `Adds \`registry/${item.name}\`: ${item.description}`,
+    "",
+    "## vectoys check",
+    "",
+    ...results.map((result) => `- ${result.pass ? "pass" : "FAIL"}: ${result.line}`),
+    "",
+    "## Author",
+    "",
+    "- [ ] I made this item myself, and it draws no maker's product.",
+    "- [ ] I agree to license it under the MIT license."
+  ].join(`
+`);
+  return {
+    branch,
+    title,
+    body,
+    steps: steps({ branch, title }, [`Copy ${files.join(", ")} into registry/${item.name}/`]),
+    write: (clone) => {
+      for (const file of files) {
+        const to = join7(clone, "registry", item.name, file);
+        mkdirSync3(dirname3(to), { recursive: true });
+        cpSync(join7(dir, file), to, { recursive: true });
+      }
+      inRepoForm(join7(clone, "registry", item.name));
+    }
+  };
+}
+function registryUrls(given) {
+  const trimmed = given.replace(/\/+$/, "");
+  if (trimmed.endsWith(".json"))
+    return { index: trimmed, base: trimmed.slice(0, trimmed.lastIndexOf("/")) };
+  return { index: `${trimmed}/index.json`, base: trimmed };
+}
+function readIndex(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return "it is not a JSON object";
+  if (!("items" in value) || !Array.isArray(value.items))
+    return 'it has no "items" list';
+  if (value.items.length === 0)
+    return "it lists no items";
+  const bad = value.items.find((item) => !(typeof item === "object" && item !== null && ("name" in item) && typeof item.name === "string" && ITEM_NAME.test(item.name)));
+  if (bad !== undefined)
+    return `it lists ${JSON.stringify(bad)}, which has no item name`;
+  const name = "name" in value && typeof value.name === "string" && ITEM_NAME.test(value.name) ? value.name : undefined;
+  return { name, items: value.items.length };
+}
+function listed(registries, listing) {
+  return [...registries.filter((entry) => entry.name !== listing.name), listing].sort((a, b) => a.name.localeCompare(b.name));
+}
+function isListings(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "object" && entry !== null && ("name" in entry) && typeof entry.name === "string");
+}
+async function listingChange(context, given, runner) {
+  const { index, base } = registryUrls(given);
+  context.log(`Reading ${index}`);
+  const read = readIndex(await fetchJson(index));
+  if (typeof read === "string")
+    throw new Error(`${index} is not a vectoys registry index: ${read}.`);
+  const { items } = read;
+  const name = read.name ?? new URL(base).hostname;
+  context.log(`  pass  it lists ${items} item${items === 1 ? "" : "s"}`);
+  const author = runner("git", ["config", "user.name"], context.cwd).stdout.trim();
+  if (!author)
+    throw new Error('Set your name for git first, as git config --global user.name "Your Name".');
+  const listing = { name, url: base, author };
+  const branch = `registry/${name}`;
+  const title = `List the ${name} registry`;
+  const body = [
+    `Lists the ${name} registry, at ${base}, by ${author}. Its index lists ${items} item${items === 1 ? "" : "s"}.`,
+    "",
+    "- [ ] I run this registry, and its items draw no maker's product."
+  ].join(`
+`);
+  return {
+    branch,
+    title,
+    body,
+    steps: steps({ branch, title }, [`Add ${JSON.stringify(listing)} to registries.json, sorted by name`]),
+    write: (clone) => {
+      const path = join7(clone, "registries.json");
+      const found = existsSync7(path) ? JSON.parse(readFileSync7(path, "utf8")) : [];
+      if (!isListings(found))
+        throw new Error("registries.json in the fork is not a list of registries.");
+      writeFileSync6(path, `${JSON.stringify(listed(found, listing), null, 2)}
+`);
+    }
+  };
+}
+async function submit(context, given, options) {
+  const runner = options.run ?? run;
+  const change = options.registry ? await listingChange(context, options.registry, runner) : itemChange(context, resolve5(context.cwd, given ?? "."));
+  if (!(options.submissionsOpen ?? SUBMISSIONS_OPEN) || options.dryRun) {
+    context.log("");
+    context.log("submit would:");
+    change.steps.forEach((step, at) => context.log(`  ${at + 1}. ${step}`));
+    context.log("");
+    context.log(`Pull request title: ${change.title}`);
+    context.log("Pull request body:");
+    for (const line of change.body.split(`
+`))
+      context.log(line ? `  ${line}` : "");
+    context.log("");
+    context.log(CLOSED);
+    return;
+  }
+  const { url, opened } = openPullRequest(change, runner, context.cwd);
+  context.log(`${opened ? "Opened" : "Updated"} ${url}`);
+  return url;
+}
+
+// src/index.ts
+var HELP = `vectoys ${version}: copy vectoys devices and toys into your project.
+
+Usage
+  vectoys init                 Write vectoys.json with where items go
+  vectoys add <item...>        Copy items in and install what they need
+  vectoys list [@registry]     Show the items a registry has
+  vectoys create <name>        Start a new item in ./<name> to draw and submit
+  vectoys check [dir]          Check an item folder before you submit it (needs bun)
+  vectoys preview [dir]        Render an item to preview.html in light and dark (needs bun)
+  vectoys submit [dir]         Check an item, then open a pull request to add it (needs gh)
+  vectoys submit --registry <url>
+                               Open a pull request to list your registry on vectoys
+  vectoys skill                Print how a coding agent makes a new item
+
+Items
+  phone                        From the default registry
+  @acme/thing                  From the registry "@acme" maps to in vectoys.json
+  https://acme.dev/r/x.json    From that URL
+
+Options
+  --registry <url>   The registry for plain names (or set VECTOYS_REGISTRY), or the one submit lists
+  --cwd <dir>        Run in another folder
+  --dir <dir>        Where create puts the new item's folder
+  -y, --yes          Answer yes to every question
+  -o, --overwrite    Replace files or a new item's folder that are already there
+  --no-install       Do not install packages, only say which ones
+  --open             Open the preview once it is written
+  --dry-run          Say what submit would send, and send nothing
+  -h, --help         Show this help
+  -v, --version      Show the version
+`;
+async function main(argv) {
+  const { command, rest, flags } = parseArgs(argv);
+  if (flags.version)
+    return console.log(version);
+  if (flags.help || !command)
+    return console.log(HELP);
+  const context = {
+    cwd: resolve6(flags.cwd ?? process.cwd()),
+    registry: flags.registry ?? (process.env.VECTOYS_REGISTRY || undefined),
+    registryFlag: flags.registry,
+    yes: flags.yes,
+    overwrite: flags.overwrite,
+    install: flags.install,
+    log: (line) => console.log(line)
+  };
+  if (command === "init")
+    return void init(context);
+  if (command === "add")
+    return add(context, rest);
+  if (command === "list")
+    return list(context, rest[0]);
+  if (command === "create")
+    return create(context, rest[0], flags.dir);
+  if (command === "check")
+    return check2(context, rest[0]);
+  if (command === "preview")
+    return void preview(context, rest[0], flags.open);
+  if (command === "submit")
+    return void await submit(context, rest[0], { registry: flags.registry, dryRun: flags.dryRun });
+  if (command === "skill")
+    return skill(context);
+  throw new Error(`Unknown command "${command}". Run "vectoys --help" to see the commands.`);
+}
+main(process.argv.slice(2)).catch((error) => {
+  console.error(`vectoys: ${error.message}`);
+  process.exitCode = 1;
+});