321 lines
10 KiB
JavaScript
321 lines
10 KiB
JavaScript
/* @ts-self-types="./guidance_kernel.d.ts" */
|
|
|
|
/**
|
|
* Process a batch of operations in a single host→kernel call.
|
|
* Accepts a JSON array of `BatchOp` and returns a JSON array of results.
|
|
*
|
|
* This is the primary entry point for high-throughput scenarios.
|
|
* The host batches multiple operations into one call to minimize
|
|
* WASM boundary crossings.
|
|
* @param {string} ops_json
|
|
* @returns {string}
|
|
*/
|
|
function batch_process(ops_json) {
|
|
let deferred2_0;
|
|
let deferred2_1;
|
|
try {
|
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
const ptr0 = passStringToWasm0(ops_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.batch_process(retptr, ptr0, len0);
|
|
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
deferred2_0 = r0;
|
|
deferred2_1 = r1;
|
|
return getStringFromWasm0(r0, r1);
|
|
} finally {
|
|
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
wasm.__wbindgen_export3(deferred2_0, deferred2_1, 1);
|
|
}
|
|
}
|
|
exports.batch_process = batch_process;
|
|
|
|
/**
|
|
* Compute content hash with sorted keys (for RunEvent hashing)
|
|
* @param {string} json_input
|
|
* @returns {string}
|
|
*/
|
|
function content_hash(json_input) {
|
|
let deferred2_0;
|
|
let deferred2_1;
|
|
try {
|
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
const ptr0 = passStringToWasm0(json_input, wasm.__wbindgen_export, wasm.__wbindgen_export2);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.content_hash(retptr, ptr0, len0);
|
|
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
deferred2_0 = r0;
|
|
deferred2_1 = r1;
|
|
return getStringFromWasm0(r0, r1);
|
|
} finally {
|
|
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
wasm.__wbindgen_export3(deferred2_0, deferred2_1, 1);
|
|
}
|
|
}
|
|
exports.content_hash = content_hash;
|
|
|
|
/**
|
|
* Detect destructive command patterns, returns matched pattern or empty string
|
|
* @param {string} command
|
|
* @returns {string}
|
|
*/
|
|
function detect_destructive(command) {
|
|
let deferred2_0;
|
|
let deferred2_1;
|
|
try {
|
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
const ptr0 = passStringToWasm0(command, wasm.__wbindgen_export, wasm.__wbindgen_export2);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.detect_destructive(retptr, ptr0, len0);
|
|
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
deferred2_0 = r0;
|
|
deferred2_1 = r1;
|
|
return getStringFromWasm0(r0, r1);
|
|
} finally {
|
|
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
wasm.__wbindgen_export3(deferred2_0, deferred2_1, 1);
|
|
}
|
|
}
|
|
exports.detect_destructive = detect_destructive;
|
|
|
|
/**
|
|
* Compute HMAC-SHA256 hex digest
|
|
* @param {string} key
|
|
* @param {string} input
|
|
* @returns {string}
|
|
*/
|
|
function hmac_sha256(key, input) {
|
|
let deferred3_0;
|
|
let deferred3_1;
|
|
try {
|
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(input, wasm.__wbindgen_export, wasm.__wbindgen_export2);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
wasm.hmac_sha256(retptr, ptr0, len0, ptr1, len1);
|
|
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
deferred3_0 = r0;
|
|
deferred3_1 = r1;
|
|
return getStringFromWasm0(r0, r1);
|
|
} finally {
|
|
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
wasm.__wbindgen_export3(deferred3_0, deferred3_1, 1);
|
|
}
|
|
}
|
|
exports.hmac_sha256 = hmac_sha256;
|
|
|
|
/**
|
|
* Initialize the kernel (called once on module load).
|
|
* Returns the kernel version string.
|
|
* @returns {string}
|
|
*/
|
|
function kernel_init() {
|
|
let deferred1_0;
|
|
let deferred1_1;
|
|
try {
|
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
wasm.kernel_init(retptr);
|
|
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
deferred1_0 = r0;
|
|
deferred1_1 = r1;
|
|
return getStringFromWasm0(r0, r1);
|
|
} finally {
|
|
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
wasm.__wbindgen_export3(deferred1_0, deferred1_1, 1);
|
|
}
|
|
}
|
|
exports.kernel_init = kernel_init;
|
|
|
|
/**
|
|
* Scan content for secret patterns, returns JSON array of redacted matches
|
|
* @param {string} content
|
|
* @returns {string}
|
|
*/
|
|
function scan_secrets(content) {
|
|
let deferred2_0;
|
|
let deferred2_1;
|
|
try {
|
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.scan_secrets(retptr, ptr0, len0);
|
|
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
deferred2_0 = r0;
|
|
deferred2_1 = r1;
|
|
return getStringFromWasm0(r0, r1);
|
|
} finally {
|
|
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
wasm.__wbindgen_export3(deferred2_0, deferred2_1, 1);
|
|
}
|
|
}
|
|
exports.scan_secrets = scan_secrets;
|
|
|
|
/**
|
|
* Compute SHA-256 hex digest of input
|
|
* @param {string} input
|
|
* @returns {string}
|
|
*/
|
|
function sha256(input) {
|
|
let deferred2_0;
|
|
let deferred2_1;
|
|
try {
|
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export, wasm.__wbindgen_export2);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
wasm.sha256(retptr, ptr0, len0);
|
|
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
deferred2_0 = r0;
|
|
deferred2_1 = r1;
|
|
return getStringFromWasm0(r0, r1);
|
|
} finally {
|
|
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
wasm.__wbindgen_export3(deferred2_0, deferred2_1, 1);
|
|
}
|
|
}
|
|
exports.sha256 = sha256;
|
|
|
|
/**
|
|
* Sign a proof envelope body (HMAC-SHA256)
|
|
* @param {string} key
|
|
* @param {string} envelope_json
|
|
* @returns {string}
|
|
*/
|
|
function sign_envelope(key, envelope_json) {
|
|
let deferred3_0;
|
|
let deferred3_1;
|
|
try {
|
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(envelope_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
wasm.hmac_sha256(retptr, ptr0, len0, ptr1, len1);
|
|
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
deferred3_0 = r0;
|
|
deferred3_1 = r1;
|
|
return getStringFromWasm0(r0, r1);
|
|
} finally {
|
|
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
wasm.__wbindgen_export3(deferred3_0, deferred3_1, 1);
|
|
}
|
|
}
|
|
exports.sign_envelope = sign_envelope;
|
|
|
|
/**
|
|
* Verify an entire proof chain from JSON
|
|
* @param {string} chain_json
|
|
* @param {string} key
|
|
* @returns {boolean}
|
|
*/
|
|
function verify_chain(chain_json, key) {
|
|
const ptr0 = passStringToWasm0(chain_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
|
|
const len0 = WASM_VECTOR_LEN;
|
|
const ptr1 = passStringToWasm0(key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
|
|
const len1 = WASM_VECTOR_LEN;
|
|
const ret = wasm.verify_chain(ptr0, len0, ptr1, len1);
|
|
return ret !== 0;
|
|
}
|
|
exports.verify_chain = verify_chain;
|
|
|
|
function __wbg_get_imports() {
|
|
const import0 = {
|
|
__proto__: null,
|
|
};
|
|
return {
|
|
__proto__: null,
|
|
"./guidance_kernel_bg.js": import0,
|
|
};
|
|
}
|
|
|
|
let cachedDataViewMemory0 = null;
|
|
function getDataViewMemory0() {
|
|
if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
|
|
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
|
|
}
|
|
return cachedDataViewMemory0;
|
|
}
|
|
|
|
function getStringFromWasm0(ptr, len) {
|
|
ptr = ptr >>> 0;
|
|
return decodeText(ptr, len);
|
|
}
|
|
|
|
let cachedUint8ArrayMemory0 = null;
|
|
function getUint8ArrayMemory0() {
|
|
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
|
|
cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
|
|
}
|
|
return cachedUint8ArrayMemory0;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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 wasmPath = `${__dirname}/guidance_kernel_bg.wasm`;
|
|
const wasmBytes = require('fs').readFileSync(wasmPath);
|
|
const wasmModule = new WebAssembly.Module(wasmBytes);
|
|
const wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
|