@eyeauras/insight-cli 0.0.0-stage → 0.2.0

package/dist/src/mutation-effects.js

@@ -0,0 +1,321 @@
+import { address } from './research.js';
+import { object, fail } from './model.js';
+import { verifyFunctionMutation } from './function-effects.js';
+import { verifyComments } from './comment-effects.js';
+import { verifyDataMutation } from './data-effects.js';
+import { verifyDocumentation } from './documentation-effects.js';
+import { verifyMemoryCreation } from './memory-inputs.js';
+const equal = (actual, expected, label) => { if (actual !== expected)
+    fail('partial', `Saved ${label} does not match the requested effect.`); };
+const normalized = (value) => address(String(value));
+const category = (value) => '/' + String(value).replace(/^\/+|\/+$/g, '');
+/** Effect assertions run against an immutable saved program, not the response's success flag. */
+export async function verifyMutation(backend, snapshot, path, p, response) {
+    if (path.startsWith('/sdk/')) {
+        if (!backend.inspect)
+            fail('configuration', 'Native SDK edits require immutable saved-state inspection.');
+        return backend.inspect(snapshot, { kind: 'sdk', operation: path.slice(5), parameters: p });
+    }
+    if (path === '/create_memory_block')
+        return verifyMemoryCreation(backend, snapshot, p);
+    if (path === '/set_function_prototype') {
+        if (!backend.inspect)
+            fail('configuration', 'Prototype edits require saved-state inspection.');
+        const value = await backend.inspect(snapshot, { kind: 'function', address: p.function_address, prototype: p.prototype });
+        equal(value.exists, true, 'function presence');
+        const expected = object(value.expectedPrototype);
+        equal(value.returnType, expected.returnType, 'prototype return type');
+        if (!Array.isArray(value.parameters) || !Array.isArray(expected.parameters))
+            fail('partial', 'Saved prototype parameters are absent.');
+        const actual = value.parameters.filter(v => !v.auto);
+        equal(actual.length, expected.parameters.length, 'prototype parameter count');
+        for (let i = 0; i < actual.length; i++)
+            equal(actual[i].type, object(expected.parameters[i]).type, 'prototype parameter type');
+        const convention = p.calling_convention || expected.inlineCallingConvention;
+        if (convention === 'default') {
+            if (!['default', value.defaultCallingConvention].includes(value.callingConvention))
+                fail('partial', 'Saved prototype default convention differs from the compiler specification.');
+        }
+        else if (convention)
+            equal(value.callingConvention, convention, 'prototype convention');
+        return value;
+    }
+    if (['/import_data_types', '/apply_data_classification', '/set_global', '/set_function_this_type', '/clear_flow_and_repair'].includes(path))
+        return verifyDataMutation(backend, snapshot, path, p, response);
+    if (path === '/apply_function_documentation')
+        return verifyDocumentation(backend, snapshot, p);
+    if (['/batch_set_comments', '/clear_function_comments'].includes(path))
+        return verifyComments(backend, snapshot, path, p);
+    if (path === '/batch_apply_documentation') {
+        if (!Array.isArray(response.errors) || response.errors.length)
+            fail('partial', 'Documentation batch has incomplete steps.');
+        const comments = await verifyComments(backend, snapshot, path, p);
+        if (!backend.inspect)
+            fail('configuration', 'Documentation requires saved-state inspection.');
+        const functionState = await backend.inspect(snapshot, { kind: 'function', address: p.address, ...(p.prototype ? { prototype: p.prototype } : {}) });
+        equal(functionState.exists, true, 'documented function presence');
+        if (p.name)
+            equal(functionState.name, p.name, 'documented function name');
+        const variables = functionState.variables;
+        if (!Array.isArray(variables))
+            fail('partial', 'Saved documented variables are absent.');
+        const renames = object(p.variable_renames ?? {}), types = object(p.variable_types ?? {});
+        for (const [oldName, newName] of Object.entries(renames))
+            if (!variables.some(v => object(v).name === newName))
+                fail('partial', 'Saved variable rename is absent.');
+        for (const [name, typeName] of Object.entries(types)) {
+            const saved = variables.find(v => object(v).name === (renames[name] ?? name));
+            if (!saved)
+                fail('partial', 'Saved documented variable is absent.');
+            const wanted = await backend.inspect(snapshot, { kind: 'resolve_type', name: typeName });
+            equal(wanted.exists, true, 'documented variable type');
+            equal(object(saved).type, object(wanted.type).name, 'documented variable type');
+        }
+        if (p.prototype) {
+            const expected = object(functionState.expectedPrototype);
+            equal(functionState.returnType, expected.returnType, 'documented return type');
+            const actual = functionState.parameters;
+            if (!Array.isArray(actual) || !Array.isArray(expected.parameters))
+                fail('partial', 'Saved signature parameters are absent.');
+            equal(actual.length, expected.parameters.length, 'documented parameter count');
+            for (let i = 0; i < actual.length; i++)
+                equal(object(actual[i]).type, object(expected.parameters[i]).type, 'documented parameter type');
+        }
+        if (p.calling_convention)
+            equal(functionState.callingConvention, p.calling_convention, 'documented calling convention');
+        return { function: functionState, ...comments };
+    }
+    if (path === '/run_script_inline' || path === '/run_ghidra_script') {
+        // Output describes execution, while the snapshot captures the resulting complete program state.
+        // Scripts can have external effects, so an unknown response cannot be reconciled from DB state alone.
+        if (response.success !== true || typeof response.console_output !== 'string' && response.output_captured !== false)
+            fail('partial', 'Script execution lacks a complete successful outcome.');
+        if (!backend.inspect)
+            fail('configuration', 'Script execution requires saved-state inspection.');
+        const metadata = await backend.inspect(snapshot, { kind: 'metadata' });
+        if (typeof metadata.sha256 !== 'string' || !metadata.sha256)
+            fail('partial', 'Saved script state lacks its input identity.');
+        return { success: true, ...(typeof response.console_output === 'string' ? { output: response.console_output } : {}),
+            outputCaptured: response.output_captured !== false, ...(path === '/run_ghidra_script' ? { script: p.script_name } : {}) };
+    }
+    if (['/create_function', '/delete_function', '/clear_instruction_flow_override', '/disassemble_bytes', '/add_function_tag', '/remove_function_tag',
+        '/delete_function_tag', '/set_function_tag_comment', '/set_function_no_return', '/set_variable_type', '/set_variable_storage',
+        '/rename_variables', '/batch_rename_function_components', '/set_variables'].includes(path))
+        return verifyFunctionMutation(backend, snapshot, path, p, response);
+    if (!backend.inspect)
+        fail('configuration', 'Structural operations require saved-state inspection.');
+    const inspect = (kind, parameters = {}) => backend.inspect(snapshot, { kind, ...parameters });
+    if (path === '/run_analysis' || path === '/reanalyze') {
+        const value = await inspect('metadata');
+        equal(value.analyzed, true, 'completed analysis flag');
+        if (response.success !== true)
+            fail('partial', 'Analysis completion was not established.');
+        if (response.total_functions !== undefined)
+            equal(value.functionCount, response.total_functions, 'analyzed function count');
+        return value;
+    }
+    if (path === '/configure_analyzer') {
+        const value = await inspect('option', { name: p.name, group: 'Analyzers' });
+        equal(value.exists, true, 'analyzer option presence');
+        if (p.enabled !== undefined)
+            equal(value.value, String(p.enabled), 'analyzer enabled flag');
+        return value;
+    }
+    const type = async (name) => { const value = await inspect('type', { name }); equal(value.exists, true, 'type presence'); return object(value.type); };
+    const structure = async (name) => { const value = await type(name); if (!Array.isArray(value.fields))
+        fail('partial', 'Saved composite layout is absent.'); return value; };
+    if (['/clone_data_type', '/create_derived_type', '/rename_data_type'].includes(path)) {
+        const name = p.new_name ?? p.name ?? response.name;
+        const value = await type(name);
+        equal(value.name, name, 'type name');
+        if (path === '/clone_data_type' && p.source_type !== p.new_name) {
+            const original = await type(p.source_type);
+            equal(original.size, value.size, 'copied type size');
+            if (original.fields !== undefined)
+                equal(JSON.stringify(original.fields), JSON.stringify(value.fields), 'copied layout');
+        }
+        return value;
+    }
+    if (path === '/create_function_signature') {
+        const value = await type(p.name);
+        equal(value.name, p.name, 'signature type name');
+        const parameters = typeof p.parameters === 'string' ? JSON.parse(p.parameters) : p.parameters;
+        if (!Array.isArray(parameters) || !Array.isArray(value.arguments))
+            fail('partial', 'Saved function signature arguments are absent.');
+        equal(value.arguments.length, parameters.length, 'signature argument count');
+        for (let i = 0; i < parameters.length; i++) {
+            const resolved = await inspect('resolve_type', { name: object(parameters[i]).type });
+            equal(resolved.exists, true, 'signature argument type');
+            equal(value.arguments[i], object(resolved.type).name, 'signature argument type');
+        }
+        const result = await inspect('resolve_type', { name: p.return_type });
+        equal(result.exists, true, 'signature return type');
+        equal(value.returnType, object(result.type).name, 'signature return type');
+        return value;
+    }
+    if (path === '/create_data_type_category') {
+        const value = await inspect('category', { name: category(p.category_path) });
+        equal(value.exists, true, 'category presence');
+        return value;
+    }
+    if (path === '/delete_data_type') {
+        const value = await inspect('type', { name: p.type_name });
+        equal(value.exists, false, 'deleted type absence');
+        return value;
+    }
+    if (path === '/move_data_type_to_category') {
+        const value = await type(p.type_name);
+        equal(value.category, category(p.category_path), 'type category');
+        return value;
+    }
+    if (path === '/create_enum') {
+        const value = await type(p.name), members = object(value.values), expected = object(p.values);
+        equal(value.size, p.size ?? 4, 'enum size');
+        equal(Object.keys(members).length, Object.keys(expected).length, 'enum member count');
+        for (const [name, item] of Object.entries(expected)) {
+            let wanted;
+            try {
+                wanted = BigInt(String(item)).toString();
+            }
+            catch {
+                fail('invalid', 'Enum values must be exact integers.');
+            }
+            equal(members[name], wanted, 'enum member ' + name);
+        }
+        return value;
+    }
+    if (path === '/create_union' || path === '/recreate_struct') {
+        const value = await structure(p.name), fields = value.fields;
+        if (!Array.isArray(p.fields))
+            fail('invalid', 'Composite fields must be an array.');
+        equal(fields.length, p.fields.length, 'composite field count');
+        for (let i = 0; i < fields.length; i++) {
+            const wanted = object(p.fields[i]);
+            equal(fields[i].name, wanted.name, 'composite field name');
+            if (wanted.offset !== undefined && path === '/recreate_struct')
+                equal(fields[i].offset, wanted.offset, 'composite field offset');
+        }
+        if (path === '/recreate_struct' && Number(p.size ?? -1) > 0)
+            equal(value.size, p.size, 'structure size');
+        return value;
+    }
+    if (['/add_struct_field', '/modify_struct_field', '/remove_struct_field'].includes(path)) {
+        const value = await structure(p.struct_name), fields = value.fields;
+        const selector = String(p.field_name ?? ''), byOffset = selector.startsWith('offset:') ? Number(selector.slice(7)) : undefined;
+        const target = fields.find(f => byOffset === undefined ? f.name === (p.new_name || selector) : f.offset === byOffset);
+        if (path === '/remove_struct_field') {
+            if (fields.some(f => f.name === selector))
+                fail('partial', 'Removed field remains in the saved structure.');
+        }
+        else {
+            if (!target)
+                fail('partial', 'Edited field is absent from the saved structure.');
+            if (path === '/add_struct_field' && Number(p.offset ?? -1) >= 0)
+                equal(target.offset, p.offset, 'field offset');
+            if (p.new_name)
+                equal(target.name, p.new_name, 'field name');
+            const expected = p.new_type ?? p.field_type;
+            if (expected) {
+                const resolved = await inspect('resolve_type', { name: expected });
+                equal(resolved.exists, true, 'resolved field type');
+                equal(String(target.type).replace(/\s+/g, ''), String(object(resolved.type).name).replace(/\s+/g, ''), 'field type');
+            }
+        }
+        return value;
+    }
+    if (path === '/resize_struct') {
+        const value = await structure(p.name);
+        equal(value.size, p.new_size, 'structure size');
+        return value;
+    }
+    if (path === '/resolve_duplicate_type') {
+        const value = await type(p.type_name);
+        if (Number(value.size) <= 1)
+            fail('partial', 'Canonical type is still a placeholder.');
+        return value;
+    }
+    if (path === '/apply_data_type') {
+        // The acknowledgment carries the resolved type; the saved type must exist with that size.
+        const resolved = await inspect('resolve_type', { name: p.type_name });
+        equal(resolved.exists, true, 'resolved applied type');
+        const value = object(resolved.type);
+        if (Number(value.size) <= 0)
+            fail('partial', 'Applied type has no defined size.');
+        const observed = await inspect('data', { address: p.address });
+        equal(observed.exists, true, 'defined data presence');
+        equal(observed.type, value.name, 'applied data type');
+        return observed;
+    }
+    if (['/create_property_map', '/delete_property_map', '/set_property', '/remove_property'].includes(path)) {
+        const value = await inspect('property', { name: p.name ?? p.map, ...(p.address ? { address: p.address } : {}) });
+        equal(value.exists, path !== '/delete_property_map', 'property map presence');
+        if (path === '/set_property') {
+            equal(value.hasValue, true, 'property presence');
+            if (value.value !== null)
+                equal(value.value, String(p.value ?? ''), 'property value');
+        }
+        if (path === '/remove_property')
+            equal(value.hasValue, false, 'removed property absence');
+        return value;
+    }
+    if (path === '/set_program_option' || path === '/remove_program_option') {
+        const value = await inspect('option', { name: p.name, group: p.group });
+        equal(value.exists, path === '/set_program_option', 'program option presence');
+        if (path === '/set_program_option')
+            equal(value.value, String(p.value), 'program option value');
+        return value;
+    }
+    if (path === '/set_image_base') {
+        const value = await inspect('metadata');
+        equal(normalized(value.imageBase), normalized(p.address), 'image base');
+        return value;
+    }
+    if (path === '/set_memory_block') {
+        const value = await inspect('memory', { name: p.block ?? '', address: p.address ?? '' });
+        equal(value.exists, true, 'memory block presence');
+        for (const flag of ['read', 'write', 'execute', 'volatile'])
+            if (p[flag] !== undefined)
+                equal(value[flag], p[flag], 'memory ' + flag);
+        return value;
+    }
+    if (path === '/set_bookmark' || path === '/delete_bookmark') {
+        const value = await inspect('bookmarks', { address: p.address }), marks = value.bookmarks;
+        if (!Array.isArray(marks))
+            fail('partial', 'Saved bookmark inventory is absent.');
+        const selected = marks.filter(mark => object(mark).category === String(p.category ?? ''));
+        if (path === '/set_bookmark') {
+            if (!selected.some(mark => object(mark).comment === String(p.comment ?? '')))
+                fail('partial', 'Saved bookmark does not contain the requested comment.');
+        }
+        else if (p.category ? selected.length : marks.length)
+            fail('partial', 'Deleted bookmark remains in saved state.');
+        return value;
+    }
+    if (path === '/create_label' || path === '/delete_label') {
+        const edits = Array.isArray(p.labels) && p.labels.length ? p.labels : [{ address: p.address, name: p.name }];
+        const verified = [];
+        for (const item of edits) {
+            const label = object(item), value = await inspect('symbols', { address: label.address });
+            if (!Array.isArray(value.symbols))
+                fail('partial', 'Saved symbol inventory is absent.');
+            equal(value.symbols.some(s => object(s).name === label.name), path === '/create_label', 'label presence');
+            verified.push(value);
+        }
+        return { labels: verified };
+    }
+    if (path === '/rename_symbol') {
+        const value = await inspect('symbols', { name: p.new_name });
+        if (!Array.isArray(value.symbols) || !value.symbols.length)
+            fail('partial', 'Renamed symbol is absent from saved state.');
+        return value;
+    }
+    if (path === '/add_memory_reference' || path === '/remove_reference') {
+        const value = await inspect('references', { address: p.from_address });
+        if (!Array.isArray(value.references))
+            fail('partial', 'Saved reference inventory is absent.');
+        const found = value.references.filter(ref => normalized(object(ref).to) === normalized(p.to_address) && object(ref).operand === (p.operand_index ?? -1));
+        equal(found.length > 0, path === '/add_memory_reference', 'reference presence');
+        return value;
+    }
+    fail('schema', 'Mutation lacks its saved effect contract.');
+}

package/dist/src/mutation-inputs.d.ts

@@ -0,0 +1,2 @@
+/** Validate nested domain input before reserving or dispatching a changing intent. */
+export declare function mutationInputs(path: string, p: Record<string, unknown>): void;

package/dist/src/mutation-inputs.js

@@ -0,0 +1,71 @@
+import { object, fail, text } from './model.js';
+import { address } from './research.js';
+/** Validate nested domain input before reserving or dispatching a changing intent. */
+export function mutationInputs(path, p) {
+    if (path === '/apply_data_classification') {
+        if (!['PRIMITIVE', 'STRUCTURE', 'ARRAY', 'STRING'].includes(String(p.classification)))
+            fail('invalid', 'Classification must be PRIMITIVE, STRUCTURE, ARRAY or STRING.');
+        const type = object(p.type_definition);
+        if (p.classification === 'PRIMITIVE')
+            text(type.type, 512);
+        if (p.classification === 'STRUCTURE') {
+            text(type.name, 512);
+            if (!Array.isArray(type.fields) || !type.fields.length)
+                fail('invalid', 'A structure requires fields.');
+            for (const raw of type.fields) {
+                const field = object(raw);
+                text(field.name, 512);
+                text(field.type, 512);
+            }
+        }
+        if (p.classification === 'ARRAY') {
+            text(type.element_type ?? type.element_struct, 512);
+            if (!Number.isSafeInteger(Number(type.count)) || Number(type.count) < 1 || Number(type.count) > 1048576)
+                fail('invalid', 'Array count must be 1–1048576.');
+        }
+    }
+    if (path === '/set_global' && (!Number.isSafeInteger(p.array_length ?? 0) || Number(p.array_length ?? 0) < 0 || Number(p.array_length ?? 0) > 1048576))
+        fail('invalid', 'Global array length must be 0–1048576.');
+    if (path === '/apply_function_documentation') {
+        const document = object(p.json_body);
+        address(document.target_address);
+        for (const key of ['function_name', 'return_type', 'calling_convention', 'plate_comment'])
+            if (document[key] !== undefined && document[key] !== '')
+                text(document[key], key === 'plate_comment' ? 16000 : 512);
+        const array = (key) => { const value = document[key] ?? []; if (!Array.isArray(value))
+            fail('invalid', 'Documentation ' + key + ' must be an array.'); return value; };
+        const ordinals = new Set();
+        for (const raw of array('parameters')) {
+            const parameter = object(raw), ordinal = parameter.ordinal;
+            if (!Number.isSafeInteger(ordinal) || Number(ordinal) < 0 || Number(ordinal) > 65535 || ordinals.has(Number(ordinal)))
+                fail('invalid', 'Parameter ordinals must be unique integers from 0 to 65535.');
+            ordinals.add(Number(ordinal));
+            for (const key of ['name', 'type'])
+                if (parameter[key] !== undefined && parameter[key] !== '')
+                    text(parameter[key], 512);
+        }
+        for (const key of ['comments', 'labels']) {
+            const offsets = new Set();
+            for (const raw of array(key)) {
+                const item = object(raw);
+                let offset;
+                try {
+                    if (!/^\d+$/.test(String(item.relative_offset)))
+                        throw Error();
+                    offset = BigInt(String(item.relative_offset));
+                }
+                catch {
+                    fail('invalid', 'Relative offset must be a nonnegative integer.');
+                }
+                if (offset > 0x7fffffffffffffffn || offsets.has(offset.toString()))
+                    fail('invalid', 'Documentation offsets must be unique signed 64-bit integers.');
+                offsets.add(offset.toString());
+                for (const field of key === 'labels' ? ['name'] : ['eol_comment', 'pre_comment'])
+                    if (item[field] !== undefined && item[field] !== '')
+                        text(item[field], field === 'name' ? 512 : 16000);
+                if (key === 'labels')
+                    text(item.name, 512);
+            }
+        }
+    }
+}

package/dist/src/mutations.d.ts

@@ -0,0 +1,4 @@
+import { type CommandDefinition, type CommandContext } from '@eyeauras/cli-factory';
+import { Research } from './research.js';
+/** Concrete pinned edit leaves with durable intent and independent saved-state effect checks. */
+export declare function mutationCommands(research: (context: CommandContext) => Research): CommandDefinition[];

package/dist/src/mutations.js

@@ -0,0 +1,53 @@
+import { readFileSync } from 'node:fs';
+import { command, Permission } from '@eyeauras/cli-factory';
+import { key, flag, parsed, option, selectedOptions } from './arguments.js';
+import { scope } from './research.js';
+import { id, fail } from './model.js';
+import { verifyMutation } from './mutation-effects.js';
+import { mutationInputs } from './mutation-inputs.js';
+const catalog = JSON.parse(readFileSync(new URL('../../references/mutations.json', import.meta.url), 'utf8'));
+if (catalog.source !== '57e37a8bf388b1279cff46378f85be1554548f61')
+    throw Error('Installed mutation contracts differ from the pinned build.');
+/** Concrete pinned edit leaves with durable intent and independent saved-state effect checks. */
+export function mutationCommands(research) {
+    const groups = new Map();
+    for (const m of catalog.tools) {
+        const [group, leaf, ...rest] = m.command.split(' ');
+        if (!group || !leaf || rest.length)
+            throw Error('Invalid installed mutation contract.');
+        const parameters = m.params.map(p => ({ ...p, publicName: p.name === 'target' ? 'symbol' : p.name === 'no_return' ? 'non_returning' : p.name === 'json_body' ? 'document' : p.name }));
+        const options = parameters.map(p => option({ ...p, name: p.publicName }));
+        const children = groups.get(group) ?? [];
+        groups.set(group, children);
+        children.push(command(leaf, leaf.replaceAll('-', ' '), ({ options: o }, c) => {
+            const values = {};
+            for (const p of parameters) {
+                const input = o[key(p.publicName)];
+                if (input === undefined) {
+                    if (p.required)
+                        fail('invalid', `Missing --${flag(p.publicName)}.`);
+                    continue;
+                }
+                values[p.name] = parsed(p, input);
+            }
+            for (const name of ['decompiler_comments', 'disassembly_comments'])
+                if (values[name] !== undefined) {
+                    const comments = values[name];
+                    if (!Array.isArray(comments))
+                        fail('invalid', 'Comments must be an array.');
+                    for (const item of comments) {
+                        if (!item || typeof item !== 'object' || typeof item.comment !== 'string' || item.comment.length > 16000 || item.comment.includes('\0'))
+                            fail('invalid', 'Every comment requires an address and bounded text.');
+                        parsed({ name: 'address', type: 'string', required: true, semantic: 'address' }, item.address);
+                    }
+                }
+            const selected = scope(o), request = o.requestId === undefined ? undefined : id(o.requestId);
+            mutationInputs(m.path, values);
+            if (['/set_program_option', '/remove_program_option'].includes(m.path) && values.group === 'Program Information' && values.name === 'Executable SHA256')
+                fail('binding', 'The immutable consumed input identity cannot be rewritten as a program option.');
+            return research(c).mutate(selected, m.path, values, async (_backend, response) => response, request, (backend, snapshot, response) => verifyMutation(backend, snapshot, m.path, values, response));
+        }, { permission: m.access === 'DESTRUCTIVE' || ['/recreate_struct', '/resize_struct', '/clone_data_type', '/set_global'].includes(m.path) ? 'Destructive' : Permission.Update,
+            options: [...selectedOptions, ...options, { flags: '--request-id <id>', description: 'Retrieve this changing intent after a lost response' }] }));
+    }
+    return [...groups].map(([name, children]) => command(name, `${name} changes`, children));
+}

package/dist/src/native-inputs.d.ts

@@ -0,0 +1,28 @@
+export interface NativeInputs {
+    java: string;
+    ghidraHome: string;
+    mcpJar: string;
+    jars: string[];
+    classpath: string;
+    ghidraVersion: string;
+    fingerprint: string;
+    debuggerWheels: string[];
+    extensionRoots?: string[];
+    serverClasspath?: string;
+}
+export declare const pinnedMcpJar = "7084e2fda16dc779dd05398e48821ff3f9ace4d32757ea143b257b39689e5fbd";
+export declare const packagedMcpJar: string;
+/** Ghidra has its own cache/settings overrides in addition to Java's home/tmp properties. */
+export declare const nativeJvmDirectories: (root: string) => string[];
+export declare function moduleJars(home: string): Promise<string[]>;
+export interface NativeRuntimeFile {
+    name: string;
+    path: string;
+}
+/** Installed native code/data, excluding documentation and isolated generated caches. */
+export declare function nativeRuntimeFiles(ghidraHome: string, java: string): Promise<NativeRuntimeFile[]>;
+export declare function nativeRuntimeFingerprint(ghidraVersion: string, files: NativeRuntimeFile[]): Promise<string>;
+export declare function nativeInputs(values: Record<string, unknown>, directory?: string): Promise<NativeInputs>;
+/** Compile packaged helper sources against the selected installation, never an author checkout. */
+export declare function nativeHelpers(directory: string, inputs: NativeInputs): Promise<string>;
+export declare const nativeExtensionArguments: (inputs: NativeInputs) => string[];