@moonglade/provenance 0.0.0-stage → 2.6.0

package/package.json

@@ -1,6 +1,77 @@
 {
   "name": "@moonglade/provenance",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.6.0",
+  "description": "Local-first cryptographic proof for markdown files and agentic AI memory substrates.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "provenance": "dist/artifact-cli.js",
+    "provenance-gate": "dist/mcp.js",
+    "provenance-artifact": "dist/artifact-cli.js"
+  },
+  "scripts": {
+    "build": "node clean-build.cjs && tsc",
+    "test": "npm run build && node -r ./test-harness.cjs --test src/*.test.js",
+    "self-test": "node dist/artifact-cli.js test",
+    "prepublishOnly": "npm run build",
+    "test:only": "node -r ./test-harness.cjs --test src/*.test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MoongladeAI/moonglade-provenance-public.git"
+  },
+  "keywords": [
+    "provenance",
+    "ai",
+    "agentic",
+    "merkle",
+    "rfc3161",
+    "ed25519",
+    "mcp",
+    "moonglade"
+  ],
+  "author": "Moonglade AI",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/*.js",
+    "dist/*.d.ts",
+    "wasm",
+    "README.md",
+    "SPEC.md",
+    "TIMESTAMP.md",
+    "LICENSE",
+    "NOTICE.md",
+    "trust"
+  ],
+  "homepage": "https://github.com/MoongladeAI/moonglade-provenance-public#readme",
+  "bugs": {
+    "url": "https://github.com/MoongladeAI/moonglade-provenance-public/issues"
+  },
+  "devDependencies": {
+    "@types/node": "22.20.4",
+    "typescript": "5.9.3"
+  },
+  "dependencies": {
+    "asn1js": "3.0.10",
+    "pkijs": "3.4.1"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": "^22.0.0 || ^24.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./wasm": {
+      "types": "./wasm/mgc_wasm.d.ts",
+      "require": "./wasm/mgc_wasm.js",
+      "default": "./wasm/mgc_wasm.js"
+    },
+    "./package.json": "./package.json"
+  }
+}

package/trust/README.md

@@ -0,0 +1,19 @@
+# Release root trust
+
+The OpenPGP release root fingerprint is:
+
+```text
+5E7FA9F6C5B0A65BC23A75704FF2C2DE69C0C4A3
+```
+
+Inspect the public certificate independently:
+
+```sh
+gpg --show-keys --with-fingerprint root-public.asc
+```
+
+Verify the human release manifest or commit with GPG. Before trusting it, compare the full fingerprint with the MoongladeAI organization profile and the identified publication on moongladeai.net. Those external publications must be checked at release time. A key shipped inside the same untrusted download cannot establish its own identity.
+
+The registry contains the root role only. Agent reviews have no architect authority. The registry remains an unsigned candidate until the human gate signs it.
+
+The artifact API accepts raw Ed25519 SPKI PEM keys, not OpenPGP certificates. Do not pass this certificate to that API or use the release root from an unattended agent. The certificate's user IDs are deliberate public signer identifiers.

package/trust/registry.json

@@ -0,0 +1,12 @@
+{
+  "format": "moonglade-release-trust-v1",
+  "status": "unsigned-candidate",
+  "signers": [
+    {
+      "fingerprint": "5E7FA9F6C5B0A65BC23A75704FF2C2DE69C0C4A3",
+      "role": "root",
+      "public_key": "root-public.asc",
+      "architect_authority": true
+    }
+  ]
+}

package/trust/root-public.asc

@@ -0,0 +1,10 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+
+mDMEapbUuBYJKwYBBAHaRw8BAQdAULJ9to5djqb63TWkuBsylWfKgrujIbevcM5L
+acOhv1C0O01hcmMgT3R0bGV5IChGb3VuZGVyLCBNb29uZ2xhZGUgQUkpIDxtb29u
+Z2xhZGVhaUBnbWFpbC5jb20+iJkEExYKAEEWIQRef6n2xbCmW8I6dXBP8sLeacDE
+owUCapbUuAIbIwUJBaOagAULCQgHAgIiAgYVCgkICwIEFgIDAQIeBwIXgAAKCRBP
+8sLeacDEowfNAQC1o+XcHAHwhpc1MMSZClFb/ylagyPo7Y7pdJkgPRWHzAEA3Owi
+zID5JKGznM+xVhNA7LaiHIYMEKx3KgLJbsUeRAc=
+=gFm3
+-----END PGP PUBLIC KEY BLOCK-----

package/wasm/mgc_wasm.d.ts

@@ -0,0 +1,53 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Claims JSON per draft -03 section 3.3: safe-integer numbers (judged by value) and UTF-16 key order.
+ */
+export function canonicalize_claims_json(json: string): string;
+
+/**
+ * Canonicalize a JSON string according to RFC-8785 (JCS).
+ */
+export function canonicalize_json(json_str: string): string;
+
+/**
+ * Strict provenance-ts text/binary canonicalization, distinct from frozen legacy profiles.
+ */
+export function canonicalize_provenance(filename: string, bytes: Uint8Array): Uint8Array;
+
+/**
+ * Returns the engine version and cryptographic capabilities.
+ */
+export function engine_info(): string;
+
+export function provenance_inclusion_proof(artifacts_json: string, target: string): string;
+
+export function provenance_merkle_root(artifacts_json: string): string;
+
+/**
+ * Compute SHA-256 digest over arbitrary binary bytes, returning lowercase hex.
+ */
+export function sha256_digest(bytes: Uint8Array): string;
+
+/**
+ * Verify a full Moonglade sidecar attestation against a live payload hash and known signers registry.
+ *
+ * Returns a JSON string of the complete `Verdict`.
+ */
+export function verify_attestation(current_hash: string, sidecar_json: string, known_signers_json: string): string;
+
+/**
+ * Verify a raw Ed25519 signature over a message using hex-encoded public key and signature.
+ */
+export function verify_ed25519_hex(message: Uint8Array, signature_hex: string, public_key_hex: string): boolean;
+
+/**
+ * Verify a Merkle inclusion proof for a leaf against a root digest.
+ *
+ * Siblings must be passed as an ordered array of 32-byte hex hashes with a direction flag
+ * (e.g. `[{"hash": "...", "is_left": true}]`).
+ */
+export function verify_merkle_proof(leaf_hash_hex: string, root_hash_hex: string, proof_siblings_json: string): boolean;
+
+export function verify_provenance_merkle_proof(proof_json: string, expected_root: string): boolean;

package/wasm/mgc_wasm.js

@@ -0,0 +1,389 @@
+/* @ts-self-types="./mgc_wasm.d.ts" */
+
+/**
+ * Claims JSON per draft -03 section 3.3: safe-integer numbers (judged by value) and UTF-16 key order.
+ * @param {string} json
+ * @returns {string}
+ */
+function canonicalize_claims_json(json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.canonicalize_claims_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.canonicalize_claims_json = canonicalize_claims_json;
+
+/**
+ * Canonicalize a JSON string according to RFC-8785 (JCS).
+ * @param {string} json_str
+ * @returns {string}
+ */
+function canonicalize_json(json_str) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(json_str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.canonicalize_json(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.canonicalize_json = canonicalize_json;
+
+/**
+ * Strict provenance-ts text/binary canonicalization, distinct from frozen legacy profiles.
+ * @param {string} filename
+ * @param {Uint8Array} bytes
+ * @returns {Uint8Array}
+ */
+function canonicalize_provenance(filename, bytes) {
+    const ptr0 = passStringToWasm0(filename, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.canonicalize_provenance(ptr0, len0, ptr1, len1);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+}
+exports.canonicalize_provenance = canonicalize_provenance;
+
+/**
+ * Returns the engine version and cryptographic capabilities.
+ * @returns {string}
+ */
+function engine_info() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.engine_info();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.engine_info = engine_info;
+
+/**
+ * @param {string} artifacts_json
+ * @param {string} target
+ * @returns {string}
+ */
+function provenance_inclusion_proof(artifacts_json, target) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(artifacts_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(target, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.provenance_inclusion_proof(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+exports.provenance_inclusion_proof = provenance_inclusion_proof;
+
+/**
+ * @param {string} artifacts_json
+ * @returns {string}
+ */
+function provenance_merkle_root(artifacts_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(artifacts_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.provenance_merkle_root(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.provenance_merkle_root = provenance_merkle_root;
+
+/**
+ * Compute SHA-256 digest over arbitrary binary bytes, returning lowercase hex.
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+function sha256_digest(bytes) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sha256_digest(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.sha256_digest = sha256_digest;
+
+/**
+ * Verify a full Moonglade sidecar attestation against a live payload hash and known signers registry.
+ *
+ * Returns a JSON string of the complete `Verdict`.
+ * @param {string} current_hash
+ * @param {string} sidecar_json
+ * @param {string} known_signers_json
+ * @returns {string}
+ */
+function verify_attestation(current_hash, sidecar_json, known_signers_json) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const ptr0 = passStringToWasm0(current_hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(sidecar_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(known_signers_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.verify_attestation(ptr0, len0, ptr1, len1, ptr2, len2);
+        var ptr4 = ret[0];
+        var len4 = ret[1];
+        if (ret[3]) {
+            ptr4 = 0; len4 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred5_0 = ptr4;
+        deferred5_1 = len4;
+        return getStringFromWasm0(ptr4, len4);
+    } finally {
+        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+}
+exports.verify_attestation = verify_attestation;
+
+/**
+ * Verify a raw Ed25519 signature over a message using hex-encoded public key and signature.
+ * @param {Uint8Array} message
+ * @param {string} signature_hex
+ * @param {string} public_key_hex
+ * @returns {boolean}
+ */
+function verify_ed25519_hex(message, signature_hex, public_key_hex) {
+    const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(signature_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(public_key_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.verify_ed25519_hex(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] !== 0;
+}
+exports.verify_ed25519_hex = verify_ed25519_hex;
+
+/**
+ * Verify a Merkle inclusion proof for a leaf against a root digest.
+ *
+ * Siblings must be passed as an ordered array of 32-byte hex hashes with a direction flag
+ * (e.g. `[{"hash": "...", "is_left": true}]`).
+ * @param {string} leaf_hash_hex
+ * @param {string} root_hash_hex
+ * @param {string} proof_siblings_json
+ * @returns {boolean}
+ */
+function verify_merkle_proof(leaf_hash_hex, root_hash_hex, proof_siblings_json) {
+    const ptr0 = passStringToWasm0(leaf_hash_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(root_hash_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(proof_siblings_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.verify_merkle_proof(ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] !== 0;
+}
+exports.verify_merkle_proof = verify_merkle_proof;
+
+/**
+ * @param {string} proof_json
+ * @param {string} expected_root
+ * @returns {boolean}
+ */
+function verify_provenance_merkle_proof(proof_json, expected_root) {
+    const ptr0 = passStringToWasm0(proof_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(expected_root, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.verify_provenance_merkle_proof(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] !== 0;
+}
+exports.verify_provenance_merkle_proof = verify_provenance_merkle_proof;
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbindgen_generic_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./mgc_wasm_bg.js": import0,
+    };
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const path = require('path');
+const wasmPath = path.join(__dirname, 'mgc_wasm_bg.wasm');
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
+let wasm = wasmInstance.exports;
+wasm.__wbindgen_start();

package/wasm/mgc_wasm_bg.wasm.d.ts

@@ -0,0 +1,20 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const canonicalize_claims_json: (a: number, b: number) => [number, number, number, number];
+export const canonicalize_json: (a: number, b: number) => [number, number, number, number];
+export const canonicalize_provenance: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const engine_info: () => [number, number];
+export const provenance_inclusion_proof: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const provenance_merkle_root: (a: number, b: number) => [number, number, number, number];
+export const sha256_digest: (a: number, b: number) => [number, number];
+export const verify_attestation: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number, number];
+export const verify_ed25519_hex: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+export const verify_merkle_proof: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+export const verify_provenance_merkle_proof: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;