kynjal-cli 4.0.0 → 4.0.2

package/dist/src/appliance/rvfa-signing.js

@@ -6,59 +6,12 @@
  *
  * @module @claude-flow/cli/appliance/rvfa-signing
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-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());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import { generateKeyPairSync, createHash, sign, verify, createPublicKey, createPrivateKey, } from 'node:crypto';
 import { readFile, writeFile, stat, chmod, mkdir } from 'node:fs/promises';
 // ── Constants ────────────────────────────────────────────────
-var PREAMBLE_SIZE = 12; // 4B magic + 4B version + 4B header_len
-var SHA256_SIZE = 32;
-var KEY_FILE_MODE = 384;
+const PREAMBLE_SIZE = 12; // 4B magic + 4B version + 4B header_len
+const SHA256_SIZE = 32;
+const KEY_FILE_MODE = 0o600;
 // ── Key Management ───────────────────────────────────────────
 /** Compute the fingerprint of a public key: first 16 hex chars of its SHA256. */
 function computeFingerprint(publicKeyPem) {
@@ -70,20 +23,15 @@ function computeFingerprint(publicKeyPem) {
 /**
  * Generate a new Ed25519 key pair for RVFA signing.
  */
-export function generateKeyPair() {
-    return __awaiter(this, void 0, Promise, function () {
-        var _a, publicKey, privateKey, pubBuf, privBuf, fingerprint;
-        return __generator(this, function (_b) {
-            _a = generateKeyPairSync('ed25519', {
-                publicKeyEncoding: { type: 'spki', format: 'pem' },
-                privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
-            }), publicKey = _a.publicKey, privateKey = _a.privateKey;
-            pubBuf = Buffer.from(publicKey, 'utf-8');
-            privBuf = Buffer.from(privateKey, 'utf-8');
-            fingerprint = computeFingerprint(publicKey);
-            return [2 /*return*/, { publicKey: pubBuf, privateKey: privBuf, fingerprint: fingerprint }];
-        });
+export async function generateKeyPair() {
+    const { publicKey, privateKey } = generateKeyPairSync('ed25519', {
+        publicKeyEncoding: { type: 'spki', format: 'pem' },
+        privateKeyEncoding: { type: 'pkcs8', format: 'pem' },
     });
+    const pubBuf = Buffer.from(publicKey, 'utf-8');
+    const privBuf = Buffer.from(privateKey, 'utf-8');
+    const fingerprint = computeFingerprint(publicKey);
+    return { publicKey: pubBuf, privateKey: privBuf, fingerprint };
 }
 /**
  * Save a key pair to disk as PEM files.
@@ -93,32 +41,15 @@ export function generateKeyPair() {
  * @param name     Base name for the key files (default: 'rvfa-signing').
  * @returns Paths to the written public and private key files.
  */
-export function saveKeyPair(keyPair, dir, name) {
-    if (name === void 0) { name = 'rvfa-signing'; }
-    return __awaiter(this, void 0, Promise, function () {
-        var pubPath, privPath;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, mkdir(dir, { recursive: true })];
-                case 1:
-                    _a.sent();
-                    pubPath = dir + "/" + name + ".pub";
-                    privPath = dir + "/" + name + ".key";
-                    return [4 /*yield*/, writeFile(pubPath, keyPair.publicKey)];
-                case 2:
-                    _a.sent();
-                    return [4 /*yield*/, writeFile(privPath, keyPair.privateKey, { mode: KEY_FILE_MODE })];
-                case 3:
-                    _a.sent();
-                    // Ensure private key has restrictive permissions even on existing files
-                    return [4 /*yield*/, chmod(privPath, KEY_FILE_MODE)];
-                case 4:
-                    // Ensure private key has restrictive permissions even on existing files
-                    _a.sent();
-                    return [2 /*return*/, { publicKeyPath: pubPath, privateKeyPath: privPath }];
-            }
-        });
-    });
+export async function saveKeyPair(keyPair, dir, name = 'rvfa-signing') {
+    await mkdir(dir, { recursive: true });
+    const pubPath = `${dir}/${name}.pub`;
+    const privPath = `${dir}/${name}.key`;
+    await writeFile(pubPath, keyPair.publicKey);
+    await writeFile(privPath, keyPair.privateKey, { mode: KEY_FILE_MODE });
+    // Ensure private key has restrictive permissions even on existing files
+    await chmod(privPath, KEY_FILE_MODE);
+    return { publicKeyPath: pubPath, privateKeyPath: privPath };
 }
 /**
  * Load a key pair from PEM files on disk.
@@ -126,44 +57,26 @@ export function saveKeyPair(keyPair, dir, name) {
  * @param dir   Directory containing the key files.
  * @param name  Base name for the key files (default: 'rvfa-signing').
  */
-export function loadKeyPair(dir, name) {
-    if (name === void 0) { name = 'rvfa-signing'; }
-    return __awaiter(this, void 0, Promise, function () {
-        var pubPath, privPath, publicKey, privateKey, privStat, mode, fingerprint;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    pubPath = dir + "/" + name + ".pub";
-                    privPath = dir + "/" + name + ".key";
-                    return [4 /*yield*/, readFile(pubPath)];
-                case 1:
-                    publicKey = _a.sent();
-                    return [4 /*yield*/, readFile(privPath)];
-                case 2:
-                    privateKey = _a.sent();
-                    return [4 /*yield*/, stat(privPath)];
-                case 3:
-                    privStat = _a.sent();
-                    mode = privStat.mode & 511;
-                    if (mode & 63) {
-                        console.warn("[rvfa-signing] WARNING: Private key " + privPath + " has open permissions " +
-                            ("(" + mode.toString(8) + "). Consider running: chmod 600 " + privPath));
-                    }
-                    fingerprint = computeFingerprint(publicKey.toString('utf-8'));
-                    return [2 /*return*/, { publicKey: publicKey, privateKey: privateKey, fingerprint: fingerprint }];
-            }
-        });
-    });
+export async function loadKeyPair(dir, name = 'rvfa-signing') {
+    const pubPath = `${dir}/${name}.pub`;
+    const privPath = `${dir}/${name}.key`;
+    const publicKey = await readFile(pubPath);
+    const privateKey = await readFile(privPath);
+    // Warn if private key permissions are too open
+    const privStat = await stat(privPath);
+    const mode = privStat.mode & 0o777;
+    if (mode & 0o077) {
+        console.warn(`[rvfa-signing] WARNING: Private key ${privPath} has open permissions ` +
+            `(${mode.toString(8)}). Consider running: chmod 600 ${privPath}`);
+    }
+    const fingerprint = computeFingerprint(publicKey.toString('utf-8'));
+    return { publicKey, privateKey, fingerprint };
 }
 /**
  * Load a public key from a single PEM file.
  */
-export function loadPublicKey(path) {
-    return __awaiter(this, void 0, Promise, function () {
-        return __generator(this, function (_a) {
-            return [2 /*return*/, readFile(path)];
-        });
-    });
+export async function loadPublicKey(path) {
+    return readFile(path);
 }
 // ── Internal Helpers ─────────────────────────────────────────
 /**
@@ -171,11 +84,10 @@ export function loadPublicKey(path) {
  * Produces deterministic output regardless of insertion order.
  */
 function canonicalJson(value) {
-    return JSON.stringify(value, function (_key, val) {
+    return JSON.stringify(value, (_key, val) => {
         if (val !== null && typeof val === 'object' && !Array.isArray(val) && !Buffer.isBuffer(val)) {
-            var sorted = {};
-            for (var _i = 0, _a = Object.keys(val).sort(); _i < _a.length; _i++) {
-                var k = _a[_i];
+            const sorted = {};
+            for (const k of Object.keys(val).sort()) {
                 sorted[k] = val[k];
             }
             return sorted;
@@ -191,27 +103,27 @@ function parseRvfaBinary(buf) {
     if (buf.length < PREAMBLE_SIZE + SHA256_SIZE) {
         throw new Error('Buffer too small to be a valid RVFA file');
     }
-    var magic = buf.subarray(0, 4).toString('ascii');
+    const magic = buf.subarray(0, 4).toString('ascii');
     if (magic !== 'RVFA') {
-        throw new Error("Invalid RVFA magic: expected \"RVFA\", got \"" + magic + "\"");
+        throw new Error(`Invalid RVFA magic: expected "RVFA", got "${magic}"`);
     }
-    var headerLen = buf.readUInt32LE(8);
-    var headerStart = PREAMBLE_SIZE;
-    var headerEnd = headerStart + headerLen;
+    const headerLen = buf.readUInt32LE(8);
+    const headerStart = PREAMBLE_SIZE;
+    const headerEnd = headerStart + headerLen;
     if (headerEnd > buf.length - SHA256_SIZE) {
         throw new Error('Header length extends beyond buffer');
     }
-    var headerJson = buf.subarray(headerStart, headerEnd).toString('utf-8');
-    var header;
+    const headerJson = buf.subarray(headerStart, headerEnd).toString('utf-8');
+    let header;
     try {
         header = JSON.parse(headerJson);
     }
-    catch (_a) {
+    catch {
         throw new Error('Failed to parse RVFA header JSON');
     }
-    var footer = buf.subarray(buf.length - SHA256_SIZE);
-    var sectionData = buf.subarray(headerEnd, buf.length - SHA256_SIZE);
-    return { header: header, headerStart: headerStart, headerEnd: headerEnd, sectionData: sectionData, footer: footer };
+    const footer = buf.subarray(buf.length - SHA256_SIZE);
+    const sectionData = buf.subarray(headerEnd, buf.length - SHA256_SIZE);
+    return { header, headerStart, headerEnd, sectionData, footer };
 }
 /**
  * Compute the signing digest for an RVFA file.
@@ -222,9 +134,9 @@ function parseRvfaBinary(buf) {
  */
 function computeSigningDigest(header, sectionData, footer) {
     // Strip signature field from header for digest computation
-    var stripped = __assign({}, header);
+    const stripped = { ...header };
     delete stripped.signature;
-    var canonical = Buffer.from(canonicalJson(stripped), 'utf-8');
+    const canonical = Buffer.from(canonicalJson(stripped), 'utf-8');
     return createHash('sha256')
         .update(canonical)
         .update(sectionData)
@@ -233,12 +145,12 @@ function computeSigningDigest(header, sectionData, footer) {
 }
 /** Convert a Buffer or PEM string into a KeyObject. */
 function toPrivateKeyObject(key) {
-    var pem = Buffer.isBuffer(key) ? key.toString('utf-8') : key;
+    const pem = Buffer.isBuffer(key) ? key.toString('utf-8') : key;
     return createPrivateKey(pem);
 }
 /** Convert a Buffer or PEM string into a KeyObject. */
 function toPublicKeyObject(key) {
-    var pem = Buffer.isBuffer(key) ? key.toString('utf-8') : key;
+    const pem = Buffer.isBuffer(key) ? key.toString('utf-8') : key;
     return createPublicKey(pem);
 }
 /**
@@ -248,9 +160,9 @@ function toPublicKeyObject(key) {
  * and keeps section data and footer intact.
  */
 function rebuildRvfa(originalBuf, newHeader, sectionData, footer) {
-    var headerJson = Buffer.from(JSON.stringify(newHeader), 'utf-8');
+    const headerJson = Buffer.from(JSON.stringify(newHeader), 'utf-8');
     // Preamble: magic + version + new header length
-    var preamble = Buffer.alloc(PREAMBLE_SIZE);
+    const preamble = Buffer.alloc(PREAMBLE_SIZE);
     originalBuf.copy(preamble, 0, 0, 8); // magic + version unchanged
     preamble.writeUInt32LE(headerJson.length, 8);
     return Buffer.concat([preamble, headerJson, sectionData, footer]);
@@ -259,11 +171,14 @@ function rebuildRvfa(originalBuf, newHeader, sectionData, footer) {
 /**
  * Signs RVFA appliance files and data with Ed25519.
  */
-var RvfaSigner = /** @class */ (function () {
-    function RvfaSigner(privateKey) {
+export class RvfaSigner {
+    keyObj;
+    fingerprint;
+    constructor(privateKey) {
         this.keyObj = toPrivateKeyObject(privateKey);
         // Derive public key to compute fingerprint
-        var pubPem = createPublicKey(this.keyObj)["export"]({ type: 'spki', format: 'pem' });
+        const pubPem = createPublicKey(this.keyObj)
+            .export({ type: 'spki', format: 'pem' });
         this.fingerprint = computeFingerprint(pubPem);
     }
     /**
@@ -281,81 +196,62 @@ var RvfaSigner = /** @class */ (function () {
      * @param signedBy   Optional publisher name.
      * @returns The signature metadata that was embedded.
      */
-    RvfaSigner.prototype.signAppliance = function (rvfaPath, signedBy) {
-        return __awaiter(this, void 0, Promise, function () {
-            var buf, _a, header, sectionData, footer, digest, sig, metadata, rebuilt;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, readFile(rvfaPath)];
-                    case 1:
-                        buf = _b.sent();
-                        _a = parseRvfaBinary(buf), header = _a.header, sectionData = _a.sectionData, footer = _a.footer;
-                        digest = computeSigningDigest(header, sectionData, footer);
-                        sig = sign(null, digest, this.keyObj);
-                        metadata = {
-                            algorithm: 'ed25519',
-                            publicKeyFingerprint: this.fingerprint,
-                            signature: sig.toString('hex'),
-                            signedAt: new Date().toISOString(),
-                            signedBy: signedBy,
-                            scope: 'full'
-                        };
-                        // Embed signature in header and rebuild
-                        header.signature = metadata;
-                        rebuilt = rebuildRvfa(buf, header, sectionData, footer);
-                        return [4 /*yield*/, writeFile(rvfaPath, rebuilt)];
-                    case 2:
-                        _b.sent();
-                        return [2 /*return*/, metadata];
-                }
-            });
-        });
-    };
+    async signAppliance(rvfaPath, signedBy) {
+        const buf = await readFile(rvfaPath);
+        const { header, sectionData, footer } = parseRvfaBinary(buf);
+        // Compute digest over header (without signature) + sections + footer
+        const digest = computeSigningDigest(header, sectionData, footer);
+        // Ed25519 sign
+        const sig = sign(null, digest, this.keyObj);
+        const metadata = {
+            algorithm: 'ed25519',
+            publicKeyFingerprint: this.fingerprint,
+            signature: sig.toString('hex'),
+            signedAt: new Date().toISOString(),
+            signedBy,
+            scope: 'full',
+        };
+        // Embed signature in header and rebuild
+        header.signature = metadata;
+        const rebuilt = rebuildRvfa(buf, header, sectionData, footer);
+        await writeFile(rvfaPath, rebuilt);
+        return metadata;
+    }
     /**
      * Sign a section footer hash (detached signature).
      *
      * @param footerHash  The 32-byte SHA256 footer hash from an RVFA file.
      * @returns Hex-encoded Ed25519 signature.
      */
-    RvfaSigner.prototype.signSections = function (footerHash) {
-        return __awaiter(this, void 0, Promise, function () {
-            var sig;
-            return __generator(this, function (_a) {
-                if (footerHash.length !== SHA256_SIZE) {
-                    throw new Error("Footer hash must be " + SHA256_SIZE + " bytes, got " + footerHash.length);
-                }
-                sig = sign(null, footerHash, this.keyObj);
-                return [2 /*return*/, sig.toString('hex')];
-            });
-        });
-    };
+    async signSections(footerHash) {
+        if (footerHash.length !== SHA256_SIZE) {
+            throw new Error(`Footer hash must be ${SHA256_SIZE} bytes, got ${footerHash.length}`);
+        }
+        const sig = sign(null, footerHash, this.keyObj);
+        return sig.toString('hex');
+    }
     /**
      * Sign an RVFP patch file (detached signature).
      *
      * @param patchData  The raw patch binary data.
      * @returns Hex-encoded Ed25519 signature.
      */
-    RvfaSigner.prototype.signPatch = function (patchData) {
-        return __awaiter(this, void 0, Promise, function () {
-            var digest, sig;
-            return __generator(this, function (_a) {
-                digest = createHash('sha256').update(patchData).digest();
-                sig = sign(null, digest, this.keyObj);
-                return [2 /*return*/, sig.toString('hex')];
-            });
-        });
-    };
-    return RvfaSigner;
-}());
-export { RvfaSigner };
+    async signPatch(patchData) {
+        const digest = createHash('sha256').update(patchData).digest();
+        const sig = sign(null, digest, this.keyObj);
+        return sig.toString('hex');
+    }
+}
 // ── RvfaVerifier ─────────────────────────────────────────────
 /**
  * Verifies Ed25519 signatures on RVFA appliance files and data.
  */
-var RvfaVerifier = /** @class */ (function () {
-    function RvfaVerifier(publicKey) {
+export class RvfaVerifier {
+    keyObj;
+    fingerprint;
+    constructor(publicKey) {
         this.keyObj = toPublicKeyObject(publicKey);
-        var pem = Buffer.isBuffer(publicKey) ? publicKey.toString('utf-8') : publicKey;
+        const pem = Buffer.isBuffer(publicKey) ? publicKey.toString('utf-8') : publicKey;
         this.fingerprint = computeFingerprint(pem);
     }
     /**
@@ -364,106 +260,88 @@ var RvfaVerifier = /** @class */ (function () {
      * @param rvfaPath  Path to the .rvf appliance file.
      * @returns Verification result with details and any errors.
      */
-    RvfaVerifier.prototype.verifyAppliance = function (rvfaPath) {
-        return __awaiter(this, void 0, Promise, function () {
-            var errors, buf, err_1, parsed, header, sectionData, footer, sigRaw, sigMeta, digest, sigBuf, valid;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        errors = [];
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, readFile(rvfaPath)];
-                    case 2:
-                        buf = _a.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        err_1 = _a.sent();
-                        return [2 /*return*/, { valid: false, errors: ["Failed to read file: " + err_1.message] }];
-                    case 4:
-                        try {
-                            parsed = parseRvfaBinary(buf);
-                        }
-                        catch (err) {
-                            return [2 /*return*/, { valid: false, errors: ["Invalid RVFA file: " + err.message] }];
-                        }
-                        header = parsed.header, sectionData = parsed.sectionData, footer = parsed.footer;
-                        sigRaw = header.signature;
-                        if (!sigRaw || typeof sigRaw !== 'object') {
-                            return [2 /*return*/, { valid: false, errors: ['No signature found in RVFA header'] }];
-                        }
-                        sigMeta = sigRaw;
-                        if (sigMeta.algorithm !== 'ed25519') {
-                            errors.push("Unsupported algorithm: " + String(sigMeta.algorithm));
-                            return [2 /*return*/, { valid: false, errors: errors }];
-                        }
-                        if (typeof sigMeta.signature !== 'string' || !sigMeta.signature) {
-                            errors.push('Signature field is missing or empty');
-                            return [2 /*return*/, { valid: false, errors: errors }];
-                        }
-                        digest = computeSigningDigest(header, sectionData, footer);
-                        try {
-                            sigBuf = Buffer.from(sigMeta.signature, 'hex');
-                        }
-                        catch (_b) {
-                            errors.push('Signature is not valid hex');
-                            return [2 /*return*/, { valid: false, errors: errors }];
-                        }
-                        try {
-                            valid = verify(null, digest, this.keyObj, sigBuf);
-                        }
-                        catch (err) {
-                            errors.push("Verification error: " + err.message);
-                            return [2 /*return*/, { valid: false, errors: errors }];
-                        }
-                        if (!valid) {
-                            errors.push('Ed25519 signature verification failed: data may be tampered');
-                        }
-                        return [2 /*return*/, {
-                                valid: valid,
-                                signerFingerprint: sigMeta.publicKeyFingerprint,
-                                signedAt: sigMeta.signedAt,
-                                signedBy: sigMeta.signedBy,
-                                errors: errors
-                            }];
-                }
-            });
-        });
-    };
+    async verifyAppliance(rvfaPath) {
+        const errors = [];
+        let buf;
+        try {
+            buf = await readFile(rvfaPath);
+        }
+        catch (err) {
+            return { valid: false, errors: [`Failed to read file: ${err.message}`] };
+        }
+        let parsed;
+        try {
+            parsed = parseRvfaBinary(buf);
+        }
+        catch (err) {
+            return { valid: false, errors: [`Invalid RVFA file: ${err.message}`] };
+        }
+        const { header, sectionData, footer } = parsed;
+        // Extract signature metadata from header
+        const sigRaw = header.signature;
+        if (!sigRaw || typeof sigRaw !== 'object') {
+            return { valid: false, errors: ['No signature found in RVFA header'] };
+        }
+        const sigMeta = sigRaw;
+        if (sigMeta.algorithm !== 'ed25519') {
+            errors.push(`Unsupported algorithm: ${String(sigMeta.algorithm)}`);
+            return { valid: false, errors };
+        }
+        if (typeof sigMeta.signature !== 'string' || !sigMeta.signature) {
+            errors.push('Signature field is missing or empty');
+            return { valid: false, errors };
+        }
+        // Recompute the digest the same way the signer did
+        const digest = computeSigningDigest(header, sectionData, footer);
+        // Verify
+        let sigBuf;
+        try {
+            sigBuf = Buffer.from(sigMeta.signature, 'hex');
+        }
+        catch {
+            errors.push('Signature is not valid hex');
+            return { valid: false, errors };
+        }
+        let valid;
+        try {
+            valid = verify(null, digest, this.keyObj, sigBuf);
+        }
+        catch (err) {
+            errors.push(`Verification error: ${err.message}`);
+            return { valid: false, errors };
+        }
+        if (!valid) {
+            errors.push('Ed25519 signature verification failed: data may be tampered');
+        }
+        return {
+            valid,
+            signerFingerprint: sigMeta.publicKeyFingerprint,
+            signedAt: sigMeta.signedAt,
+            signedBy: sigMeta.signedBy,
+            errors,
+        };
+    }
     /**
      * Verify a detached Ed25519 signature over arbitrary data.
      *
      * @param data       The data that was signed.
      * @param signature  Hex-encoded Ed25519 signature.
      */
-    RvfaVerifier.prototype.verifyDetached = function (data, signature) {
-        return __awaiter(this, void 0, Promise, function () {
-            var digest, sigBuf;
-            return __generator(this, function (_a) {
-                digest = createHash('sha256').update(data).digest();
-                sigBuf = Buffer.from(signature, 'hex');
-                return [2 /*return*/, verify(null, digest, this.keyObj, sigBuf)];
-            });
-        });
-    };
+    async verifyDetached(data, signature) {
+        const digest = createHash('sha256').update(data).digest();
+        const sigBuf = Buffer.from(signature, 'hex');
+        return verify(null, digest, this.keyObj, sigBuf);
+    }
     /**
      * Verify an RVFP patch file signature.
      *
      * @param patchData  The raw patch binary data.
      * @param signature  Hex-encoded Ed25519 signature.
      */
-    RvfaVerifier.prototype.verifyPatch = function (patchData, signature) {
-        return __awaiter(this, void 0, Promise, function () {
-            var digest, sigBuf;
-            return __generator(this, function (_a) {
-                digest = createHash('sha256').update(patchData).digest();
-                sigBuf = Buffer.from(signature, 'hex');
-                return [2 /*return*/, verify(null, digest, this.keyObj, sigBuf)];
-            });
-        });
-    };
-    return RvfaVerifier;
-}());
-export { RvfaVerifier };
+    async verifyPatch(patchData, signature) {
+        const digest = createHash('sha256').update(patchData).digest();
+        const sigBuf = Buffer.from(signature, 'hex');
+        return verify(null, digest, this.keyObj, sigBuf);
+    }
+}
 //# sourceMappingURL=rvfa-signing.js.map