@jasy/cli 1.0.0-alpha.1

package/dist/core/pdfa.js

@@ -0,0 +1,47 @@
+// Structural PDF/A-3 + ZUGFeRD/Factur-X conformance checks - pure Node. This is NOT full ISO 19005-3
+// validation (that's veraPDF, Java - offered as an optional adapter). It's the structural / metadata
+// layer that actually trips e-invoice PDFs in practice: the rules our own writer satisfies, read
+// backwards. Great as a regression guard for us and a fast local signal for foreign PDFs.
+export function checkPdfA3(pdf) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const s = Buffer.from(pdf).toString("latin1");
+    const xmp = (_b = (_a = s.match(/<x:xmpmeta[\s\S]*?<\/x:xmpmeta>/)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : "";
+    const checks = [];
+    const add = (id, label, ok, detail) => {
+        checks.push({ id, label, ok, detail });
+    };
+    // header + binary marker (≥4 bytes > 127 on the comment line) - required for PDF/A
+    const version = (_c = s.match(/^%PDF-(\d\.\d)/)) === null || _c === void 0 ? void 0 : _c[1];
+    add("header", "PDF header & version", !!version, version ? `%PDF-${version}` : "missing");
+    const afterHeader = s.slice(s.indexOf("\n") + 1, s.indexOf("\n") + 9);
+    const binaryMarker = afterHeader.startsWith("%") &&
+        Array.from(afterHeader.slice(1, 5)).some((c) => c.charCodeAt(0) > 127);
+    add("binary-marker", "binary marker comment", binaryMarker);
+    // forbidden in PDF/A
+    add("no-encrypt", "not encrypted", !/\/Encrypt\b/.test(s));
+    add("no-javascript", "no JavaScript actions", !/\/JavaScript\b|\/JS\s/.test(s));
+    add("no-lzw", "no LZW compression", !/\/LZWDecode\b/.test(s));
+    // trailer /ID (required)
+    add("file-id", "document /ID present", /\/ID\s*\[\s*<[0-9A-Fa-f]/.test(s));
+    // XMP metadata + PDF/A identification
+    add("xmp", "XMP metadata present", xmp.length > 0);
+    const part = (_d = xmp.match(/pdfaid:part[^0-9]{0,4}(\d)/)) === null || _d === void 0 ? void 0 : _d[1];
+    add("pdfa-part", "declares PDF/A part 3", part === "3", part ? `part ${part}` : "missing");
+    const conformance = (_e = xmp.match(/pdfaid:conformance[^ABU]{0,4}([ABU])/)) === null || _e === void 0 ? void 0 : _e[1];
+    add("pdfa-conformance", "PDF/A conformance level", !!conformance, conformance ? `level ${conformance}` : "missing");
+    // Factur-X / ZUGFeRD XMP extension schema (the e-invoice fingerprint)
+    const fxFile = (_g = (_f = xmp.match(/DocumentFileName[^>]*>\s*([^<\s]+\.xml)/i)) === null || _f === void 0 ? void 0 : _f[1]) !== null && _g !== void 0 ? _g : (/DocumentFileName/i.test(xmp) ? "?" : undefined);
+    add("facturx-xmp", "Factur-X/ZUGFeRD XMP extension", /ConformanceLevel/i.test(xmp) && /DocumentType/i.test(xmp), fxFile);
+    // PDF/A OutputIntent with an embedded ICC profile (needed once colour/transparency is used)
+    add("output-intent", "PDF/A OutputIntent (sRGB ICC)", /\/OutputIntent/.test(s) && /\/DestOutputProfile/.test(s) && /\/S\s*\/GTS_PDFA1/.test(s));
+    // the embedded XML attached as an Associated File with a relationship (ZUGFeRD requirement)
+    add("associated-file", "embedded XML as Associated File", /\/AF\b/.test(s) &&
+        /\/AFRelationship\s*\/(Alternative|Data|Source)/.test(s) &&
+        /\/EF\s*<</.test(s));
+    // every font must be embedded (no font descriptor without a font program)
+    // count the descriptor objects (/Type /FontDescriptor), not the /FontDescriptor ref entries
+    const descriptors = ((_h = s.match(/\/Type\s*\/FontDescriptor\b/g)) !== null && _h !== void 0 ? _h : []).length;
+    const programs = ((_j = s.match(/\/FontFile[23]?\b/g)) !== null && _j !== void 0 ? _j : []).length;
+    add("fonts-embedded", "all fonts embedded", descriptors === 0 || programs >= descriptors, `${programs}/${descriptors} programs`);
+    return { ok: checks.every((c) => c.ok), checks };
+}

package/dist/core/read.d.ts

@@ -0,0 +1,14 @@
+import { type Invoice, type ComputedInvoice } from "@jasy/zugferd";
+import { type InvoiceMeta } from "./detect.js";
+export interface ReadResult {
+    isPdf: boolean;
+    xml: string;
+    meta: InvoiceMeta;
+    /** The parsed invoice (CII supported; UBL coming) - undefined if the syntax can't be parsed yet. */
+    invoice?: Invoice;
+    /** Totals derived from `invoice` (net, VAT, gross …). */
+    totals?: ComputedInvoice;
+}
+/** Read an e-invoice from raw bytes - a PDF (embedded XML extracted) or raw XML (used as-is). */
+export declare function readInvoice(data: Uint8Array): ReadResult;
+export declare function readInvoiceFile(path: string): ReadResult;

package/dist/core/read.js

@@ -0,0 +1,25 @@
+import { readFileSync } from "node:fs";
+import { computeInvoice } from "@jasy/zugferd";
+import { extractEmbeddedXml } from "./extract.js";
+import { detectInvoice } from "./detect.js";
+import { parseInvoice } from "./parse.js";
+/** Read an e-invoice from raw bytes - a PDF (embedded XML extracted) or raw XML (used as-is). */
+export function readInvoice(data) {
+    const buf = Buffer.from(data);
+    const isPdf = buf.subarray(0, 5).toString("latin1") === "%PDF-";
+    const xml = isPdf ? extractEmbeddedXml(buf) : buf.toString("utf-8");
+    const meta = detectInvoice(xml);
+    let invoice;
+    let totals;
+    try {
+        invoice = parseInvoice(xml); // throws for not-yet-supported syntaxes
+        totals = computeInvoice(invoice);
+    }
+    catch (_a) {
+        /* leave the parsed view empty - the raw XML + detection still work */
+    }
+    return { isPdf, xml, meta, invoice, totals };
+}
+export function readInvoiceFile(path) {
+    return readInvoice(readFileSync(path));
+}

package/dist/core/validate.d.ts

@@ -0,0 +1,18 @@
+import type { InvoiceMeta } from "./detect.js";
+export type ValidationProfile = "en16931-cii" | "en16931-ubl" | "xrechnung-cii" | "xrechnung-ubl";
+export interface Violation {
+    id?: string;
+    test?: string;
+    location?: string;
+    text: string;
+}
+export interface ValidationReport {
+    profile: ValidationProfile;
+    valid: boolean;
+    errors: Violation[];
+    warnings: Violation[];
+}
+/** The profile that matches what detect() found - picks the right syntax + CIUS automatically. */
+export declare function profileFor(meta: InvoiceMeta): ValidationProfile;
+/** Validate invoice XML against a profile's Schematron rules → a structured pass/fail report. */
+export declare function validateInvoiceXml(xml: string, profile: ValidationProfile): ValidationReport;

package/dist/core/validate.js

@@ -0,0 +1,65 @@
+import { readFileSync } from "node:fs";
+import { gunzipSync } from "node:zlib";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import SaxonJS from "saxon-js";
+// Which rule sets to run for a profile. XRechnung is a CIUS *on top of* EN 16931, so its files carry
+// only the BR-DE delta - we run the EN 16931 base AND the XRechnung rules and merge the findings.
+const RULE_SETS = {
+    "en16931-cii": ["en16931-cii"],
+    "en16931-ubl": ["en16931-ubl"],
+    "xrechnung-cii": ["en16931-cii", "xrechnung-cii"],
+    "xrechnung-ubl": ["en16931-ubl", "xrechnung-ubl"],
+};
+const RULES_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "assets", "validation");
+/** The profile that matches what detect() found - picks the right syntax + CIUS automatically. */
+export function profileFor(meta) {
+    const ubl = meta.syntax === "UBL";
+    if (meta.profile === "xrechnung")
+        return ubl ? "xrechnung-ubl" : "xrechnung-cii";
+    return ubl ? "en16931-ubl" : "en16931-cii";
+}
+function runRuleSet(set, xml) {
+    var _a;
+    const sef = gunzipSync(readFileSync(join(RULES_DIR, `${set}.sef.json.gz`))).toString("utf-8");
+    const out = SaxonJS.transform({ stylesheetText: sef, sourceText: xml, destination: "serialized" }, "sync");
+    return parseSvrl((_a = out.principalResult) !== null && _a !== void 0 ? _a : "");
+}
+/** Validate invoice XML against a profile's Schematron rules → a structured pass/fail report. */
+export function validateInvoiceXml(xml, profile) {
+    const errors = [];
+    const warnings = [];
+    for (const set of RULE_SETS[profile]) {
+        const r = runRuleSet(set, xml);
+        errors.push(...r.errors);
+        warnings.push(...r.warnings);
+    }
+    return { profile, valid: errors.length === 0, errors, warnings };
+}
+// The rules emit SVRL (Schematron Validation Report Language). Each <svrl:failed-assert> is a violation;
+// flag="warning" downgrades it. Regex is enough for this well-formed machine output.
+function parseSvrl(svrl) {
+    var _a, _b, _c, _d, _e;
+    const errors = [];
+    const warnings = [];
+    const re = /<svrl:failed-assert\b([^>]*)>([\s\S]*?)<\/svrl:failed-assert>/g;
+    for (let m = re.exec(svrl); m; m = re.exec(svrl)) {
+        const flag = (_b = (_a = attr(m[1], "flag")) !== null && _a !== void 0 ? _a : attr(m[1], "role")) !== null && _b !== void 0 ? _b : "fatal";
+        const text = ((_d = (_c = m[2].match(/<svrl:text>([\s\S]*?)<\/svrl:text>/)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : "")
+            .replace(/\s+/g, " ")
+            .trim();
+        const violation = {
+            id: (_e = text.match(/\[((?:BR|BG)-?[A-Z0-9-]+)\]/)) === null || _e === void 0 ? void 0 : _e[1],
+            test: attr(m[1], "test"),
+            location: attr(m[1], "location"),
+            text,
+        };
+        // only fatal asserts fail validity; warning/information are advisory (Schematron flag levels)
+        (/warn|info/i.test(flag) ? warnings : errors).push(violation);
+    }
+    return { errors, warnings };
+}
+function attr(s, name) {
+    var _a;
+    return (_a = s.match(new RegExp(`\\b${name}="([^"]*)"`))) === null || _a === void 0 ? void 0 : _a[1];
+}

package/dist/core/verapdf.d.ts

@@ -0,0 +1,26 @@
+export declare const VERAPDF_HOME: string;
+export interface Tools {
+    java?: string;
+    verapdf?: string;
+    verapdfPath?: string;
+}
+/** The veraPDF binary we'd use: our managed install first, then any system install on PATH. */
+export declare function findVerapdf(): string | undefined;
+/** What's available right now - drives the `jasy verapdf` doctor. */
+export declare function detectTools(): Tools;
+export interface VeraReport {
+    ok: boolean;
+    profile?: string;
+    passedRules?: number;
+    failedRules?: number;
+    failures: {
+        clause: string;
+        failedChecks: number;
+    }[];
+}
+/** Parse veraPDF's `--format xml` report (the real 1.30 shape - verified against live output). */
+export declare function parseVeraReport(xml: string): VeraReport;
+/** Run veraPDF on a PDF (auto-detecting the PDF/A flavour) and return the parsed report. */
+export declare function runVeraPdf(file: string, bin?: string | undefined): VeraReport;
+/** Download + headless-install veraPDF into ~/.jasy/verapdf. `log` streams progress to the UI. */
+export declare function installVeraPdf(log: (s: string) => void): Promise<string>;

package/dist/core/verapdf.js

@@ -0,0 +1,161 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { inflateRawSync } from "node:zlib";
+// Optional veraPDF adapter. veraPDF (verapdf.org) is the official open-source PDF/A validator from the
+// PDF Association - we shell out to a local copy for the FULL ISO 19005 (PDF/A) check. It is NEVER a
+// gate: our own structural checks (core/pdfa.ts) carry the everyday case; this is the opt-in "official
+// seal". Self-contained: `--install` drops veraPDF into ~/.jasy/verapdf (no admin, no account). The one
+// real requirement is a Java runtime - veraPDF is a Java app - which the doctor flags clearly.
+const WIN = process.platform === "win32";
+export const VERAPDF_HOME = join(homedir(), ".jasy", "verapdf");
+const MANAGED_BIN = join(VERAPDF_HOME, WIN ? "verapdf.bat" : "verapdf");
+const INSTALLER_URL = "https://software.verapdf.org/releases/verapdf-installer.zip";
+/** The veraPDF binary we'd use: our managed install first, then any system install on PATH. */
+export function findVerapdf() {
+    if (existsSync(MANAGED_BIN))
+        return MANAGED_BIN;
+    const r = spawnSync(WIN ? "where" : "which", ["verapdf"], { encoding: "utf-8" });
+    const p = r.status === 0 ? r.stdout.split(/\r?\n/)[0].trim() : "";
+    return p || undefined;
+}
+/** What's available right now - drives the `jasy verapdf` doctor. */
+export function detectTools() {
+    var _a, _b, _c, _d;
+    const jv = spawnSync("java", ["-version"], { encoding: "utf-8" }); // java prints the version to stderr
+    const java = jv.error
+        ? undefined
+        : ((_b = (_a = (jv.stderr || jv.stdout).match(/version "([^"]+)"/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : "found");
+    const verapdfPath = findVerapdf();
+    let verapdf;
+    if (verapdfPath) {
+        const vv = spawnSync(verapdfPath, ["--version"], { encoding: "utf-8" });
+        verapdf = vv.error ? undefined : ((_d = (_c = vv.stdout.match(/veraPDF (\S+)/)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : "found");
+    }
+    return { java, verapdf, verapdfPath };
+}
+/** Parse veraPDF's `--format xml` report (the real 1.30 shape - verified against live output). */
+export function parseVeraReport(xml) {
+    var _a;
+    const ok = /isCompliant="true"/.test(xml);
+    const det = xml.match(/passedRules="(\d+)"\s+failedRules="(\d+)"/);
+    const failures = [
+        ...xml.matchAll(/<rule\b[^>]*\bclause="([^"]*)"[^>]*\bstatus="failed"[^>]*\bfailedChecks="(\d+)"/g),
+    ].map((m) => ({ clause: m[1], failedChecks: Number(m[2]) }));
+    return {
+        ok,
+        profile: (_a = xml.match(/profileName="([^"]*)"/)) === null || _a === void 0 ? void 0 : _a[1],
+        passedRules: det ? Number(det[1]) : undefined,
+        failedRules: det ? Number(det[2]) : undefined,
+        failures,
+    };
+}
+/** Run veraPDF on a PDF (auto-detecting the PDF/A flavour) and return the parsed report. */
+export function runVeraPdf(file, bin = findVerapdf()) {
+    var _a;
+    if (!bin)
+        throw new Error("veraPDF is not installed - run `jasy verapdf --install`");
+    const r = spawnSync(bin, ["--format", "xml", file], {
+        encoding: "utf-8",
+        maxBuffer: 64 * 1024 * 1024,
+    });
+    if (r.error)
+        throw r.error; // e.g. Java missing - the verapdf launcher couldn't start
+    const xml = (_a = r.stdout) !== null && _a !== void 0 ? _a : "";
+    if (!xml.includes("<validationReport")) {
+        throw new Error("veraPDF returned no report" + (r.stderr ? `: ${r.stderr.split("\n")[0]}` : ""));
+    }
+    return parseVeraReport(xml);
+}
+// ── self-contained install into ~/.jasy/verapdf (no admin, no installer GUI) ────────────────────────
+/** Extract one entry from a ZIP by name, via the central directory (robust vs data descriptors). */
+function extractFromZip(zip, pattern) {
+    let eo = zip.length - 22;
+    while (eo >= 0 && zip.readUInt32LE(eo) !== 0x06054b50)
+        eo--; // end-of-central-directory record
+    if (eo < 0)
+        return undefined;
+    let cd = zip.readUInt32LE(eo + 16);
+    const count = zip.readUInt16LE(eo + 10);
+    for (let k = 0; k < count && zip.readUInt32LE(cd) === 0x02014b50; k++) {
+        const method = zip.readUInt16LE(cd + 10);
+        const comp = zip.readUInt32LE(cd + 20);
+        const nameLen = zip.readUInt16LE(cd + 28);
+        const extraLen = zip.readUInt16LE(cd + 30);
+        const commentLen = zip.readUInt16LE(cd + 32);
+        const lho = zip.readUInt32LE(cd + 42);
+        const name = zip.subarray(cd + 46, cd + 46 + nameLen).toString("utf-8");
+        if (pattern.test(name)) {
+            const dataStart = lho + 30 + zip.readUInt16LE(lho + 26) + zip.readUInt16LE(lho + 28);
+            const body = zip.subarray(dataStart, dataStart + comp);
+            return method === 8 ? inflateRawSync(body) : Buffer.from(body);
+        }
+        cd += 46 + nameLen + extraLen + commentLen;
+    }
+    return undefined;
+}
+/** veraPDF's IzPack auto-install descriptor - installs the CLI (no GUI prompts) into `home`. */
+function autoInstallXml(home) {
+    return `<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<AutomatedInstallation langpack="eng">
+    <com.izforge.izpack.panels.htmlhello.HTMLHelloPanel id="welcome"/>
+    <com.izforge.izpack.panels.target.TargetPanel id="install_dir"><installpath>${home}</installpath></com.izforge.izpack.panels.target.TargetPanel>
+    <com.izforge.izpack.panels.packs.PacksPanel id="sdk_pack_select">
+        <pack index="0" name="veraPDF GUI" selected="true"/>
+        <pack index="1" name="veraPDF Mac and *nix Scripts" selected="true"/>
+        <pack index="2" name="veraPDF Batch files" selected="true"/>
+        <pack index="3" name="veraPDF Sample Files" selected="false"/>
+        <pack index="4" name="Documentation" selected="false"/>
+    </com.izforge.izpack.panels.packs.PacksPanel>
+    <com.izforge.izpack.panels.install.InstallPanel id="install"/>
+    <com.izforge.izpack.panels.finish.SimpleFinishPanel id="finish"/>
+</AutomatedInstallation>`;
+}
+/** Download + headless-install veraPDF into ~/.jasy/verapdf. `log` streams progress to the UI. */
+export function installVeraPdf(log) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tools = detectTools();
+        if (!tools.java) {
+            throw new Error("Java is required (veraPDF is a Java app). Install a JRE 11+ first, then re-run `jasy verapdf --install`.");
+        }
+        log(`Java ${tools.java} found.`);
+        const tmp = mkdtempSync(join(tmpdir(), "jasy-vera-"));
+        try {
+            log("Downloading veraPDF (~33 MB) ...");
+            const res = yield fetch(INSTALLER_URL);
+            if (!res.ok)
+                throw new Error(`download failed: HTTP ${res.status}`);
+            const zip = Buffer.from(yield res.arrayBuffer());
+            log("Extracting the installer ...");
+            const jar = extractFromZip(zip, /izpack-installer-[^/]*\.jar$/);
+            if (!jar)
+                throw new Error("could not find the veraPDF installer inside the download");
+            const jarPath = join(tmp, "installer.jar");
+            const xmlPath = join(tmp, "auto-install.xml");
+            writeFileSync(jarPath, jar);
+            writeFileSync(xmlPath, autoInstallXml(VERAPDF_HOME));
+            rmSync(VERAPDF_HOME, { recursive: true, force: true }); // clean (re)install
+            log(`Installing into ${VERAPDF_HOME} ...`);
+            const r = spawnSync("java", ["-Djava.awt.headless=true", "-jar", jarPath, xmlPath], {
+                encoding: "utf-8",
+            });
+            if (!existsSync(MANAGED_BIN)) {
+                throw new Error("install did not complete: " + (r.stderr || r.stdout || "").split("\n").slice(-3).join(" "));
+            }
+            return MANAGED_BIN;
+        }
+        finally {
+            rmSync(tmp, { recursive: true, force: true });
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { readCommand } from "./commands/read.js";
+import { validateCommand } from "./commands/validate.js";
+import { exportCommand } from "./commands/export.js";
+import { verapdfCommand } from "./commands/verapdf.js";
+import { launchTui } from "./tui/app.js";
+// jasy CLI entry. With a command (e.g. `jasy read invoice.pdf`) it runs non-interactively and exits;
+// with no command it opens the interactive JANO terminal.
+const argv = process.argv.slice(2);
+const cmd = argv[0];
+// run a command and return true (then we exit), or open the interactive TUI and return false (it owns
+// the process). Wrapped in an async fn so `verapdf` can await without needing top-level await.
+function dispatch() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (cmd === "read") {
+            readCommand(argv.slice(1));
+            return true;
+        }
+        if (cmd === "validate") {
+            validateCommand(argv.slice(1));
+            return true;
+        }
+        if (cmd === "export") {
+            exportCommand(argv.slice(1));
+            return true;
+        }
+        if (cmd === "verapdf") {
+            yield verapdfCommand(argv.slice(1));
+            return true;
+        }
+        // shorthand: `jasy some-invoice.pdf` == `jasy read some-invoice.pdf`
+        if (cmd && /\.(pdf|xml)$/i.test(cmd)) {
+            readCommand(argv);
+            return true;
+        }
+        if (cmd === "-h" || cmd === "--help") {
+            printHelp();
+            return true;
+        }
+        launchTui();
+        return false;
+    });
+}
+void dispatch().then((done) => {
+    var _a;
+    if (done)
+        process.exit((_a = process.exitCode) !== null && _a !== void 0 ? _a : 0);
+});
+function printHelp() {
+    console.log(`jasy - ZUGFeRD / XRechnung terminal
+
+usage:
+  jasy                        open the interactive terminal
+  jasy read <file>            read a PDF/XML invoice and show what it is
+  jasy read <file> --xml      print the embedded XML to stdout
+  jasy read <file> -o x.xml   save the embedded XML to a file
+  jasy validate <file>        check EN 16931 rules + PDF/A-3 structure (exit 1 if invalid)
+  jasy validate <file> -v     also list every passing check
+  jasy export <file> -f json  write the invoice as JSON (or txt) to stdout
+  jasy export <file> -o x.xlsx export the invoice as a spreadsheet
+  jasy verapdf                check the optional full-ISO PDF/A validator (veraPDF)
+  jasy verapdf --install      install veraPDF locally for the full PDF/A check
+`);
+}

package/dist/tui/app.d.ts

@@ -0,0 +1 @@
+export declare function launchTui(): void;