@eyeauras/insight-cli 0.0.0-stage → 0.1.0

package/dist/src/sdk-files.js

@@ -0,0 +1,249 @@
+import { command, Permission } from '@eyeauras/cli-factory';
+import { mkdir, readdir, lstat, readFile, open, rename, copyFile, realpath, chmod } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { join, resolve, dirname } from 'node:path';
+import { scope, address, number } from './research.js';
+import { object, fail, text, id, stable } from './model.js';
+import { parseDomainJson } from './json.js';
+import { selectedOptions } from './arguments.js';
+import { randomUUID } from 'node:crypto';
+async function persist(path, value) { const temp = path + '.new-' + randomUUID(), file = await open(temp, 'wx', 0o600); try {
+    await file.writeFile(stable(value));
+    await file.sync();
+}
+finally {
+    await file.close();
+} await rename(temp, path); if (process.platform !== 'win32') {
+    const directory = await open(dirname(path), 'r');
+    try {
+        await directory.sync();
+    }
+    finally {
+        await directory.close();
+    }
+} }
+/** Native SDK file effects have retained input/output bytes and never repeat an uncertain call. */
+export class SdkFiles {
+    workspace;
+    research;
+    backend;
+    constructor(workspace, research, backend) {
+        this.workspace = workspace;
+        this.research = research;
+        this.backend = backend;
+    }
+    async loaders(input) {
+        const artifact = await this.workspace.artifacts.capture(input, 'input'), backend = await this.backend();
+        if (!backend.sdkFile)
+            fail('configuration', 'Native SDK file workflows are unavailable.');
+        return { inputSha256: artifact.sha256, ...await backend.sdkFile('loaders', { input: await this.workspace.artifacts.verify(artifact) }) };
+    }
+    async exporters(selected) {
+        return this.research.ordered(selected, async () => {
+            const backend = await this.backend();
+            if (!backend.sdkFile)
+                fail('configuration', 'Native SDK file workflows are unavailable.');
+            await backend.open(selected);
+            const snapshot = await backend.saved(selected);
+            return { ...selected, value: await backend.sdkFile('exporters', { snapshot: await this.workspace.artifacts.verify(snapshot) }) };
+        });
+    }
+    async copy(files, directory, recovery = false) {
+        try {
+            await mkdir(directory, { mode: 0o700 });
+        }
+        catch (error) {
+            if (!recovery || error.code !== 'EEXIST')
+                throw error;
+        }
+        if (await realpath(directory) !== resolve(directory) || (await lstat(directory)).isSymbolicLink())
+            fail('binding', 'Export destination is not the requested ordinary directory.');
+        for (const file of files) {
+            if (!/^[a-zA-Z0-9_.-]{1,160}$/.test(file.name) || file.name === '.' || file.name === '..')
+                fail('binding', 'Exporter produced an unsupported output filename.');
+            const source = await this.workspace.artifacts.verify(file.artifact), output = join(directory, file.name);
+            try {
+                await copyFile(source, output, constants.COPYFILE_EXCL);
+            }
+            catch (error) {
+                if (!recovery || error.code !== 'EEXIST')
+                    throw error;
+            }
+            if ((await this.workspace.artifacts.capture(output, 'input')).id !== file.artifact.id)
+                fail('partial', 'Exported file bytes differ from retained native output.');
+            // Artifact copies retain their read-only mode. The owned user output needs a writable
+            // descriptor for FlushFileBuffers on Windows; verify existing recovery bytes first.
+            await chmod(output, 0o600);
+            const handle = await open(output, 'r+');
+            try {
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        if (process.platform !== 'win32')
+            for (const path of [directory, dirname(directory)]) {
+                const handle = await open(path, 'r');
+                try {
+                    await handle.sync();
+                }
+                finally {
+                    await handle.close();
+                }
+            }
+    }
+    async completedOutput(stage, request, operation) {
+        const marker = object(JSON.parse(await readFile(join(stage, 'native-result.json'), 'utf8')));
+        if (marker.request !== request || marker.operation !== operation || object(marker.value).state !== 'exported' || !Array.isArray(marker.files) || !marker.files.length || marker.files.length > 64)
+            fail('binding', 'Native file completion receipt differs from the retained request.');
+        const files = [];
+        for (const item of marker.files) {
+            const row = object(item), name = text(row.name, 160);
+            if (!/^[a-zA-Z0-9_.-]+$/.test(name) || name === '.' || name === '..')
+                fail('binding', 'Native output name is not a simple owned file.');
+            const path = join(stage, 'outputs', name);
+            if (!(await lstat(path)).isFile() || (await lstat(path)).isSymbolicLink())
+                fail('binding', 'Native output is not a regular owned file.');
+            const artifact = await this.workspace.artifacts.capture(path, 'input');
+            if (artifact.sha256 !== row.sha256 || artifact.size !== row.size)
+                fail('partial', 'Native output changed after its completion receipt.');
+            files.push({ name, artifact });
+        }
+        return { files, value: marker.value };
+    }
+    async databaseQuery(selected, operation, database, p) {
+        const artifact = await this.workspace.artifacts.capture(database, 'input');
+        if (artifact.size > 268435456)
+            fail('limit', 'Function database exceeds 256 MiB.');
+        return this.research.ordered(selected, async () => {
+            const backend = await this.backend();
+            if (!backend.sdkFile)
+                fail('configuration', 'Native function databases are unavailable.');
+            await backend.open(selected);
+            const snapshot = await backend.saved(selected), value = await backend.sdkFile(operation, { ...p, database: await this.workspace.artifacts.verify(artifact), snapshot: await this.workspace.artifacts.verify(snapshot) });
+            return { ...selected, databaseSha256: artifact.sha256, sourceSnapshotSha256: snapshot.sha256, value };
+        });
+    }
+    async export(selected, operation, parameters, directory, callerId) {
+        const reserved = this.workspace.reserveRequest(selected, 'ghidra.sdk-file.' + operation, { ...parameters, outputDirectory: directory }, callerId);
+        return this.research.ordered(selected, async () => {
+            const request = this.workspace.request(reserved.request.id), stage = join(this.workspace.directory, 'sdk-exports', request.id), receiptPath = join(stage, 'receipt.json');
+            if (reserved.replay && request.state !== 'accepted') {
+                if (request.state === 'applied')
+                    return request.result;
+                let saved;
+                try {
+                    saved = object(JSON.parse(await readFile(receiptPath, 'utf8')));
+                }
+                catch {
+                    let completed;
+                    try {
+                        completed = await this.completedOutput(stage, request.id, operation);
+                    }
+                    catch {
+                        fail('unknown', 'Native export has no verified completed receipt; the original call is not repeated.');
+                    }
+                    saved = { request: request.id, operation, ...completed };
+                    await persist(receiptPath, saved);
+                }
+                if (saved.request !== request.id || saved.operation !== operation || !Array.isArray(saved.files))
+                    fail('binding', 'Native export receipt differs from the retained intent.');
+                const files = saved.files;
+                await this.copy(files, directory, true);
+                const current = this.workspace.context(selected);
+                const result = { ...selected, state: 'exported', outputDirectory: directory, files: files.map(file => ({ name: file.name, sha256: file.artifact.sha256, size: file.artifact.size })), value: saved.value };
+                this.workspace.completeSavedRequest(selected, request.id, current.generation, {}, result);
+                return result;
+            }
+            try {
+                await lstat(directory);
+                fail('exists', 'Export directory already exists; choose a new directory.');
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+            const backend = await this.backend();
+            if (!backend.sdkFile)
+                fail('configuration', 'Native SDK file workflows are unavailable.');
+            await backend.open(selected);
+            const snapshot = await backend.saved(selected), current = this.workspace.context(selected);
+            await mkdir(stage, { recursive: true, mode: 0o700 });
+            const outputs = join(stage, 'outputs');
+            await mkdir(outputs, { recursive: true, mode: 0o700 });
+            if (await realpath(outputs) !== resolve(outputs) || (await lstat(outputs)).isSymbolicLink() || (await readdir(outputs)).length)
+                fail('binding', 'Accepted file preparation must retain an empty owned output directory.');
+            this.workspace.startRequest(request.id, { kind: 'sdk-file', operation, snapshot, generation: current.generation });
+            try {
+                const filename = operation === 'archive-export' ? 'types.gdt' : operation === 'fid-build' ? 'database.fidb' : operation === 'bsim-build' ? 'database.mv.db' : 'program.out';
+                const value = await backend.sdkFile(operation, { ...parameters, request_id: request.id, receipt: join(stage, 'native-result.json'), snapshot: await this.workspace.artifacts.verify(snapshot), output: join(outputs, filename) });
+                if (value.state !== 'exported')
+                    fail('partial', 'Native exporter did not establish a completed output.');
+                const completed = await this.completedOutput(stage, request.id, operation), files = completed.files;
+                if (stable(completed.value) !== stable(value))
+                    fail('partial', 'Native file reply differs from its durable receipt.');
+                await persist(receiptPath, { request: request.id, operation, files, value });
+                await this.copy(files, directory);
+                const result = { ...selected, state: 'exported', outputDirectory: directory, files: files.map(file => ({ name: file.name, sha256: file.artifact.sha256, size: file.artifact.size })), value };
+                this.workspace.completeSavedRequest(selected, request.id, current.generation, { workingSnapshot: snapshot }, result);
+                return result;
+            }
+            catch (error) {
+                this.workspace.recordRequest(request.id, 'unknown', { ...selected, state: 'unknown' });
+                throw error;
+            }
+        });
+    }
+}
+function json(value) { return parseDomainJson(text(value, 16000)); }
+export function sdkFileCommands(service) {
+    const outputs = [...selectedOptions, { flags: '--output-directory <directory>', description: 'New output directory including all exporter companion files', required: true },
+        { flags: '--request-id <id>', description: 'Retrieve retained export bytes without repeating native export' }];
+    const databases = [];
+    for (const kind of ['fid', 'bsim']) {
+        databases.push(command('build-' + kind, 'Build a genuine native ' + kind + ' database from the saved private snapshot', ({ options: o }, c) => service(c).export(scope(o), kind + '-build', { library: text(o.library, 512), ...(kind === 'fid' ? { version: text(o.libraryVersion, 128) } : {}) }, resolve(c.cwd, text(o.outputDirectory, 4096)), o.requestId === undefined ? undefined : id(o.requestId)), { permission: Permission.Update, options: [...outputs, { flags: '--library <name>', description: 'Native library/database name', required: true }, ...(kind === 'fid' ? [{ flags: '--library-version <version>', description: 'Native library version', required: true }] : [])] }));
+        databases.push(command(kind + '-query', 'Query one explicitly consumed native ' + kind + ' database with provenance and no-match semantics', ({ options: o }, c) => {
+            const p = { limit: number(o.limit, 1000, 1) };
+            if (o.function !== undefined)
+                p.function = address(o.function);
+            if (kind === 'fid') {
+                const threshold = Number(o.threshold);
+                if (!Number.isFinite(threshold) || threshold < 0 || threshold > 100000)
+                    fail('invalid', 'FID threshold must be 0–100000 native code units.');
+                p.threshold = threshold;
+            }
+            else {
+                const similarity = Number(o.similarity), significance = Number(o.significance);
+                if (!Number.isFinite(similarity) || similarity < 0 || similarity > 1 || !Number.isFinite(significance) || significance < 0 || significance > 1000000)
+                    fail('invalid', 'Invalid native BSim similarity/significance threshold.');
+                p.similarity = similarity;
+                p.significance = significance;
+            }
+            return service(c).databaseQuery(scope(o), kind + '-query', resolve(c.cwd, text(o.database, 4096)), p);
+        }, { permission: Permission.ReadOnly, options: [...selectedOptions, { flags: '--database <file>', description: 'Native FID or BSim/H2 file; immutable bytes are consumed first', required: true },
+                { flags: '--function <address>', description: 'Exact function entry', ...(kind === 'bsim' ? { required: true } : {}) }, { flags: '--limit <count>', description: 'Maximum returned matches', defaultValue: 20 },
+                ...(kind === 'fid' ? [{ flags: '--threshold <score>', description: 'Native matching code-unit threshold', defaultValue: 14.6 }] : [{ flags: '--similarity <number>', description: 'Native feature similarity 0–1', defaultValue: 0.7 }, { flags: '--significance <number>', description: 'Native feature significance', defaultValue: 0 }])] }));
+    }
+    return [command('libraries', 'Native FID and BSim/H2 library identity/similarity databases', databases), command('formats', 'Native loaders and exporters', [
+            command('loaders', 'Read installed loader names and supported specs/options for consumed bytes', ({ options: o }, c) => service(c).loaders(resolve(c.cwd, text(o.input, 4096))), { permission: Permission.ReadOnly, options: [{ flags: '--input <file>', description: 'Input file to inspect', required: true }] }),
+            command('exporters', 'Read installed exporters and their actual options for this program', ({ options: o }, c) => service(c).exporters(scope(o)), { permission: Permission.ReadOnly, options: selectedOptions }),
+            command('export', 'Export through an explicitly selected native exporter with typed options/ranges', ({ options: o }, c) => {
+                const p = { exporter: text(o.exporter, 512), options: object(json(o.options)) };
+                if (o.ranges !== undefined) {
+                    const ranges = json(o.ranges);
+                    if (!Array.isArray(ranges) || !ranges.length || ranges.length > 64)
+                        fail('invalid', 'Export ranges require 1–64 start/end objects.');
+                    p.ranges = ranges;
+                }
+                return service(c).export(scope(o), 'export', p, resolve(c.cwd, text(o.outputDirectory, 4096)), o.requestId === undefined ? undefined : id(o.requestId));
+            }, { permission: Permission.Update, options: [...outputs, { flags: '--exporter <id>', description: 'Explicit native exporter name/ID', required: true }, { flags: '--options <json>', description: 'Named primitive native options', defaultValue: '{}' }, { flags: '--ranges <json>', description: 'Address ranges with start/end; exporter must support restricted output' }] }),
+        ]), command('types', 'Native type archives', [
+            command('archive-export', 'Export 1–256 explicit type paths to a native GDT with checked layout', ({ options: o }, c) => {
+                const types = json(o.types);
+                if (!Array.isArray(types) || !types.length || types.length > 256 || types.some(v => typeof v !== 'string' || !v.startsWith('/')))
+                    fail('invalid', 'Types must be 1–256 absolute type paths.');
+                return service(c).export(scope(o), 'archive-export', { types }, resolve(c.cwd, text(o.outputDirectory, 4096)), o.requestId === undefined ? undefined : id(o.requestId));
+            }, { permission: Permission.Update, options: [...outputs, { flags: '--types <json>', description: 'Selected native type paths', required: true }] }),
+        ])];
+}

package/dist/src/sdk.d.ts

@@ -0,0 +1,4 @@
+import { type CommandContext, type CommandDefinition } from '@eyeauras/cli-factory';
+import { Research } from './research.js';
+export declare function sdkInputs(operation: string, p: Record<string, unknown>): void;
+export declare function sdkCommands(research: (c: CommandContext) => Research): CommandDefinition[];

package/dist/src/sdk.js

@@ -0,0 +1,125 @@
+import { command, Permission } from '@eyeauras/cli-factory';
+import { sdkOperations } from './sdk-contracts.js';
+import { option, key, parsed, selectedOptions } from './arguments.js';
+import { scope, address, number } from './research.js';
+import { id, fail, object, text } from './model.js';
+import { verifyMutation } from './mutation-effects.js';
+import { resolve } from 'node:path';
+export function sdkInputs(operation, p) {
+    if (['type-structure', 'type-layout', 'type-settings'].includes(operation) && !/^\/(?:[^/\0]+\/)*[^/\0]+$/.test(String(p.path)))
+        fail('invalid', 'Types require an absolute native type path.');
+    for (const name of ['packing', 'alignment'])
+        if (p[name] !== undefined) {
+            const n = number(Number(p[name]) + 1, 65) - 1;
+            if (n > 0 && (n & (n - 1)) !== 0)
+                fail('invalid', 'Packing/alignment must be -1, zero or a power of two through 64.');
+        }
+    if (p.types !== undefined && (!Array.isArray(p.types) || !p.types.length || p.types.length > 256 || p.types.some(v => typeof v !== 'string' || !v.startsWith('/'))))
+        fail('invalid', 'Select 1–256 explicit type paths.');
+    if (operation === 'type-structure' && (!Array.isArray(p.fields) || !p.fields.length || p.fields.length > 256))
+        fail('invalid', 'A structure needs 1–256 field objects.');
+    if (operation === 'type-structure') {
+        const names = new Set();
+        for (const item of p.fields) {
+            const field = object(item), name = text(field.name, 512);
+            text(field.type, 512);
+            if (names.has(name) || Object.keys(field).some(key => !['name', 'type', 'comment', 'offset', 'bit_size', 'bit_offset', 'byte_width'].includes(key)))
+                fail('invalid', 'Fields require unique names and known layout properties.');
+            names.add(name);
+            if (field.comment !== undefined && (typeof field.comment !== 'string' || field.comment.length > 4096 || field.comment.includes('\0')))
+                fail('invalid', 'Field comment exceeds its text bound.');
+            for (const [key, max, min] of [['offset', 1048576, 0], ['bit_size', 512, 1], ['bit_offset', 511, 0], ['byte_width', 64, 1]])
+                if (field[key] !== undefined) {
+                    if (typeof field[key] !== 'number')
+                        fail('invalid', 'Field numeric values must be exact JSON integers.');
+                    number(field[key], max, min);
+                }
+            if (field.offset !== undefined && Number(p.packing ?? 0) >= 0)
+                fail('invalid', 'Explicit field offsets require disabled packing (-1).');
+            if ((field.bit_offset !== undefined || field.byte_width !== undefined) && (field.bit_size === undefined || field.offset === undefined))
+                fail('invalid', 'Explicit bit placement requires a bitfield and byte offset.');
+        }
+    }
+    if (operation === 'type-settings')
+        for (const value of Object.values(object(p.settings))) {
+            if (value !== null && (!['string', 'number', 'boolean'].includes(typeof value) || typeof value === 'number' && !Number.isSafeInteger(value) || typeof value === 'string' && (value.length > 4096 || value.includes('\0'))))
+                fail('invalid', 'Type settings require bounded primitive values or null.');
+        }
+    if (operation === 'decompiler-ir')
+        for (const [key, value] of Object.entries(object(p.options ?? {})))
+            if (!['eliminate_unreachable', 'respect_read_only', 'infer_constant_pointers', 'split_structures', 'split_arrays'].includes(key) || typeof value !== 'boolean')
+                fail('invalid', 'Decompiler options require known Boolean properties.');
+    if (operation === 'changes') {
+        const categories = p.categories;
+        if (!Array.isArray(categories) || !categories.length || categories.length > 8 || new Set(categories).size !== categories.length || categories.some(value => !['bytes', 'code_units', 'comments', 'symbols', 'functions', 'references', 'context', 'properties'].includes(String(value))))
+            fail('invalid', 'Select 1–8 distinct supported diff categories.');
+    }
+    for (const name of ['expect_hex', 'bytes_hex'])
+        if (p[name] !== undefined &&
+            (typeof p[name] !== 'string' || !/^(?:[a-fA-F0-9]{2}){1,4096}$/.test(p[name])))
+            fail('invalid', name + ' needs 1–4096 complete hex bytes.');
+    if (operation === 'patch-bytes' && String(p.expect_hex).length !== String(p.bytes_hex).length)
+        fail('invalid', 'Expected and replacement lengths must match.');
+    for (const name of ['expect_sha256', 'second_sha256'])
+        if (p[name] !== undefined && !/^[a-f0-9]{64}$/.test(String(p[name])))
+            fail('invalid', 'Memory preconditions require SHA256.');
+    for (const name of ['expect_size', 'second_size'])
+        if (p[name] !== undefined)
+            p[name] = number(p[name], 16777216, 1);
+    for (const [name, max] of [['max_ranges', 1000], ['max_ops', 10000], ['timeout_seconds', 120]])
+        if (p[name] !== undefined)
+            p[name] = number(p[name], max, 1);
+    if (p.instructions !== undefined && (!Array.isArray(p.instructions) || !p.instructions.length || p.instructions.length > 64 || p.instructions.some(v => typeof v !== 'string' || v.length > 512 || /[\r\n\0]/.test(v))))
+        fail('invalid', 'Assembly requires 1–64 bounded instruction strings.');
+    if (operation === 'library-update' && p.new_name === undefined && p.path === undefined)
+        fail('invalid', 'Supply a library name or path update.');
+    if (operation.startsWith('context-') && p.end_address !== undefined) {
+        const start = address(p.address), end = address(p.end_address), parts = (v) => v.split(':');
+        const a = parts(start), b = parts(end);
+        if (a.length !== b.length || a.length === 2 && a[0] !== b[0])
+            fail('invalid', 'Processor context needs one address space.');
+        const length = BigInt('0x' + b.at(-1)) - BigInt('0x' + a.at(-1)) + 1n;
+        if (length < 1n || length > 65536n)
+            fail('invalid', 'Processor context range is 1–65536 bytes.');
+    }
+    if (operation === 'context-set' && !/^(?:0x)?[a-f0-9]{1,128}$/i.test(String(p.value)))
+        fail('invalid', 'Context value must be an unsigned hex integer.');
+    if (operation === 'context-set')
+        p.value = String(p.value).toLowerCase();
+}
+export function sdkCommands(research) {
+    const groups = new Map();
+    for (const entry of sdkOperations) {
+        const children = groups.get(entry.group) ?? [];
+        groups.set(entry.group, children);
+        children.push(command(entry.name, entry.description, async ({ options: o }, c) => {
+            const selected = scope(o), p = {};
+            for (const parameter of entry.params) {
+                const value = o[key(parameter.name)];
+                if (value !== undefined)
+                    p[parameter.name] = parsed(parameter, value);
+                else if (parameter.required)
+                    fail('invalid', 'Missing ' + parameter.name);
+            }
+            sdkInputs(entry.operation, p);
+            const api = research(c), operation = '/sdk/' + entry.operation;
+            if (entry.operation === 'type-archive-import') {
+                const archive = await api.workspace.artifacts.capture(resolve(c.cwd, String(p.input)), 'input');
+                if (archive.size > 67108864)
+                    fail('limit', 'Type archive exceeds 64 MiB.');
+                delete p.input;
+                p.archive = archive;
+            }
+            if (entry.write)
+                return api.mutate(selected, operation, p, async () => ({}), o.requestId === undefined ? undefined : id(o.requestId), (backend, snapshot, response) => verifyMutation(backend, snapshot, operation, p, response));
+            const other = entry.pair ? { session: o.otherSession === undefined ? selected.session : id(o.otherSession), target: id(o.otherTarget) } : undefined;
+            const value = object(other ? await api.crossRead(selected, other, operation, p) : await api.read(selected, operation, p));
+            if (Buffer.byteLength(JSON.stringify(value)) > 1048576)
+                fail('limit', 'SDK result exceeds 1 MiB; narrow the operation.');
+            return { ...selected, ...(other ? { other } : {}), value };
+        }, { permission: entry.write ? 'Destructive' : Permission.ReadOnly, options: [...selectedOptions, ...entry.params.map(option),
+                ...(entry.pair ? [{ flags: '--other-target <id>', description: 'Second immutable target', required: true }, { flags: '--other-session <id>', description: 'Second session (default selected session)' }] : []),
+                ...(entry.write ? [{ flags: '--request-id <id>', description: 'Retrieve this changing intent without repeating it' }] : [])] }));
+    }
+    return [...groups].map(([name, children]) => command(name, name + ' native SDK workflows', children));
+}

package/dist/src/server.d.ts

@@ -0,0 +1,44 @@
+import type { CommandContext } from '@eyeauras/cli-factory';
+import { type ChildProcess } from 'node:child_process';
+import { type NativeInputs } from './native-inputs.js';
+export interface ServerBinding {
+    mode: 'local' | 'external';
+    origin: string;
+    repository: string;
+    readerUser: string;
+    publisherUser: string;
+    readerSecret: string;
+    publisherSecret: string;
+}
+/** Own local startup; external profiles connect without taking ownership of their server. */
+export declare class GhidraServer {
+    readonly directory: string;
+    private readonly inputs;
+    private readonly c;
+    private readonly state;
+    constructor(directory: string, inputs: NativeInputs, c: CommandContext, state?: {
+        initializing?: Promise<ServerBinding>;
+        child?: ChildProcess;
+    });
+    fork(c: CommandContext): GhidraServer;
+    private root;
+    private run;
+    credentials(binding: ServerBinding, role: 'reader' | 'publisher'): Promise<Record<string, string>>;
+    fields(snapshot: string, selectors: string): Promise<Record<string, unknown>>;
+    inspect(snapshot: string, request: string): Promise<Record<string, unknown>>;
+    sdkFile(operation: string, p: Record<string, unknown>): Promise<Record<string, unknown>>;
+    traceInspect(snapshot: string): Promise<Record<string, unknown>>;
+    project(operation: string, parameters: Record<string, unknown>): Promise<Record<string, unknown>>;
+    projectOutcome(requestId: string, expected: Record<string, unknown>): Promise<Record<string, unknown> | undefined>;
+    administration(operation: string, parameters: Record<string, unknown>): Promise<Record<string, unknown>>;
+    programStatus(binding: ServerBinding, path: string): Promise<Record<string, unknown>>;
+    initialImport(root: string): Promise<Record<string, unknown>>;
+    initialPublication(binding: ServerBinding, root: string, operation?: 'stage' | 'verify-stage' | 'promote' | 'verify'): Promise<Record<string, unknown>>;
+    publish(binding: ServerBinding, path: string, snapshot: string, expected: number, request: string, journal: string, sourceSha: string): Promise<Record<string, unknown>>;
+    recoverPublication(binding: ServerBinding, path: string, snapshot: string, expected: number, request: string, journal: string, sourceSha: string): Promise<Record<string, unknown>>;
+    private authority;
+    ensure(): Promise<ServerBinding>;
+    private initialize;
+    private identity;
+    stop(): Promise<void>;
+}