@acutenetwork/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Acute Network
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,161 @@
+# acute
+
+The command line for [Acute](https://acute.network).
+
+```bash
+npm install -g @acutenetwork/cli
+```
+
+```bash
+acute --help
+```
+
+Node 20 or newer. MIT.
+
+Today it generates and reads Acute QR codes. More of the platform lands here as
+it ships, and every command follows the same shape: `--json` for scripting,
+`--quiet` for silence, meaningful exit codes.
+
+## Commands
+
+|                           |                                                                        |
+| ------------------------- | ---------------------------------------------------------------------- |
+| `acute qr <value>`        | Write an Acute QR code                                                 |
+| `acute qr decode <image>` | Read the value back out of one                                         |
+| `acute config`            | Defaults, so the flags you always pass become the flags you never pass |
+
+---
+
+## acute qr
+
+```bash
+acute qr https://example.com
+```
+
+Writes `acute-qr.png`: 1024px, transparent, with the Acute mark inlaid at the
+centre. This is the same code Acute renders in its own app and on its checkout
+and invoice pages, so a code you generate and a code your customer sees are the
+same object.
+
+| Flag                 | What it does                                                                 | Default          |
+| -------------------- | ---------------------------------------------------------------------------- | ---------------- |
+| `-o, --out <path>`   | File to write, or a directory to write into                                  | `./acute-qr.png` |
+| `-f, --format <fmt>` | `png`, `svg`, `jpeg`, `webp`. Inferred from `--out` when it has an extension | `png`            |
+| `-s, --size <px>`    | Width and height, 64 to 8192                                                 | `1024`           |
+| `--margin <px>`      | Quiet zone around the code                                                   | 8% of `--size`   |
+| `--fg <colour>`      | Module colour                                                                | `black`          |
+| `--bg <colour>`      | Background colour, or `transparent`                                          | `transparent`    |
+| `--mark <what>`      | `purple`, `light`, `none`, or a path to your own image                       | `purple`         |
+| `--ec <level>`       | Error correction: `auto`, `L`, `M`, `Q`, `H`                                 | `auto`           |
+| `-p, --print`        | Also print the code in the terminal, scannable as-is                         |                  |
+| `--stdout`           | Write the bytes to stdout instead of a file                                  |                  |
+| `--open`             | Open the file when it is done                                                |                  |
+
+```bash
+acute qr https://acute.ink/t/yourtag --size 2048 --out ~/Desktop
+acute qr https://example.com --format svg --bg white
+acute qr https://example.com --mark ./your-logo.svg
+acute qr https://example.com --stdout > code.png
+acute qr https://example.com --print        # scan it straight off your screen
+```
+
+`--fg` and `--bg` take any CSS colour, or one of `black`, `white`, `purple`,
+`purple-accent`, `green`.
+
+### Two defaults worth knowing
+
+**The background is transparent**, because a code is usually an asset that gets
+dropped onto something else, and a baked-in white square is the one thing you
+cannot undo later. Pass `--bg white` when the code has to stand alone: on a dark
+slide, or saved to a phone's photo library, a black code on nothing is
+invisible.
+
+**Error correction is `auto`.** The mark covers a fixed _proportion_ of the
+code, so on a short payload it eats relatively more of a low-version code, and
+the thing reading it is usually a cheap phone camera. Payloads of 64 characters
+or fewer get `H`, the highest level; longer ones get `Q`, which is plenty once
+the code is dense. Override it with `--ec`.
+
+## acute qr decode
+
+```bash
+acute qr decode ./poster.jpg
+```
+
+Reads any QR image, not only ones this wrote. Worth running before a code goes
+to print: what a scanner sees is the only thing that matters, and it is not
+always what you typed.
+
+## acute config
+
+```bash
+acute config set qr.out ~/Desktop
+acute config set qr.size 2048
+acute config list
+acute config path
+```
+
+Stored in `~/.config/acute/config.json`, or under `$XDG_CONFIG_HOME` if you set
+it. Keys no command reads cannot be set, so the file never fills with typos.
+
+## Scripting it
+
+Every command takes `--json` and prints one object to stdout:
+
+```bash
+acute qr https://example.com --json
+```
+
+```json
+{
+  "path": "/Users/you/acute-qr.png",
+  "format": "png",
+  "size": 1024,
+  "bytes": 22431,
+  "value": "https://example.com",
+  "errorCorrection": "Q",
+  "background": "transparent",
+  "foreground": "#000000",
+  "margin": 82
+}
+```
+
+Exit codes: `0` it worked, `1` it could not do what you asked, `2` the command
+line was wrong. `--quiet` prints nothing but errors. Colour is dropped when
+stdout is not a terminal, and `NO_COLOR` is honoured.
+
+## Contributing
+
+```bash
+git clone https://github.com/acutenetwork/acute-cli
+cd acute-cli
+pnpm install && pnpm build && pnpm test
+pnpm link --global      # puts your build on PATH as `acute`
+```
+
+A new command is a folder under `src/commands/` exporting a `CommandGroup`, plus
+one line in `src/commands/index.ts`. Routing, help, flag parsing, `--json`,
+`--quiet` and the settings file are all generated from what a `Command`
+declares, so there is nothing else to wire up:
+
+```ts
+export const show: Command = {
+  name: 'show',
+  summary: 'Show a thing.',
+  usage: 'thing show <id>',
+  options: { verbose: { kind: 'boolean', describe: 'More detail.' } },
+  async run({ positionals, io }) {
+    io.field('Id', positionals[0]!);
+    io.result({ id: positionals[0] }); // printed only under --json
+  },
+};
+```
+
+Three conventions: use `io` rather than `console.log`, since that is what makes
+`--json` and `--quiet` work; throw a `CliError` with a `hint` rather than
+calling `process.exit`; and use `usageError(...)` for a bad command line, so it
+exits 2 rather than 1.
+
+## Credits
+
+QR rendering by [fey](https://github.com/acutenetwork/fey).

package/assets/mark-light.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 62.23 49.92">
+  <path d="M62.13,47.37L50.03,1.52c-.21-.81-.78-1.32-1.49-1.48-.58-.13-1.26.07-1.8.61L.64,46.42c-.83.82-.83,1.94-.12,2.69.66.7,1.77.83,2.62.13,3.87-3.24,7.98-5.95,12.62-7.96,15.26-6.64,30.8-2.19,43.2,8.07.74.61,1.69.8,2.43.29.67-.47,1.03-1.18.74-2.26ZM30.57,29.88c-.54,0-1.08.01-1.61.03l15.88-15.76,5.28,20.01c-6.36-2.82-12.95-4.27-19.54-4.27Z" fill="#f2effc" />
+</svg>

package/assets/mark-purple.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 62.23 49.92">
+  <path d="M62.13,47.37L50.03,1.52c-.21-.81-.78-1.32-1.49-1.48-.58-.13-1.26.07-1.8.61L.64,46.42c-.83.82-.83,1.94-.12,2.69.66.7,1.77.83,2.62.13,3.87-3.24,7.98-5.95,12.62-7.96,15.26-6.64,30.8-2.19,43.2,8.07.74.61,1.69.8,2.43.29.67-.47,1.03-1.18.74-2.26ZM30.57,29.88c-.54,0-1.08.01-1.61.03l15.88-15.76,5.28,20.01c-6.36-2.82-12.95-4.27-19.54-4.27Z" fill="#5200a0" />
+</svg>

package/dist/bin.js

@@ -0,0 +1,1050 @@
+#!/usr/bin/env node
+
+// package.json
+var package_default = {
+  name: "@acutenetwork/cli",
+  version: "0.1.0",
+  description: "The command line for Acute.",
+  license: "MIT",
+  author: "Acute's Engineering Team <engineering@acute.network>",
+  homepage: "https://github.com/acutenetwork/acute-cli#readme",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/acutenetwork/acute-cli.git"
+  },
+  bugs: {
+    url: "https://github.com/acutenetwork/acute-cli/issues"
+  },
+  keywords: [
+    "acute",
+    "cli",
+    "acute-network",
+    "payments",
+    "qr",
+    "qr-code"
+  ],
+  type: "module",
+  bin: {
+    acute: "./dist/bin.js"
+  },
+  files: [
+    "dist",
+    "assets",
+    "README.md",
+    "LICENSE"
+  ],
+  engines: {
+    node: ">=20.0.0"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    test: "vitest run",
+    "test:watch": "vitest",
+    "type-check": "tsc --noEmit",
+    lint: "eslint .",
+    "lint:fix": "eslint . --fix",
+    format: "prettier --write .",
+    clean: "rm -rf dist",
+    prepublishOnly: "pnpm clean && pnpm build"
+  },
+  dependencies: {
+    "@acutenetwork/fey": "^0.2.2",
+    jsqr: "^1.4.0",
+    "qrcode-generator": "^1.4.4",
+    sharp: "^0.35.5"
+  },
+  devDependencies: {
+    "@eslint/js": "^9.12.0",
+    "@types/node": "^22.10.0",
+    eslint: "^9.12.0",
+    "eslint-config-prettier": "^9.1.0",
+    prettier: "^3.3.3",
+    tsup: "^8.4.0",
+    typescript: "^5.7.0",
+    "typescript-eslint": "^8.8.1",
+    vitest: "^3.0.0"
+  },
+  packageManager: "pnpm@11.7.0"
+};
+
+// src/kernel/config.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
+// src/kernel/errors.ts
+var CliError = class extends Error {
+  exitCode;
+  /** One line under the error saying what to do instead. */
+  hint;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = options.exitCode ?? ExitCode.Failure;
+    this.hint = options.hint;
+  }
+};
+var ExitCode = {
+  Ok: 0,
+  /** The command ran and could not do what was asked. */
+  Failure: 1,
+  /** The command line itself was wrong: unknown flag, missing argument. */
+  Usage: 2
+};
+function usageError(message, hint) {
+  return new CliError(message, { exitCode: ExitCode.Usage, ...hint ? { hint } : {} });
+}
+function distance(a, b) {
+  const rows = a.length + 1;
+  const cols = b.length + 1;
+  const d = new Array(rows * cols).fill(0);
+  for (let i = 0; i < rows; i += 1) d[i * cols] = i;
+  for (let j = 0; j < cols; j += 1) d[j] = j;
+  for (let i = 1; i < rows; i += 1) {
+    for (let j = 1; j < cols; j += 1) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      d[i * cols + j] = Math.min(
+        d[(i - 1) * cols + j] + 1,
+        d[i * cols + (j - 1)] + 1,
+        d[(i - 1) * cols + (j - 1)] + cost
+      );
+    }
+  }
+  return d[rows * cols - 1];
+}
+function nearest(input, candidates) {
+  let best = null;
+  for (const name of candidates) {
+    const score = distance(input.toLowerCase(), name.toLowerCase());
+    if (!best || score < best.score) best = { name, score };
+  }
+  if (!best || best.score > Math.max(2, Math.floor(input.length / 2))) return null;
+  return best.name;
+}
+
+// src/kernel/config.ts
+var SETTINGS = {
+  "qr.size": {
+    describe: "Pixel width of a generated code.",
+    parse: (raw) => positiveInt("qr.size", raw, 64, 8192)
+  },
+  "qr.format": {
+    describe: "Default output format: png, svg, jpeg or webp.",
+    parse: (raw) => oneOf("qr.format", raw, ["png", "svg", "jpeg", "webp"])
+  },
+  "qr.out": {
+    describe: "Directory (or file path) a generated code is written to.",
+    parse: (raw) => raw
+  },
+  "qr.mark": {
+    describe: "Centre mark: purple, light, none, or a path to an image.",
+    parse: (raw) => raw
+  },
+  "qr.foreground": {
+    describe: "Module colour, as a CSS colour.",
+    parse: (raw) => raw
+  },
+  "qr.background": {
+    describe: 'Background colour, or "transparent".',
+    parse: (raw) => raw
+  },
+  "qr.errorCorrection": {
+    describe: "Error correction: auto, L, M, Q or H.",
+    parse: (raw) => oneOf("qr.errorCorrection", raw, ["auto", "L", "M", "Q", "H"])
+  }
+};
+function positiveInt(key, raw, min, max) {
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < min || n > max) {
+    throw usageError(`${key} must be a whole number between ${min} and ${max}, got "${raw}".`);
+  }
+  return n;
+}
+function oneOf(key, raw, allowed) {
+  if (!allowed.includes(raw)) {
+    throw usageError(`${key} must be one of ${allowed.join(", ")}, got "${raw}".`);
+  }
+  return raw;
+}
+function settingKeys() {
+  return Object.keys(SETTINGS);
+}
+function describeSetting(key) {
+  return SETTINGS[key]?.describe;
+}
+function configPath() {
+  const base = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(base, "acute", "config.json");
+}
+function loadConfig() {
+  const path2 = configPath();
+  const stored = read(path2);
+  return {
+    path: path2,
+    get: (key) => stored[key],
+    entries: () => Object.entries(stored).sort(([a], [b]) => a.localeCompare(b)),
+    set(key, raw) {
+      const setting = SETTINGS[key];
+      if (!setting) throw unknownKey(key);
+      stored[key] = setting.parse(raw);
+      write(path2, stored);
+    },
+    unset(key) {
+      if (!SETTINGS[key]) throw unknownKey(key);
+      delete stored[key];
+      write(path2, stored);
+    }
+  };
+}
+function unknownKey(key) {
+  const suggestion = nearest(key, settingKeys());
+  return usageError(
+    `"${key}" is not an Acute setting.`,
+    suggestion ? `Did you mean ${suggestion}? Run "acute config list" for all of them.` : void 0
+  );
+}
+function read(path2) {
+  let raw;
+  try {
+    raw = readFileSync(path2, "utf8");
+  } catch {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      throw new Error("not an object");
+    return Object.fromEntries(
+      Object.entries(parsed).filter(
+        ([key, value]) => key in SETTINGS && (typeof value === "string" || typeof value === "number")
+      )
+    );
+  } catch {
+    throw new CliError(`${path2} is not valid JSON.`, {
+      hint: 'Fix it by hand, or delete it and set the values again with "acute config set".'
+    });
+  }
+}
+function write(path2, value) {
+  mkdirSync(dirname(path2), { recursive: true });
+  writeFileSync(path2, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+
+// src/commands/config.ts
+var list = {
+  name: "list",
+  summary: "Show every setting and what it is set to.",
+  usage: "config list",
+  options: {},
+  async run({ config, io }) {
+    const stored = new Map(config.entries());
+    const keys = settingKeys();
+    const width = Math.max(...keys.map((k) => k.length));
+    io.say();
+    for (const key of keys) {
+      const value = stored.get(key);
+      const shown = value === void 0 ? io.style.dim("unset") : String(value);
+      io.say(`  ${key.padEnd(width + 2)}${shown}`);
+      io.say(`  ${" ".repeat(width + 2)}${io.style.dim(describeSetting(key) ?? "")}`);
+    }
+    io.say();
+    io.say(`  ${io.style.dim(config.path)}`);
+    io.say();
+    io.result(Object.fromEntries(config.entries()));
+  }
+};
+var get = {
+  name: "get",
+  summary: "Print one setting.",
+  usage: "config get <key>",
+  options: {},
+  async run({ positionals, config, io }) {
+    const key = positionals[0];
+    if (!key) throw usageError("Which setting?", `One of: ${settingKeys().join(", ")}`);
+    const value = config.get(key);
+    if (value === void 0) {
+      io.say(io.style.dim("unset"));
+      io.result({ key, value: null });
+      return;
+    }
+    io.say(String(value));
+    io.result({ key, value });
+  }
+};
+var set = {
+  name: "set",
+  summary: "Change one setting.",
+  usage: "config set <key> <value>",
+  options: {},
+  examples: ["acute config set qr.out ~/Desktop", "acute config set qr.size 2048"],
+  async run({ positionals, config, io }) {
+    const [key, value] = positionals;
+    if (!key) throw usageError("Which setting?", `One of: ${settingKeys().join(", ")}`);
+    if (value === void 0) throw usageError(`What should ${key} be?`);
+    config.set(key, value);
+    io.say(`  ${key} = ${value}`);
+    io.result({ key, value: config.get(key), path: config.path });
+  }
+};
+var unset = {
+  name: "unset",
+  summary: "Go back to the default for one setting.",
+  usage: "config unset <key>",
+  options: {},
+  async run({ positionals, config, io }) {
+    const key = positionals[0];
+    if (!key) throw usageError("Which setting?", `One of: ${settingKeys().join(", ")}`);
+    config.unset(key);
+    io.say(`  ${key} is back to its default`);
+    io.result({ key, value: null, path: config.path });
+  }
+};
+var path = {
+  name: "path",
+  summary: "Print where the settings file lives.",
+  usage: "config path",
+  options: {},
+  async run({ config, io }) {
+    io.say(config.path);
+    io.result({ path: config.path });
+  }
+};
+var configGroup = {
+  name: "config",
+  summary: "Defaults, so the flags you always pass become the flags you never pass.",
+  commands: [list, get, set, unset, path],
+  defaultCommand: "list"
+};
+
+// src/commands/qr/decode.ts
+import { readFile } from "fs/promises";
+import { isAbsolute, resolve } from "path";
+
+// src/qr/decode.ts
+import jsQR from "jsqr";
+import sharp from "sharp";
+async function decodeQr(image) {
+  const { data, info } = await sharp(image).flatten({ background: "#FFFFFF" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  const pixels = new Uint8ClampedArray(data.buffer, data.byteOffset, data.byteLength);
+  const found = jsQR(pixels, info.width, info.height);
+  return found ? { value: found.data, width: info.width, height: info.height } : null;
+}
+
+// src/commands/qr/decode.ts
+var decode = {
+  name: "decode",
+  summary: "Read the value back out of a QR image.",
+  usage: "qr decode <image>",
+  options: {},
+  details: [
+    "Reads any QR image, not only ones this CLI wrote. It is the check worth running before a code goes on a page or into a deck: what a scanner sees is the only thing that matters, and it is not always what you typed."
+  ],
+  examples: ["acute qr decode ./acute-qr.png", "acute qr decode ~/Desktop/poster.jpg --json"],
+  async run({ positionals, io }) {
+    const target = positionals[0];
+    if (!target) throw usageError("Nothing to decode.", "Pass the image: acute qr decode <image>");
+    const path2 = isAbsolute(target) ? target : resolve(process.cwd(), target);
+    let file;
+    try {
+      file = await readFile(path2);
+    } catch {
+      throw new CliError(`Could not read ${path2}.`);
+    }
+    const found = await decodeQr(file);
+    if (!found) {
+      throw new CliError(`No QR code found in ${path2}.`, {
+        hint: "A tight crop, a low resolution or a heavy background can all hide one. Try the original file."
+      });
+    }
+    io.say();
+    io.field("Value", found.value);
+    io.field("Image", `${found.width}\xD7${found.height}`);
+    io.say();
+    io.result({ value: found.value, path: path2, width: found.width, height: found.height });
+  }
+};
+
+// src/commands/qr/generate.ts
+import { spawn } from "child_process";
+import { statSync } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import { dirname as dirname2, extname, isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
+
+// src/brand.ts
+import { fileURLToPath } from "url";
+var Brand = {
+  /** `AcutePurple[500]`, the main brand purple. The mark is filled with this. */
+  purple: "#5200A0",
+  /** `AcutePurple[300]`, the secondary purple. Readable on a dark surface. */
+  purpleAccent: "#9A5CFF",
+  /** `AcuteGreen[400]`, the brand green. A fill, never ink. */
+  green: "#13FB79",
+  /** `Tint.black`, true black. What QR modules are drawn in. */
+  black: "#000000",
+  white: "#FFFFFF"
+};
+var NAMED = {
+  black: Brand.black,
+  white: Brand.white,
+  purple: Brand.purple,
+  "purple-accent": Brand.purpleAccent,
+  green: Brand.green
+};
+function resolveColour(raw) {
+  if (raw === "transparent") return raw;
+  return NAMED[raw.toLowerCase()] ?? raw;
+}
+function markFile(variant) {
+  return fileURLToPath(new URL(`../assets/mark-${variant}.svg`, import.meta.url));
+}
+
+// src/kernel/args.ts
+import { parseArgs } from "util";
+var GLOBAL_OPTIONS = {
+  help: { kind: "boolean", short: "h", describe: "Show help for this command." },
+  json: { kind: "boolean", describe: "Print the result as JSON instead of prose." },
+  quiet: { kind: "boolean", short: "q", describe: "Print nothing but errors." },
+  version: { kind: "boolean", short: "v", describe: "Print the CLI's version." }
+};
+function parse(argv, options) {
+  const merged = { ...GLOBAL_OPTIONS, ...options };
+  const config = Object.fromEntries(
+    Object.entries(merged).map(([name, spec]) => [
+      name,
+      spec.short ? { type: spec.kind, short: spec.short } : { type: spec.kind }
+    ])
+  );
+  try {
+    const { values, positionals } = parseArgs({
+      args: argv,
+      options: config,
+      allowPositionals: true,
+      strict: true
+    });
+    return { flags: values, positionals };
+  } catch (error) {
+    throw asUsageError(error, Object.keys(merged));
+  }
+}
+function asUsageError(error, known) {
+  if (!(error instanceof Error)) return usageError("Could not read the command line.");
+  const unknownFlag = /Unknown option '(-{1,2}[^']+)'/.exec(error.message);
+  if (unknownFlag) {
+    const flag = unknownFlag[1];
+    const suggestion = nearest(flag.replace(/^-+/, ""), known);
+    return usageError(
+      `Unknown option ${flag}.`,
+      suggestion ? `Did you mean --${suggestion}?` : "Run the command with --help to see its options."
+    );
+  }
+  const missingValue = /Option '(-{1,2}[^']+)[^']*' argument missing/.exec(error.message);
+  if (missingValue) {
+    return usageError(`${missingValue[1]} needs a value.`);
+  }
+  return usageError(error.message);
+}
+function stringFlag(flags, name) {
+  const value = flags[name];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") throw usageError(`--${name} needs a value.`);
+  return value;
+}
+function intFlag(flags, name, range) {
+  const raw = stringFlag(flags, name);
+  if (raw === void 0) return void 0;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < range.min || n > range.max) {
+    throw usageError(
+      `--${name} must be a whole number between ${range.min} and ${range.max}, got "${raw}".`
+    );
+  }
+  return n;
+}
+function enumFlag(flags, name, allowed) {
+  const raw = stringFlag(flags, name);
+  if (raw === void 0) return void 0;
+  if (!allowed.includes(raw)) {
+    const suggestion = nearest(raw, allowed);
+    throw usageError(
+      `--${name} must be one of ${allowed.join(", ")}, got "${raw}".`,
+      suggestion ? `Did you mean --${name} ${suggestion}?` : void 0
+    );
+  }
+  return raw;
+}
+
+// src/qr/render.ts
+import { QRCode } from "@acutenetwork/fey/node";
+import sharp3 from "sharp";
+
+// src/qr/mark.ts
+import { readFile as readFile2 } from "fs/promises";
+import sharp2 from "sharp";
+async function loadMark(source, size) {
+  if (source.kind === "none") return null;
+  const file = source.kind === "builtin" ? markFile(source.variant) : source.path;
+  let input;
+  try {
+    input = await readFile2(file);
+  } catch {
+    throw new CliError(`Could not read the mark image at ${file}.`);
+  }
+  const target = Math.max(256, Math.round(size * 0.5));
+  let png;
+  try {
+    png = await sharp2(input).resize({ width: target, withoutEnlargement: false }).png().toBuffer();
+  } catch (error) {
+    throw new CliError(
+      `${file} is not an image this can rasterize (${error instanceof Error ? error.message : "unknown error"}).`,
+      { hint: "Use a PNG, JPEG or SVG, or pass --mark none." }
+    );
+  }
+  const { width, height } = await sharp2(png).metadata();
+  if (!width || !height) throw new CliError(`Could not measure the mark image at ${file}.`);
+  return { width, height, dataUri: `data:image/png;base64,${png.toString("base64")}` };
+}
+
+// src/qr/spec.ts
+var QR_DEFAULTS = {
+  size: 1024,
+  format: "png",
+  foreground: Brand.black,
+  /**
+   * Transparent, like the app. A code is an asset that gets dropped onto
+   * whatever surface it is going on, and a baked-in white square is the one
+   * thing you cannot undo later. `--bg white` paints a card when the code has
+   * to stand alone (a dark slide, a phone's photo library) and a black code on
+   * nothing would otherwise be invisible.
+   */
+  background: "transparent",
+  mark: "purple",
+  errorCorrection: "auto"
+};
+function defaultMargin(size) {
+  return Math.round(size * 0.08);
+}
+function resolveErrorCorrection(requested, value) {
+  if (requested !== "auto") return requested;
+  return value.length <= 64 ? "H" : "Q";
+}
+
+// src/qr/render.ts
+function buildOptions(spec) {
+  const errorCorrectionLevel = resolveErrorCorrection(spec.errorCorrection, spec.value);
+  return {
+    width: spec.size,
+    height: spec.size,
+    margin: spec.margin,
+    data: spec.value,
+    qrOptions: { errorCorrectionLevel },
+    imageOptions: { imageSize: 0.25, margin: 6, hideBackgroundDots: true },
+    dotsOptions: { color: spec.foreground, type: "extra-rounded", roundSize: false },
+    cornersSquareOptions: { type: "extra-rounded", color: spec.foreground },
+    cornersDotOptions: { type: "extra-rounded", color: spec.foreground },
+    backgroundOptions: { color: spec.background }
+  };
+}
+async function renderSvg(spec) {
+  const options = buildOptions(spec);
+  const mark = await loadMark(spec.mark, spec.size);
+  const qr = new QRCode({
+    ...options,
+    ...mark ? { image: "acute-mark", imageLoader: async () => mark } : {}
+  });
+  return qr.getSVG();
+}
+async function render(spec, format) {
+  const svg = await renderSvg(spec);
+  const errorCorrection = resolveErrorCorrection(spec.errorCorrection, spec.value);
+  if (format === "svg") {
+    return { bytes: Buffer.from(svg, "utf8"), format, errorCorrection };
+  }
+  const image = sharp3(Buffer.from(svg, "utf8"));
+  const flattened = format === "jpeg" && spec.background === "transparent" ? image.flatten({ background: "#FFFFFF" }) : image;
+  try {
+    const bytes = format === "png" ? await flattened.png({ compressionLevel: 9 }).toBuffer() : format === "jpeg" ? await flattened.jpeg({ quality: 92 }).toBuffer() : await flattened.webp({ quality: 92 }).toBuffer();
+    return { bytes, format, errorCorrection };
+  } catch (error) {
+    throw new CliError(
+      `Could not rasterize the code: ${error instanceof Error ? error.message : "unknown error"}.`
+    );
+  }
+}
+
+// src/qr/terminal.ts
+import qrcode from "qrcode-generator";
+var BLACK = [0, 0, 0];
+var WHITE = [255, 255, 255];
+function toTerminal(value, errorCorrection) {
+  const qr = qrcode(0, errorCorrection);
+  qr.addData(value);
+  qr.make();
+  const count = qr.getModuleCount();
+  const QUIET = 4;
+  const size = count + QUIET * 2;
+  const dark = (row, col) => {
+    const r = row - QUIET;
+    const c = col - QUIET;
+    if (r < 0 || c < 0 || r >= count || c >= count) return false;
+    return qr.isDark(r, c);
+  };
+  const lines = [];
+  for (let row = 0; row < size; row += 2) {
+    let line = "";
+    let currentFg = null;
+    let currentBg = null;
+    for (let col = 0; col < size; col += 1) {
+      const top = dark(row, col);
+      const bottom = dark(row + 1, col);
+      if (top !== currentFg) {
+        line += `\x1B[38;2;${(top ? BLACK : WHITE).join(";")}m`;
+        currentFg = top;
+      }
+      if (bottom !== currentBg) {
+        line += `\x1B[48;2;${(bottom ? BLACK : WHITE).join(";")}m`;
+        currentBg = bottom;
+      }
+      line += "\u2580";
+    }
+    lines.push(`${line}\x1B[0m`);
+  }
+  return lines.join("\n");
+}
+
+// src/commands/qr/generate.ts
+var FORMATS = ["png", "svg", "jpeg", "webp"];
+var LEVELS = ["auto", "L", "M", "Q", "H"];
+var EXTENSIONS = {
+  ".png": "png",
+  ".svg": "svg",
+  ".jpg": "jpeg",
+  ".jpeg": "jpeg",
+  ".webp": "webp"
+};
+var generate = {
+  name: "generate",
+  summary: "Write an Acute QR code for a value.",
+  usage: "qr <value> [options]",
+  options: {
+    out: {
+      kind: "string",
+      short: "o",
+      placeholder: "path",
+      describe: "File to write, or a directory to write into.",
+      defaultsTo: "./acute-qr.png"
+    },
+    format: {
+      kind: "string",
+      short: "f",
+      placeholder: FORMATS.join("|"),
+      describe: "Output format. Taken from --out when it has an extension.",
+      defaultsTo: QR_DEFAULTS.format
+    },
+    size: {
+      kind: "string",
+      short: "s",
+      placeholder: "px",
+      describe: "Width and height of the code.",
+      defaultsTo: String(QR_DEFAULTS.size)
+    },
+    margin: {
+      kind: "string",
+      placeholder: "px",
+      describe: "Quiet zone around the code.",
+      defaultsTo: "8% of --size"
+    },
+    fg: {
+      kind: "string",
+      placeholder: "colour",
+      describe: "Module colour. A brand word or any CSS colour.",
+      defaultsTo: "black"
+    },
+    bg: {
+      kind: "string",
+      placeholder: "colour",
+      describe: 'Background colour, a brand word, or "transparent".',
+      defaultsTo: "transparent"
+    },
+    mark: {
+      kind: "string",
+      placeholder: "purple|light|none|path",
+      describe: "The mark inlaid at the centre.",
+      defaultsTo: QR_DEFAULTS.mark
+    },
+    ec: {
+      kind: "string",
+      placeholder: LEVELS.join("|"),
+      describe: "Error correction level.",
+      defaultsTo: QR_DEFAULTS.errorCorrection
+    },
+    print: { kind: "boolean", short: "p", describe: "Also print the code in the terminal." },
+    stdout: { kind: "boolean", describe: "Write the bytes to stdout instead of a file." },
+    open: { kind: "boolean", describe: "Open the written file when it is done." }
+  },
+  details: [
+    "The styling is the app\u2019s: extra-rounded dots and corners, the Acute mark inlaid at 25%. A code written here and a code the app renders for the same value are the same object.",
+    "The background is transparent, like the app\u2019s, so the code drops onto whatever surface it is going on. Pass --bg white when it has to stand alone: a black code on nothing is invisible on a dark slide or in a phone\u2019s photo library.",
+    "Error correction defaults to auto: H for a short payload, where the mark covers relatively more of a low-version code, and Q for a long URL, where the code is dense enough that Q is plenty.",
+    "--fg and --bg take a brand word (black, white, purple, purple-accent, green) or any CSS colour."
+  ],
+  examples: [
+    "acute qr https://checkout.acute.network/c/chk_live_abc",
+    "acute qr acu664463900542trf --out ~/Desktop --size 2048",
+    'acute qr "https://acute.ink/t/emeka" --bg transparent --margin 0 --format svg',
+    "acute qr https://acute.network --stdout > code.png",
+    "acute qr acu664463900542trf --print   # scan it straight off the screen"
+  ],
+  async run(ctx) {
+    const { io, config } = ctx;
+    const value = ctx.positionals[0];
+    if (!value) {
+      throw usageError("Nothing to encode.", "Pass the value: acute qr <value>");
+    }
+    if (ctx.positionals.length > 1) {
+      throw usageError(
+        `Expected one value, got ${ctx.positionals.length}.`,
+        'Quote it if it contains spaces: acute qr "one value here"'
+      );
+    }
+    const toStdout = ctx.flags.stdout === true;
+    if (toStdout && stringFlag(ctx.flags, "out")) {
+      throw usageError("--out and --stdout both say where the bytes go. Pick one.");
+    }
+    const spec = resolveSpec(value, ctx, config);
+    const format = resolveFormat(ctx, config);
+    const rendered = await render(spec, format);
+    if (ctx.flags.print === true) {
+      io.say();
+      io.say(toTerminal(spec.value, rendered.errorCorrection));
+    }
+    if (toStdout) {
+      process.stdout.write(rendered.bytes);
+      return;
+    }
+    const path2 = resolveOut(ctx, config, format);
+    await mkdir(dirname2(path2), { recursive: true });
+    await writeFile(path2, rendered.bytes);
+    io.say();
+    io.field("Acute QR", `${spec.size}\xD7${spec.size} ${format}, level ${rendered.errorCorrection}`);
+    io.field("Value", spec.value);
+    io.field("Written", path2);
+    io.say();
+    io.result({
+      path: path2,
+      format,
+      size: spec.size,
+      bytes: rendered.bytes.byteLength,
+      value: spec.value,
+      errorCorrection: rendered.errorCorrection,
+      background: spec.background,
+      foreground: spec.foreground,
+      margin: spec.margin
+    });
+    if (ctx.flags.open === true) openFile(path2, io.warn);
+  }
+};
+function resolveSpec(value, ctx, config) {
+  const size = intFlag(ctx.flags, "size", { min: 64, max: 8192 }) ?? config.get("qr.size") ?? QR_DEFAULTS.size;
+  const margin = intFlag(ctx.flags, "margin", { min: 0, max: 4096 }) ?? defaultMargin(size);
+  if (margin * 2 >= size) {
+    throw usageError(`--margin ${margin} leaves no room inside --size ${size}.`);
+  }
+  const requestedLevel = enumFlag(ctx.flags, "ec", LEVELS) ?? config.get("qr.errorCorrection") ?? QR_DEFAULTS.errorCorrection;
+  return {
+    value,
+    size,
+    margin,
+    foreground: resolveColour(
+      stringFlag(ctx.flags, "fg") ?? config.get("qr.foreground") ?? QR_DEFAULTS.foreground
+    ),
+    background: resolveColour(
+      stringFlag(ctx.flags, "bg") ?? config.get("qr.background") ?? QR_DEFAULTS.background
+    ),
+    mark: resolveMark(
+      stringFlag(ctx.flags, "mark") ?? config.get("qr.mark") ?? QR_DEFAULTS.mark
+    ),
+    errorCorrection: requestedLevel
+  };
+}
+function resolveMark(raw) {
+  if (raw === "none") return { kind: "none" };
+  if (raw === "purple" || raw === "light") return { kind: "builtin", variant: raw };
+  const path2 = isAbsolute2(raw) ? raw : resolve2(process.cwd(), raw);
+  return { kind: "file", path: path2 };
+}
+function resolveFormat(ctx, config) {
+  const explicit = enumFlag(ctx.flags, "format", FORMATS);
+  const out = stringFlag(ctx.flags, "out");
+  const fromExtension = out ? EXTENSIONS[extname(out).toLowerCase()] : void 0;
+  if (explicit && fromExtension && explicit !== fromExtension) {
+    throw usageError(
+      `--format ${explicit} disagrees with the extension on --out ${out}.`,
+      "Drop one of them: the extension alone is enough."
+    );
+  }
+  return explicit ?? fromExtension ?? config.get("qr.format") ?? QR_DEFAULTS.format;
+}
+function resolveOut(ctx, config, format) {
+  const requested = stringFlag(ctx.flags, "out") ?? config.get("qr.out");
+  const extension = format === "jpeg" ? "jpg" : format;
+  if (!requested) return resolve2(process.cwd(), `acute-qr.${extension}`);
+  const expanded = requested.startsWith("~/") ? resolve2(process.env.HOME ?? "", requested.slice(2)) : resolve2(process.cwd(), requested);
+  const looksLikeFile = extname(expanded).toLowerCase() in EXTENSIONS;
+  if (looksLikeFile) return expanded;
+  if (isDirectory(expanded) || requested.endsWith("/")) {
+    return resolve2(expanded, `acute-qr.${extension}`);
+  }
+  return `${expanded}.${extension}`;
+}
+function isDirectory(path2) {
+  try {
+    return statSync(path2).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function openFile(path2, warn) {
+  const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    spawn(opener, [path2], { detached: true, stdio: "ignore" }).unref();
+  } catch {
+    warn(`Wrote the file but could not open it with "${opener}".`);
+  }
+}
+
+// src/commands/qr/index.ts
+var qrGroup = {
+  name: "qr",
+  summary: "Acute QR codes: write one, or read one back.",
+  commands: [generate, decode],
+  defaultCommand: "generate"
+};
+
+// src/commands/index.ts
+var GROUPS = [qrGroup, configGroup];
+
+// src/kernel/help.ts
+var BIN = "acute";
+function rootHelp(io, groups, version) {
+  const { bold, dim, accent } = io.style;
+  io.say();
+  io.say(`  ${accent(bold("acute"))} ${dim(version)}`);
+  io.say(`  ${dim("The Acute command line.")}`);
+  io.say();
+  io.say(`  ${bold("USAGE")}`);
+  io.say(`    ${BIN} <command> [options]`);
+  io.say();
+  io.say(`  ${bold("COMMANDS")}`);
+  const width = Math.max(...groups.map((g) => g.name.length));
+  for (const group of groups) {
+    io.say(`    ${group.name.padEnd(width + 2)}${dim(group.summary)}`);
+  }
+  io.say();
+  io.say(`  ${bold("GLOBAL OPTIONS")}`);
+  printOptions(io, GLOBAL_OPTIONS);
+  io.say();
+  io.say(`  ${dim(`Run "${BIN} <command> --help" for what a command takes.`)}`);
+  io.say();
+}
+function groupHelp(io, group) {
+  const { bold, dim, accent } = io.style;
+  io.say();
+  io.say(`  ${accent(bold(`${BIN} ${group.name}`))}`);
+  io.say(`  ${dim(group.summary)}`);
+  io.say();
+  io.say(`  ${bold("COMMANDS")}`);
+  const width = Math.max(...group.commands.map((c) => c.name.length));
+  for (const command of group.commands) {
+    const marker = command.name === group.defaultCommand ? dim(" (default)") : "";
+    io.say(`    ${command.name.padEnd(width + 2)}${dim(command.summary)}${marker}`);
+  }
+  io.say();
+  io.say(`  ${dim(`Run "${BIN} ${group.name} <command> --help" for options.`)}`);
+  io.say();
+}
+function commandHelp(io, group, command) {
+  const { bold, dim, accent } = io.style;
+  io.say();
+  io.say(`  ${accent(bold(`${BIN} ${group.name} ${command.name}`))}`);
+  io.say(`  ${dim(command.summary)}`);
+  io.say();
+  io.say(`  ${bold("USAGE")}`);
+  io.say(`    ${BIN} ${command.usage}`);
+  if (Object.keys(command.options).length > 0) {
+    io.say();
+    io.say(`  ${bold("OPTIONS")}`);
+    printOptions(io, command.options);
+  }
+  if (command.details?.length) {
+    for (const paragraph of command.details) {
+      io.say();
+      io.say(wrap(paragraph, 76, "  "));
+    }
+  }
+  if (command.examples?.length) {
+    io.say();
+    io.say(`  ${bold("EXAMPLES")}`);
+    for (const example of command.examples) io.say(`    ${dim(example)}`);
+  }
+  io.say();
+}
+function printOptions(io, options) {
+  const rows = Object.entries(options).map(
+    ([name, spec]) => [flagLabel(name, spec), spec]
+  );
+  const width = Math.max(...rows.map(([label]) => label.length));
+  for (const [label, spec] of rows) {
+    const fallback = spec.defaultsTo ? io.style.dim(` [${spec.defaultsTo}]`) : "";
+    io.say(`    ${label.padEnd(width + 2)}${io.style.dim(spec.describe)}${fallback}`);
+  }
+}
+function flagLabel(name, spec) {
+  const short = spec.short ? `-${spec.short}, ` : "    ";
+  const value = spec.kind === "string" ? ` <${spec.placeholder ?? "value"}>` : "";
+  return `${short}--${name}${value}`;
+}
+function wrap(text, width, indent) {
+  const words = text.split(/\s+/);
+  const lines = [];
+  let line = "";
+  for (const word of words) {
+    if (line.length + word.length + 1 > width) {
+      lines.push(line);
+      line = word;
+    } else {
+      line = line ? `${line} ${word}` : word;
+    }
+  }
+  if (line) lines.push(line);
+  return lines.map((l) => `${indent}${l}`).join("\n");
+}
+
+// src/kernel/io.ts
+function supportsColor(stream) {
+  if (process.env.NO_COLOR) return false;
+  if (process.env.FORCE_COLOR) return process.env.FORCE_COLOR !== "0";
+  return Boolean(stream.isTTY);
+}
+function makeStyle(enabled) {
+  const wrap2 = (open, close) => (s) => enabled ? `${open}${s}${close}` : s;
+  return {
+    bold: wrap2("\x1B[1m", "\x1B[22m"),
+    dim: wrap2("\x1B[2m", "\x1B[22m"),
+    // The brand purple is #5200A0, which is 1.7:1 on black and unreadable in a
+    // dark terminal. Terminal accents use the secondary purple instead, which
+    // is the same hue at a lightness a terminal can actually show.
+    accent: wrap2(`\x1B[38;2;${rgb(Brand.purpleAccent).join(";")}m`, "\x1B[39m"),
+    red: wrap2("\x1B[31m", "\x1B[39m")
+  };
+}
+function rgb(hex) {
+  const n = Number.parseInt(hex.replace("#", ""), 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+function createIo(options) {
+  const style = makeStyle(supportsColor(process.stdout));
+  const narrate = !options.json && !options.quiet;
+  return {
+    json: options.json,
+    say(line = "") {
+      if (narrate) process.stdout.write(`${line}
+`);
+    },
+    field(label, value) {
+      if (narrate) process.stdout.write(`  ${style.dim(label.padEnd(10))}${value}
+`);
+    },
+    result(value) {
+      if (options.json) process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+    },
+    warn(line) {
+      process.stderr.write(`${line}
+`);
+    },
+    style
+  };
+}
+
+// src/cli.ts
+var VERSION = package_default.version;
+async function run(argv) {
+  const first = argv[0];
+  if (!first || first.startsWith("-")) {
+    const { flags: flags2 } = parse(argv, {});
+    const io2 = createIo({ json: false, quiet: false });
+    if (flags2.version === true) {
+      process.stdout.write(`${VERSION}
+`);
+      return;
+    }
+    rootHelp(io2, GROUPS, VERSION);
+    if (!first) return;
+    if (flags2.help !== true) throw usageError("No command given.");
+    return;
+  }
+  const group = GROUPS.find((g) => g.name === first);
+  if (!group) {
+    const suggestion = nearest(
+      first,
+      GROUPS.map((g) => g.name)
+    );
+    throw usageError(
+      `"${first}" is not an acute command.`,
+      suggestion ? `Did you mean "acute ${suggestion}"?` : 'Run "acute --help" for the list.'
+    );
+  }
+  const rest = argv.slice(1);
+  const named = rest[0] && !rest[0].startsWith("-") ? group.commands.find((c) => c.name === rest[0]) : void 0;
+  const command = named ?? defaultCommandOf(group);
+  const args = named ? rest.slice(1) : rest;
+  const { flags, positionals } = parse(args, command.options);
+  const io = createIo({ json: flags.json === true, quiet: flags.quiet === true });
+  if (flags.help === true) {
+    if (named) commandHelp(io, group, command);
+    else groupHelp(io, group);
+    return;
+  }
+  await command.run({ flags, positionals, config: loadConfig(), io });
+}
+function defaultCommandOf(group) {
+  const fallback = group.commands.find((c) => c.name === group.defaultCommand);
+  if (!fallback) {
+    throw new Error(`Command group "${group.name}" has no default command.`);
+  }
+  return fallback;
+}
+
+// src/bin.ts
+process.stdout.on("error", (error) => {
+  if (error.code === "EPIPE") process.exit(0);
+  throw error;
+});
+async function main() {
+  try {
+    await run(process.argv.slice(2));
+  } catch (error) {
+    const io = createIo({ json: false, quiet: false });
+    const { red, dim } = io.style;
+    if (error instanceof CliError) {
+      io.warn("");
+      io.warn(`  ${red("Error")}  ${error.message}`);
+      if (error.hint) io.warn(`  ${dim(`       ${error.hint}`)}`);
+      io.warn("");
+      process.exitCode = error.exitCode;
+      return;
+    }
+    io.warn("");
+    io.warn(`  ${red("Unexpected error")}  this is a bug in the acute CLI.`);
+    io.warn("");
+    io.warn(error instanceof Error ? error.stack ?? error.message : String(error));
+    io.warn("");
+    process.exitCode = ExitCode.Failure;
+  }
+}
+void main();

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@acutenetwork/cli",
+  "version": "0.1.0",
+  "description": "The command line for Acute.",
+  "license": "MIT",
+  "author": "Acute's Engineering Team <engineering@acute.network>",
+  "homepage": "https://github.com/acutenetwork/acute-cli#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/acutenetwork/acute-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/acutenetwork/acute-cli/issues"
+  },
+  "keywords": [
+    "acute",
+    "cli",
+    "acute-network",
+    "payments",
+    "qr",
+    "qr-code"
+  ],
+  "type": "module",
+  "bin": {
+    "acute": "./dist/bin.js"
+  },
+  "files": [
+    "dist",
+    "assets",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@acutenetwork/fey": "^0.2.2",
+    "jsqr": "^1.4.0",
+    "qrcode-generator": "^1.4.4",
+    "sharp": "^0.35.5"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.12.0",
+    "@types/node": "^22.10.0",
+    "eslint": "^9.12.0",
+    "eslint-config-prettier": "^9.1.0",
+    "prettier": "^3.3.3",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.0",
+    "typescript-eslint": "^8.8.1",
+    "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "type-check": "tsc --noEmit",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "clean": "rm -rf dist"
+  }
+}