vibe-splain 3.4.1 → 3.5.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vibe-splain",
-  "version": "3.4.1",
-  "description": "Architectural mapping and behavioral call-chain engine. Built on a language-agnostic foundation with specialized optimization for TypeScript/JavaScript projects.",
+  "version": "3.5.0",
+  "description": "Static-analysis MRI for codebases: a Tree-Sitter dossier engine and deterministic PreToolUse safety gate for coding agents. Language-agnostic core, optimized for TypeScript/JavaScript.",
   "type": "module",
   "license": "MIT",
   "author": "abp2204",

package/dist/commands/bundle.d.ts

@@ -1,4 +0,0 @@
-export declare function bundleCommand(scanId: string, opts?: {
-    output?: string;
-    projectRoot?: string;
-}): Promise<void>;

package/dist/commands/bundle.js

@@ -1,68 +0,0 @@
-import { join } from 'path';
-import { writeFile, mkdir, copyFile, rm } from 'fs/promises';
-import { existsSync } from 'fs';
-import * as tar from 'tar';
-import { PointerStore } from '../store/PointerStore.js';
-import { BlobStore } from '../store/BlobStore.js';
-export async function bundleCommand(scanId, opts = {}) {
-    const root = opts.projectRoot ?? process.cwd();
-    const outputPath = opts.output ?? join(root, `vibe-bundle-${scanId}.tar.gz`);
-    console.error(`[vibe-splain bundle] Bundling scan ${scanId} from ${root}`);
-    const pointerStore = PointerStore.open(root);
-    const blobStore = new BlobStore(root);
-    const pointers = pointerStore.listPointersByScan(scanId);
-    if (pointers.length === 0) {
-        throw new Error(`No pointers found for scanId "${scanId}"`);
-    }
-    // Stage bundle into a temp directory with predictable layout
-    const stagingDir = join(root, '.vibe-splainer', 'tmp', `bundle-stage-${scanId}`);
-    const blobsStageDir = join(stagingDir, 'blobs');
-    await mkdir(blobsStageDir, { recursive: true });
-    try {
-        // Build manifest for the bundle
-        const bundleManifest = {
-            schemaVersion: '1.0.0',
-            scanId,
-            exportedAt: new Date().toISOString(),
-            projectRoot: root,
-            pointers: pointers.map(p => ({
-                pointerId: p.pointerId,
-                scanId: p.scanId,
-                artifactName: p.artifactName,
-                contentHash: p.contentHash,
-                blobFile: `blobs/${p.contentHash.replace('sha256:', 'sha256_')}`,
-                schemaVersion: p.schemaVersion,
-                createdAt: p.createdAt,
-                expiresAt: p.expiresAt,
-            })),
-        };
-        await writeFile(join(stagingDir, 'bundle-manifest.json'), JSON.stringify(bundleManifest, null, 2), 'utf8');
-        // Copy blobs (deduplicated by contentHash)
-        const seen = new Set();
-        for (const p of pointers) {
-            const hex = p.contentHash.replace('sha256:', '');
-            if (seen.has(hex))
-                continue;
-            seen.add(hex);
-            const srcPath = p.blobPath;
-            if (!existsSync(srcPath)) {
-                console.error(`[vibe-splain bundle] Warning: blob missing for ${p.pointerId}: ${srcPath}`);
-                continue;
-            }
-            await copyFile(srcPath, join(blobsStageDir, `sha256_${hex}`));
-        }
-        // Create tarball from staging directory
-        await tar.create({
-            gzip: true,
-            file: outputPath,
-            cwd: stagingDir,
-            portable: true,
-        }, ['.']);
-        console.error(`[vibe-splain bundle] Bundle written: ${outputPath}`);
-        console.error(`[vibe-splain bundle] ${pointers.length} pointers, ${seen.size} blobs`);
-    }
-    finally {
-        await rm(stagingDir, { recursive: true, force: true });
-    }
-}
-//# sourceMappingURL=bundle.js.map

package/dist/commands/export.d.ts

@@ -1 +0,0 @@
-export declare function exportCommand(projectRoot: string, options: any): Promise<void>;

package/dist/commands/export.js

@@ -1,19 +0,0 @@
-import { readDossier } from '@vibe-splain/brain';
-import { ExportOrchestrator } from '../export/ExportOrchestrator.js';
-export async function exportCommand(projectRoot, options) {
-    const root = projectRoot || process.cwd();
-    console.error(`[vibe-splain] Exporting dossier for ${root}`);
-    const dossier = await readDossier(root);
-    if (!dossier) {
-        console.error('[vibe-splain] Dossier not found. Run scan first.');
-        process.exit(1);
-    }
-    const orchestrator = new ExportOrchestrator(root);
-    await orchestrator.writeBundle(dossier, {
-        format: options.format,
-        budget: options.budget ? parseInt(options.budget, 10) : undefined,
-        scope: options.scope,
-    });
-    console.error('[vibe-splain] Export complete.');
-}
-//# sourceMappingURL=export.js.map

package/dist/commands/gc.d.ts

@@ -1,3 +0,0 @@
-export declare function gcCommand(projectRoot?: string, opts?: {
-    keepScans?: number;
-}): Promise<void>;

package/dist/commands/gc.js

@@ -1,59 +0,0 @@
-import { join } from 'path';
-import { rm, readdir } from 'fs/promises';
-import { PointerStore } from '../store/PointerStore.js';
-import { BlobStore } from '../store/BlobStore.js';
-const DEFAULT_KEEP_SCANS = 3;
-export async function gcCommand(projectRoot, opts = {}) {
-    const root = projectRoot ?? process.cwd();
-    const keepScans = opts.keepScans ?? DEFAULT_KEEP_SCANS;
-    console.error(`[vibe-splain gc] Running GC on ${root} (keeping last ${keepScans} scans)`);
-    const pointerStore = PointerStore.open(root);
-    const blobStore = new BlobStore(root);
-    // 1. Get all scan IDs ordered by createdAt desc
-    const allScanIds = pointerStore.listAllScanIds();
-    console.error(`[vibe-splain gc] Found ${allScanIds.length} scans`);
-    // Keep the N most recent by taking last N from sorted list
-    // Scan IDs contain timestamps, sort lexicographically descending
-    const sorted = [...allScanIds].sort().reverse();
-    const keepIds = sorted.slice(0, keepScans);
-    const deleteIds = sorted.slice(keepScans);
-    if (deleteIds.length === 0) {
-        console.error('[vibe-splain gc] Nothing to collect');
-        return;
-    }
-    // 2. Collect all blob paths still referenced by kept pointers before deletion
-    const keptPointers = keepIds.flatMap(id => pointerStore.listPointersByScan(id));
-    const referencedBlobs = new Set(keptPointers.map(p => p.blobPath));
-    // 3. Delete old scan pointers
-    const deleted = await pointerStore.gcScanPointers(keepIds);
-    console.error(`[vibe-splain gc] Deleted ${deleted} pointer rows`);
-    // 4. Delete unreferenced blobs (reference count = 0)
-    const allBlobs = await blobStore.listBlobPaths();
-    let blobsDeleted = 0;
-    for (const blobPath of allBlobs) {
-        if (!referencedBlobs.has(blobPath)) {
-            try {
-                await rm(blobPath);
-                blobsDeleted++;
-            }
-            catch {
-                // ignore — may have already been deleted
-            }
-        }
-    }
-    console.error(`[vibe-splain gc] Deleted ${blobsDeleted} unreferenced blobs`);
-    // 5. Clean up tmp dir
-    const tmpDir = join(root, '.vibe-splainer', 'tmp');
-    try {
-        const tmpFiles = await readdir(tmpDir);
-        for (const f of tmpFiles) {
-            await rm(join(tmpDir, f), { force: true });
-        }
-        console.error(`[vibe-splain gc] Cleaned ${tmpFiles.length} tmp files`);
-    }
-    catch {
-        // tmp dir may not exist
-    }
-    console.error('[vibe-splain gc] Done');
-}
-//# sourceMappingURL=gc.js.map

package/dist/commands/importBundle.d.ts

@@ -1,4 +0,0 @@
-export declare function importBundleCommand(tarballPath: string, opts?: {
-    projectRoot?: string;
-    namespace?: string;
-}): Promise<void>;

package/dist/commands/importBundle.js

@@ -1,80 +0,0 @@
-import { join } from 'path';
-import { readFile, mkdir, rm } from 'fs/promises';
-import { existsSync } from 'fs';
-import * as tar from 'tar';
-import { createHash } from 'crypto';
-import { BlobStore } from '../store/BlobStore.js';
-import { PointerStore } from '../store/PointerStore.js';
-export async function importBundleCommand(tarballPath, opts = {}) {
-    const root = opts.projectRoot ?? process.cwd();
-    const namespace = opts.namespace ?? `imported_${Date.now()}`;
-    console.error(`[vibe-splain import] Importing ${tarballPath} into ${root} (namespace: ${namespace})`);
-    if (!existsSync(tarballPath)) {
-        throw new Error(`Tarball not found: ${tarballPath}`);
-    }
-    // Extract to a temp directory
-    const extractDir = join(root, '.vibe-splainer', 'tmp', `import-${namespace}`);
-    await mkdir(extractDir, { recursive: true });
-    try {
-        await tar.extract({
-            file: tarballPath,
-            cwd: extractDir,
-        });
-        // Read bundle manifest
-        const manifestPath = join(extractDir, 'bundle-manifest.json');
-        if (!existsSync(manifestPath)) {
-            throw new Error('Invalid bundle: missing bundle-manifest.json');
-        }
-        const manifestRaw = await readFile(manifestPath, 'utf8');
-        const manifest = JSON.parse(manifestRaw);
-        if (manifest.schemaVersion !== '1.0.0') {
-            throw new Error(`Unsupported bundle schema version: ${manifest.schemaVersion}`);
-        }
-        const blobStore = new BlobStore(root);
-        const pointerStore = PointerStore.open(root);
-        await blobStore.ensureDirs();
-        let imported = 0;
-        let hashErrors = 0;
-        for (const entry of manifest.pointers) {
-            const blobSrcPath = join(extractDir, entry.blobFile);
-            if (!existsSync(blobSrcPath)) {
-                console.error(`[vibe-splain import] Missing blob for pointer ${entry.pointerId}: ${entry.blobFile}`);
-                hashErrors++;
-                continue;
-            }
-            // Verify hash before importing
-            const content = await readFile(blobSrcPath);
-            const actualHash = `sha256:${createHash('sha256').update(content).digest('hex')}`;
-            if (actualHash !== entry.contentHash) {
-                console.error(`[vibe-splain import] Hash mismatch for ${entry.pointerId}: expected ${entry.contentHash}, got ${actualHash}`);
-                hashErrors++;
-                continue;
-            }
-            // Write blob to local store (atomic)
-            const { blobPath } = await blobStore.writeAtomic(content);
-            // Insert pointer under bundle namespace alias
-            const namespacedPointerId = `${namespace}::${entry.pointerId}`;
-            const namespacedScanId = `${namespace}::${entry.scanId}`;
-            await pointerStore.insertPointer({
-                pointerId: namespacedPointerId,
-                scanId: namespacedScanId,
-                artifactName: entry.artifactName,
-                contentHash: entry.contentHash,
-                blobPath,
-                schemaVersion: entry.schemaVersion,
-                createdAt: entry.createdAt,
-                expiresAt: entry.expiresAt,
-            });
-            imported++;
-        }
-        if (hashErrors > 0) {
-            console.error(`[vibe-splain import] Warning: ${hashErrors} blobs failed hash verification and were skipped`);
-        }
-        console.error(`[vibe-splain import] Imported ${imported}/${manifest.pointers.length} pointers under namespace "${namespace}"`);
-        console.error(`[vibe-splain import] Original scanId: ${manifest.scanId} → namespaced as: ${namespace}::${manifest.scanId}`);
-    }
-    finally {
-        await rm(extractDir, { recursive: true, force: true });
-    }
-}
-//# sourceMappingURL=importBundle.js.map

package/dist/export/renderers/DeltaRenderer.d.ts

@@ -1,6 +0,0 @@
-import type { DossierViewModel, AnalysisStore } from '@vibe-splain/brain';
-import type { Renderer } from './Renderer.js';
-import type { Artifact } from '../ArtifactBundleWriter.js';
-export declare class DeltaRenderer implements Renderer {
-    render(_viewModel: DossierViewModel, store: AnalysisStore): Artifact[];
-}

package/dist/export/renderers/DeltaRenderer.js

@@ -1,22 +0,0 @@
-export class DeltaRenderer {
-    render(_viewModel, store) {
-        const deltaTargets = Object.values(store.files)
-            .filter(pf => pf.isRealSource)
-            .sort((a, b) => b.gravity - a.gravity)
-            .map(pf => ({
-            path: pf.relativePath,
-            gravity: Math.round(pf.gravity),
-            isLoadBearing: pf.canonicalLoadBearing,
-            blastRadius: pf.importedBy,
-            pillarHint: pf.pillarHint,
-        }));
-        return [
-            {
-                type: 'delta',
-                path: 'delta_targets.json',
-                content: JSON.stringify(deltaTargets, null, 2),
-            }
-        ];
-    }
-}
-//# sourceMappingURL=DeltaRenderer.js.map

package/dist/mcp/tools/apply_patch.d.ts

@@ -1,37 +0,0 @@
-export declare class StalePatchError extends Error {
-    readonly filePath: string;
-    readonly expectedHash: string;
-    readonly actualHash: string;
-    constructor(filePath: string, expectedHash: string, actualHash: string);
-}
-export declare const applyPatchTool: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectRoot: {
-                type: string;
-                description: string;
-            };
-            filePath: {
-                type: string;
-                description: string;
-            };
-            newContent: {
-                type: string;
-                description: string;
-            };
-            expectedPrePatchHash: {
-                type: string;
-                description: string;
-            };
-            scanId: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-    };
-};
-export declare function handleApplyPatch(args: Record<string, unknown>): Promise<unknown>;

package/dist/mcp/tools/apply_patch.js

@@ -1,103 +0,0 @@
-import { writeFile, rename, mkdir } from 'fs/promises';
-import { join, dirname } from 'path';
-import { SessionScope, ScopeViolation } from '../SessionScope.js';
-import { hashFile, BlobStore } from '../../store/BlobStore.js';
-import { PointerStore } from '../../store/PointerStore.js';
-import { applyBudgetGuard } from '../BudgetGuard.js';
-import { v4 as uuidv4 } from 'uuid';
-export class StalePatchError extends Error {
-    filePath;
-    expectedHash;
-    actualHash;
-    constructor(filePath, expectedHash, actualHash) {
-        super(`StalePatchError: ${filePath} hash mismatch — expected ${expectedHash}, got ${actualHash}. ` +
-            'File was modified since the expectedPrePatchHash was computed. Re-read the file and regenerate the patch.');
-        this.filePath = filePath;
-        this.expectedHash = expectedHash;
-        this.actualHash = actualHash;
-        this.name = 'StalePatchError';
-    }
-}
-export const applyPatchTool = {
-    name: 'apply_patch',
-    description: 'Applies a text patch to a file within the active workOrder scope. Requires expectedPrePatchHash to prevent stale-patch corruption. Records pre- and post-patch hashes.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            projectRoot: { type: 'string', description: 'Absolute project root' },
-            filePath: { type: 'string', description: 'Path relative to projectRoot' },
-            newContent: { type: 'string', description: 'Full new content of the file after the patch' },
-            expectedPrePatchHash: {
-                type: 'string',
-                description: 'sha256:<hex> hash of the file BEFORE patching. Obtain via hashFile or the sourceHash from get_file_skeleton.',
-            },
-            scanId: { type: 'string', description: 'Current scan ID for pointer registration' },
-        },
-        required: ['projectRoot', 'filePath', 'newContent', 'expectedPrePatchHash', 'scanId'],
-    },
-};
-export async function handleApplyPatch(args) {
-    const projectRoot = args.projectRoot;
-    const filePath = args.filePath;
-    const newContent = args.newContent;
-    const expectedPrePatchHash = args.expectedPrePatchHash;
-    const scanId = args.scanId;
-    if (!projectRoot || !filePath || !newContent || !expectedPrePatchHash || !scanId) {
-        throw new Error('projectRoot, filePath, newContent, expectedPrePatchHash, and scanId are all required');
-    }
-    // 1. Scope enforcement
-    try {
-        SessionScope.enforce(filePath);
-    }
-    catch (e) {
-        if (e instanceof ScopeViolation)
-            throw e;
-        throw e;
-    }
-    const absolutePath = filePath.startsWith('/') ? filePath : join(projectRoot, filePath);
-    // 2. Preimage hash check
-    let actualPreHash;
-    try {
-        actualPreHash = await hashFile(absolutePath);
-    }
-    catch {
-        // File doesn't exist yet — for new files, expectedPrePatchHash must be 'sha256:new'
-        actualPreHash = 'sha256:new';
-    }
-    if (actualPreHash !== expectedPrePatchHash) {
-        throw new StalePatchError(filePath, expectedPrePatchHash, actualPreHash);
-    }
-    // 3. Atomic write
-    const dir = dirname(absolutePath);
-    await mkdir(dir, { recursive: true });
-    const tmpPath = absolutePath + `.tmp_${Date.now()}`;
-    await writeFile(tmpPath, newContent, 'utf8');
-    await rename(tmpPath, absolutePath);
-    // 4. Compute post-patch hash
-    const postPatchHash = await hashFile(absolutePath);
-    // 5. Record both hashes in blob store
-    const blobStore = new BlobStore(projectRoot);
-    const pointerStore = PointerStore.open(projectRoot);
-    const { blobPath } = await blobStore.writeAtomic(newContent);
-    const pointerId = `ptr_patch_${uuidv4().replace(/-/g, '').slice(0, 12)}`;
-    await pointerStore.insertPointer({
-        pointerId,
-        scanId,
-        artifactName: 'patch_record',
-        contentHash: postPatchHash,
-        blobPath,
-        schemaVersion: '1.0.0',
-        createdAt: Date.now(),
-        expiresAt: null,
-    });
-    const result = {
-        ok: true,
-        filePath,
-        prePatchHash: actualPreHash,
-        postPatchHash,
-        pointerId,
-        message: `Patch applied to ${filePath}`,
-    };
-    return await applyBudgetGuard(projectRoot, scanId, 'patch_record', result);
-}
-//# sourceMappingURL=apply_patch.js.map

package/dist/mcp/tools/get_call_chain.d.ts

@@ -1,42 +0,0 @@
-export declare const getCallChainTool: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectRoot: {
-                type: string;
-            };
-            entrypointPath: {
-                type: string;
-                description: string;
-            };
-            maxDepth: {
-                type: string;
-                description: string;
-            };
-            targetActionKind: {
-                type: string;
-                description: string;
-            };
-            targetModel: {
-                type: string;
-                description: string;
-            };
-            targetOperation: {
-                type: string;
-                description: string;
-            };
-            targetFunctionName: {
-                type: string;
-                description: string;
-            };
-            includeTests: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-    };
-};
-export declare function handleGetCallChain(args: Record<string, unknown>): Promise<unknown>;

package/dist/mcp/tools/get_call_chain.js

@@ -1,50 +0,0 @@
-import { traverseCallChain } from '@vibe-splain/brain';
-export const getCallChainTool = {
-    name: 'get_call_chain',
-    description: `Trace how behavior is reached from an entrypoint by following function call edges through the codebase. Returns a step-by-step chain with exact function names, file paths, line numbers, action kinds, and evidence text. Every edge has a confidence level; unresolved edges are listed explicitly.
-
-Use structured filters when you know the target:
-  targetModel + targetOperation: "where does Booking get created?"
-  targetActionKind: "where is auth enforced?"  
-  targetFunctionName: "how is function X reached?"
-No filter returns the full call tree up to maxDepth.
-
-Run scan_project first — this tool reads from the generated action_bindings.json.`,
-    inputSchema: {
-        type: 'object',
-        properties: {
-            projectRoot: { type: 'string' },
-            entrypointPath: { type: 'string', description: 'Relative path to the entrypoint file' },
-            maxDepth: { type: 'number', description: 'Max traversal depth. Default 6, max 12.' },
-            targetActionKind: { type: 'string', description: 'Stop at this semantic action kind.' },
-            targetModel: { type: 'string', description: 'Stop at functions touching this model.' },
-            targetOperation: { type: 'string', description: 'Narrow targetModel to this operation.' },
-            targetFunctionName: { type: 'string', description: 'Stop at a specific function name.' },
-            includeTests: { type: 'boolean', description: 'Include test files in traversal. Default false.' },
-        },
-        required: ['projectRoot', 'entrypointPath'],
-    },
-};
-export async function handleGetCallChain(args) {
-    const projectRoot = args.projectRoot;
-    const entrypointPath = args.entrypointPath;
-    if (!projectRoot || !entrypointPath)
-        throw new Error('projectRoot and entrypointPath are required');
-    const getCallChainArgs = {
-        entrypointPath,
-        maxDepth: typeof args.maxDepth === 'number' ? args.maxDepth : undefined,
-        targetActionKind: typeof args.targetActionKind === 'string' ? args.targetActionKind : undefined,
-        targetModel: typeof args.targetModel === 'string' ? args.targetModel : undefined,
-        targetOperation: typeof args.targetOperation === 'string' ? args.targetOperation : undefined,
-        targetFunctionName: typeof args.targetFunctionName === 'string' ? args.targetFunctionName : undefined,
-        includeTests: typeof args.includeTests === 'boolean' ? args.includeTests : undefined,
-    };
-    try {
-        const result = await traverseCallChain(projectRoot, getCallChainArgs);
-        return result;
-    }
-    catch (error) {
-        throw new Error(`get_call_chain failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-//# sourceMappingURL=get_call_chain.js.map

package/dist/mcp/tools/set_session_scope.d.ts

@@ -1,19 +0,0 @@
-export declare const setSessionScopeTool: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectRoot: {
-                type: string;
-                description: string;
-            };
-            workOrderId: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-    };
-};
-export declare function handleSetSessionScope(args: Record<string, unknown>): Promise<unknown>;

package/dist/mcp/tools/set_session_scope.js

@@ -1,40 +0,0 @@
-import { PointerStore } from '../../store/PointerStore.js';
-import { SessionScope } from '../SessionScope.js';
-export const setSessionScopeTool = {
-    name: 'set_session_scope',
-    description: 'Sets the active session scope from a Work Order. All subsequent file tools (read_file, get_file_skeleton, apply_patch) will enforce this scope until overwritten or the server restarts.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            projectRoot: { type: 'string', description: 'Absolute project root' },
-            workOrderId: { type: 'string', description: 'Work Order ID to load scope from' },
-        },
-        required: ['projectRoot', 'workOrderId'],
-    },
-};
-export async function handleSetSessionScope(args) {
-    const projectRoot = args.projectRoot;
-    const workOrderId = args.workOrderId;
-    if (!projectRoot || !workOrderId) {
-        throw new Error('projectRoot and workOrderId are required');
-    }
-    const pointerStore = PointerStore.open(projectRoot);
-    const row = pointerStore.getWorkOrder(workOrderId);
-    if (!row) {
-        throw new Error(`WorkOrderNotFound: ${workOrderId}`);
-    }
-    const policy = SessionScope.fromWorkOrderRow(row);
-    SessionScope.set(policy);
-    return {
-        ok: true,
-        workOrderId,
-        scope: {
-            allowedFiles: policy.allowedFiles,
-            allowedGlobs: policy.allowedGlobs,
-            deniedGlobs: policy.deniedGlobs,
-            requiredProofCount: policy.requiredProof.length,
-        },
-        message: `Session scope set from work order ${workOrderId}. All file tools will enforce this scope.`,
-    };
-}
-//# sourceMappingURL=set_session_scope.js.map

package/dist/mcp/tools/submit_receipt.d.ts

@@ -1,68 +0,0 @@
-export declare const submitReceiptTool: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectRoot: {
-                type: string;
-                description: string;
-            };
-            receipt: {
-                type: string;
-                description: string;
-                properties: {
-                    workOrderId: {
-                        type: string;
-                    };
-                    status: {
-                        type: string;
-                        enum: string[];
-                    };
-                    proofPointers: {
-                        type: string;
-                        items: {
-                            type: string;
-                            properties: {
-                                pointer: {
-                                    type: string;
-                                };
-                                schemaName: {
-                                    type: string;
-                                };
-                                contentHash: {
-                                    type: string;
-                                };
-                            };
-                            required: string[];
-                        };
-                    };
-                    changedFiles: {
-                        type: string;
-                        items: {
-                            type: string;
-                            properties: {
-                                path: {
-                                    type: string;
-                                };
-                                prePatchHash: {
-                                    type: string;
-                                };
-                                postPatchHash: {
-                                    type: string;
-                                };
-                            };
-                            required: string[];
-                        };
-                    };
-                    summary: {
-                        type: string;
-                    };
-                };
-                required: string[];
-            };
-        };
-        required: string[];
-    };
-};
-export declare function handleSubmitReceipt(args: Record<string, unknown>): Promise<unknown>;