@feilunxitong/arkit 0.1.0

package/dist/dashboard.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Dashboard — 信任仪表盘
+ * Real-time trust monitoring for AI agents.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dashboard = void 0;
+class Dashboard {
+    guard;
+    breaker;
+    validator;
+    score;
+    achievements;
+    constructor(guard, breaker, validator, score, achievements) {
+        this.guard = guard;
+        this.breaker = breaker;
+        this.validator = validator;
+        this.score = score;
+        this.achievements = achievements;
+    }
+    get trustMonitor() {
+        const gs = this.guard.stats;
+        const bs = this.breaker.stats;
+        const vs = this.validator.stats;
+        return {
+            guardPasses: gs.passes,
+            guardIntercepts: gs.intercepts,
+            guardSaveRate: gs.saveRate,
+            breakerState: bs.state,
+            breakerReliability: bs.reliability,
+            validatorPassed: vs.passed,
+            validatorBlocked: vs.blocked,
+            validatorBlockRate: vs.blockRate,
+            score: this.score.score,
+            grade: this.score.grade,
+        };
+    }
+    /** Render a text dashboard */
+    render() {
+        const t = this.trustMonitor;
+        const unlocked = this.achievements.unlocked;
+        return `
+╔══════════════════════════════════════════════════╗
+║           🛡 ARK Trust Dashboard                  ║
+╠══════════════════════════════════════════════════╣
+║                                                  ║
+║  🛡 Idempotency Guard                            ║
+║     Passes: ${String(t.guardPasses).padEnd(5)} Intercepts: ${String(t.guardIntercepts).padEnd(5)}       ║
+║     Save Rate: ${t.guardSaveRate.padEnd(10)}                       ║
+║                                                  ║
+║  ⚡ Circuit Breaker                               ║
+║     State: ${t.breakerState.padEnd(10)} Reliability: ${t.breakerReliability.padEnd(10)}  ║
+║                                                  ║
+║  🔧 Output Validator                             ║
+║     Passed: ${String(t.validatorPassed).padEnd(5)} Blocked: ${String(t.validatorBlocked).padEnd(5)}        ║
+║     Block Rate: ${t.validatorBlockRate.padEnd(10)}                       ║
+║                                                  ║
+║  🎯 Reliability Score: ${String(t.score).padEnd(5)} ${t.grade.padEnd(6)}              ║
+║                                                  ║
+║  🏆 Achievements: ${String(unlocked.length).padEnd(2)}/8 unlocked                       ║
+║     ${unlocked.map((a) => `${a.icon} ${a.name}`).join(' | ') || 'None yet'}${' '.repeat(Math.max(0, 30 - unlocked.map((a) => `${a.icon} ${a.name}`).join(' | ').length))}║
+║                                                  ║
+╚══════════════════════════════════════════════════╝`;
+    }
+}
+exports.Dashboard = Dashboard;

package/dist/guard.d.ts

@@ -0,0 +1,24 @@
+interface GuardStats {
+    passes: number;
+    intercepts: number;
+    entries: number;
+    saveRate: string;
+}
+export declare class IdempotencyGuard {
+    private ttlMs;
+    private executed;
+    private passes;
+    private intercepts;
+    constructor(ttlMs?: number);
+    /** Generate a deterministic key from tool + params */
+    key(toolName: string, params: Record<string, unknown>): string;
+    /** Check if this call has been executed before */
+    check(key: string): boolean;
+    /** Record a tool execution result */
+    record(key: string, result: unknown): void;
+    /** Decorator: wrap a function with idempotency */
+    wrap<T extends (...args: any[]) => any>(toolName: string, fn: T): T;
+    reset(): void;
+    get stats(): GuardStats;
+}
+export {};

package/dist/guard.js

@@ -0,0 +1,106 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdempotencyGuard = void 0;
+/**
+ * IdempotencyGuard — 幂等守护
+ * Gene source: Stripe payment idempotency
+ * Prevents duplicate tool execution via parameter hashing.
+ */
+const crypto = __importStar(require("crypto"));
+class IdempotencyGuard {
+    ttlMs;
+    executed = new Map();
+    passes = 0;
+    intercepts = 0;
+    constructor(ttlMs = 3_600_000) {
+        this.ttlMs = ttlMs;
+    }
+    /** Generate a deterministic key from tool + params */
+    key(toolName, params) {
+        const raw = JSON.stringify({ tool: toolName, params });
+        return crypto.createHash('sha256').update(raw).digest('hex').slice(0, 16);
+    }
+    /** Check if this call has been executed before */
+    check(key) {
+        const entry = this.executed.get(key);
+        if (!entry)
+            return false;
+        if (Date.now() - entry.at > this.ttlMs) {
+            this.executed.delete(key);
+            return false;
+        }
+        return true;
+    }
+    /** Record a tool execution result */
+    record(key, result) {
+        this.executed.set(key, { result, at: Date.now() });
+        this.passes++;
+        // Cleanup old entries
+        const cutoff = Date.now() - this.ttlMs;
+        for (const [k, v] of this.executed) {
+            if (v.at < cutoff)
+                this.executed.delete(k);
+        }
+    }
+    /** Decorator: wrap a function with idempotency */
+    wrap(toolName, fn) {
+        return ((...args) => {
+            const k = this.key(toolName, args.length === 1 ? args[0] : { args });
+            if (this.check(k)) {
+                this.intercepts++;
+                return this.executed.get(k).result;
+            }
+            const result = fn(...args);
+            this.record(k, result);
+            return result;
+        });
+    }
+    reset() {
+        this.executed.clear();
+        this.passes = 0;
+        this.intercepts = 0;
+    }
+    get stats() {
+        const total = this.passes + this.intercepts;
+        return {
+            passes: this.passes,
+            intercepts: this.intercepts,
+            entries: this.executed.size,
+            saveRate: total > 0 ? `${((this.intercepts / total) * 100).toFixed(1)}%` : '0%',
+        };
+    }
+}
+exports.IdempotencyGuard = IdempotencyGuard;

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ARK — Agent Reliability Kit
+ * Trust infrastructure for AI agents. TypeScript/Node.js edition.
+ *
+ * 基因重组:
+ *   🏦 Stripe → IdempotencyGuard
+ *   ⚡ Sentinel → CircuitBreaker
+ *   👁 OpenTelemetry → Trace
+ *   🔧 IDE → OutputValidator
+ *   🎮 Gaming → ReliabilityScore + Achievements
+ */
+export { IdempotencyGuard } from './guard.js';
+export { CircuitBreaker, CircuitOpenError } from './breaker.js';
+export { OutputValidator, ValidationResult } from './validator.js';
+export { Trace, Span } from './trace.js';
+export { ReliabilityScore } from './score.js';
+export { SchemaRegistry } from './schema-registry.js';
+export { detectFrameworks, autoInit } from './auto.js';
+export { Achievements, Achievement, definitions } from './achievements.js';
+export { Dashboard, TrustMonitor } from './dashboard.js';
+export { StatefulBreaker } from './stateful-breaker.js';
+export { ModulePipeline, ModuleBlockError, RateLimitModule, LoggingModule } from './module-kit.js';
+export type { Module, ModuleResult } from './module-kit.js';
+export { Benchmarks } from './benchmarks.js';
+export { MultiAgentProtocol } from './multi-agent.js';
+export { ProactiveGuard, ProactiveBlockError } from './proactive.js';
+export { SchemaHub, validateSchema } from './schema-hub.js';
+export type { SchemaMeta } from './schema-hub.js';
+export { BUILTIN_SCHEMAS, BUILTIN_META, CATEGORIES } from './schema-hub.js';

package/dist/index.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * ARK — Agent Reliability Kit
+ * Trust infrastructure for AI agents. TypeScript/Node.js edition.
+ *
+ * 基因重组:
+ *   🏦 Stripe → IdempotencyGuard
+ *   ⚡ Sentinel → CircuitBreaker
+ *   👁 OpenTelemetry → Trace
+ *   🔧 IDE → OutputValidator
+ *   🎮 Gaming → ReliabilityScore + Achievements
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CATEGORIES = exports.BUILTIN_META = exports.BUILTIN_SCHEMAS = exports.validateSchema = exports.SchemaHub = exports.ProactiveBlockError = exports.ProactiveGuard = exports.MultiAgentProtocol = exports.Benchmarks = exports.LoggingModule = exports.RateLimitModule = exports.ModuleBlockError = exports.ModulePipeline = exports.StatefulBreaker = exports.Dashboard = exports.definitions = exports.Achievements = exports.autoInit = exports.detectFrameworks = exports.SchemaRegistry = exports.ReliabilityScore = exports.Trace = exports.OutputValidator = exports.CircuitOpenError = exports.CircuitBreaker = exports.IdempotencyGuard = void 0;
+var guard_js_1 = require("./guard.js");
+Object.defineProperty(exports, "IdempotencyGuard", { enumerable: true, get: function () { return guard_js_1.IdempotencyGuard; } });
+var breaker_js_1 = require("./breaker.js");
+Object.defineProperty(exports, "CircuitBreaker", { enumerable: true, get: function () { return breaker_js_1.CircuitBreaker; } });
+Object.defineProperty(exports, "CircuitOpenError", { enumerable: true, get: function () { return breaker_js_1.CircuitOpenError; } });
+var validator_js_1 = require("./validator.js");
+Object.defineProperty(exports, "OutputValidator", { enumerable: true, get: function () { return validator_js_1.OutputValidator; } });
+var trace_js_1 = require("./trace.js");
+Object.defineProperty(exports, "Trace", { enumerable: true, get: function () { return trace_js_1.Trace; } });
+var score_js_1 = require("./score.js");
+Object.defineProperty(exports, "ReliabilityScore", { enumerable: true, get: function () { return score_js_1.ReliabilityScore; } });
+var schema_registry_js_1 = require("./schema-registry.js");
+Object.defineProperty(exports, "SchemaRegistry", { enumerable: true, get: function () { return schema_registry_js_1.SchemaRegistry; } });
+var auto_js_1 = require("./auto.js");
+Object.defineProperty(exports, "detectFrameworks", { enumerable: true, get: function () { return auto_js_1.detectFrameworks; } });
+Object.defineProperty(exports, "autoInit", { enumerable: true, get: function () { return auto_js_1.autoInit; } });
+var achievements_js_1 = require("./achievements.js");
+Object.defineProperty(exports, "Achievements", { enumerable: true, get: function () { return achievements_js_1.Achievements; } });
+Object.defineProperty(exports, "definitions", { enumerable: true, get: function () { return achievements_js_1.definitions; } });
+var dashboard_js_1 = require("./dashboard.js");
+Object.defineProperty(exports, "Dashboard", { enumerable: true, get: function () { return dashboard_js_1.Dashboard; } });
+// v0.4.1 — New modules
+var stateful_breaker_js_1 = require("./stateful-breaker.js");
+Object.defineProperty(exports, "StatefulBreaker", { enumerable: true, get: function () { return stateful_breaker_js_1.StatefulBreaker; } });
+var module_kit_js_1 = require("./module-kit.js");
+Object.defineProperty(exports, "ModulePipeline", { enumerable: true, get: function () { return module_kit_js_1.ModulePipeline; } });
+Object.defineProperty(exports, "ModuleBlockError", { enumerable: true, get: function () { return module_kit_js_1.ModuleBlockError; } });
+Object.defineProperty(exports, "RateLimitModule", { enumerable: true, get: function () { return module_kit_js_1.RateLimitModule; } });
+Object.defineProperty(exports, "LoggingModule", { enumerable: true, get: function () { return module_kit_js_1.LoggingModule; } });
+var benchmarks_js_1 = require("./benchmarks.js");
+Object.defineProperty(exports, "Benchmarks", { enumerable: true, get: function () { return benchmarks_js_1.Benchmarks; } });
+var multi_agent_js_1 = require("./multi-agent.js");
+Object.defineProperty(exports, "MultiAgentProtocol", { enumerable: true, get: function () { return multi_agent_js_1.MultiAgentProtocol; } });
+var proactive_js_1 = require("./proactive.js");
+Object.defineProperty(exports, "ProactiveGuard", { enumerable: true, get: function () { return proactive_js_1.ProactiveGuard; } });
+Object.defineProperty(exports, "ProactiveBlockError", { enumerable: true, get: function () { return proactive_js_1.ProactiveBlockError; } });
+var schema_hub_js_1 = require("./schema-hub.js");
+Object.defineProperty(exports, "SchemaHub", { enumerable: true, get: function () { return schema_hub_js_1.SchemaHub; } });
+Object.defineProperty(exports, "validateSchema", { enumerable: true, get: function () { return schema_hub_js_1.validateSchema; } });
+var schema_hub_js_2 = require("./schema-hub.js");
+Object.defineProperty(exports, "BUILTIN_SCHEMAS", { enumerable: true, get: function () { return schema_hub_js_2.BUILTIN_SCHEMAS; } });
+Object.defineProperty(exports, "BUILTIN_META", { enumerable: true, get: function () { return schema_hub_js_2.BUILTIN_META; } });
+Object.defineProperty(exports, "CATEGORIES", { enumerable: true, get: function () { return schema_hub_js_2.CATEGORIES; } });

package/dist/langchain.d.ts

@@ -0,0 +1,72 @@
+/**
+ * ARK × LangChain.js Integration
+ * Drop-in trust layer for LangChain agents.
+ *
+ * Usage:
+ *   import { ARKCallbackHandler } from 'ark-trust/langchain';
+ *   const agent = await createOpenAIToolsAgent({ llm, tools, prompt });
+ *   const executor = new AgentExecutor({ agent, tools, callbacks: [new ARKCallbackHandler()] });
+ */
+import { IdempotencyGuard } from './guard.js';
+import { CircuitBreaker } from './breaker.js';
+import { OutputValidator } from './validator.js';
+import { Trace } from './trace.js';
+interface CallbackInput {
+    name: string;
+    [key: string]: unknown;
+}
+interface LLMResult {
+    generations: Array<{
+        text: string;
+        [key: string]: unknown;
+    }>;
+    llmOutput?: Record<string, unknown>;
+}
+export interface ARKReport {
+    toolCalls: number;
+    intercepted: number;
+    blocked: number;
+    guard: object;
+    breaker: object;
+    validator: object;
+    trace: object | undefined;
+}
+/**
+ * ARK信任层 × LangChain.js Callback系统
+ *
+ * 接入方式: 在 AgentExecutor 的 callbacks 中传入
+ *   callbacks: [new ARKCallbackHandler()]
+ */
+export declare class ARKCallbackHandler {
+    guard: IdempotencyGuard;
+    breaker: CircuitBreaker;
+    validator: OutputValidator;
+    trace: Trace | null;
+    private intercepted;
+    private blocked;
+    private toolCalls;
+    constructor(opts?: {
+        idempotencyTtlMs?: number;
+        circuitFailures?: number;
+        circuitRecoveryMs?: number;
+    });
+    handleLLMStart(_llm: unknown, _prompts: string[]): void;
+    handleLLMEnd(_output: LLMResult): void;
+    handleLLMError(err: Error): void;
+    handleToolStart(tool: CallbackInput, input: string): void;
+    handleToolEnd(output: string): void;
+    handleToolError(err: Error): void;
+    handleAgentAction(action: {
+        tool: string;
+        toolInput: unknown;
+        log: string;
+    }): void;
+    handleAgentFinish(_finish: unknown): void;
+    handleChainStart(_chain: unknown): void;
+    handleChainEnd(_outputs: unknown): void;
+    handleChainError(err: Error): void;
+    /** Generate a trust report after the run */
+    get report(): string;
+    get stats(): ARKReport;
+}
+export {};

package/dist/langchain.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * ARK × LangChain.js Integration
+ * Drop-in trust layer for LangChain agents.
+ *
+ * Usage:
+ *   import { ARKCallbackHandler } from 'ark-trust/langchain';
+ *   const agent = await createOpenAIToolsAgent({ llm, tools, prompt });
+ *   const executor = new AgentExecutor({ agent, tools, callbacks: [new ARKCallbackHandler()] });
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARKCallbackHandler = void 0;
+const guard_js_1 = require("./guard.js");
+const breaker_js_1 = require("./breaker.js");
+const validator_js_1 = require("./validator.js");
+const trace_js_1 = require("./trace.js");
+/**
+ * ARK信任层 × LangChain.js Callback系统
+ *
+ * 接入方式: 在 AgentExecutor 的 callbacks 中传入
+ *   callbacks: [new ARKCallbackHandler()]
+ */
+class ARKCallbackHandler {
+    guard;
+    breaker;
+    validator;
+    trace = null;
+    intercepted = 0;
+    blocked = 0;
+    toolCalls = 0;
+    constructor(opts) {
+        this.guard = new guard_js_1.IdempotencyGuard(opts?.idempotencyTtlMs ?? 3_600_000);
+        this.breaker = new breaker_js_1.CircuitBreaker('langchain-agent', opts?.circuitFailures ?? 3, opts?.circuitRecoveryMs ?? 30_000);
+        this.validator = new validator_js_1.OutputValidator();
+    }
+    // ===== LLM Events =====
+    handleLLMStart(_llm, _prompts) {
+        this.trace = new trace_js_1.Trace('agent-turn');
+        this.trace.startSpan('llm_call', { promptCount: String(_prompts?.length ?? 0) });
+    }
+    handleLLMEnd(_output) {
+        if (this.trace) {
+            this.trace.endSpan(_output?.generations?.[0]?.text?.slice(0, 200));
+        }
+    }
+    handleLLMError(err) {
+        if (this.trace) {
+            this.trace.endSpan(undefined, err.message.slice(0, 200));
+        }
+    }
+    // ===== Tool Events — ARK核心拦截点 =====
+    handleToolStart(tool, input) {
+        this.toolCalls++;
+        const toolName = tool.name || 'unknown_tool';
+        // 幂等检查
+        const key = this.guard.key(toolName, { input });
+        if (this.guard.check(key)) {
+            this.intercepted++;
+        }
+        this.guard.record(key, `result_for_${key}`);
+        // 链路追踪
+        if (this.trace) {
+            this.trace.startSpan('tool_call', { tool: toolName, input: input.slice(0, 100) });
+        }
+    }
+    handleToolEnd(output) {
+        if (this.trace) {
+            this.trace.endSpan(output?.slice(0, 200));
+        }
+    }
+    handleToolError(err) {
+        if (this.trace) {
+            this.trace.endSpan(undefined, err.message.slice(0, 200));
+        }
+    }
+    // ===== Agent Events =====
+    handleAgentAction(action) {
+        if (this.trace) {
+            this.trace.startSpan('agent_action', {
+                tool: action.tool,
+                log: action.log?.slice(0, 100),
+            });
+        }
+    }
+    handleAgentFinish(_finish) {
+        if (this.trace) {
+            this.trace.endSpan();
+        }
+    }
+    // ===== Chain Events (generic fallback) =====
+    handleChainStart(_chain) {
+        if (!this.trace) {
+            this.trace = new trace_js_1.Trace('chain-run');
+        }
+    }
+    handleChainEnd(_outputs) {
+        // chain complete
+    }
+    handleChainError(err) {
+        if (this.trace) {
+            this.trace.endSpan(undefined, err.message.slice(0, 200));
+        }
+    }
+    /** Generate a trust report after the run */
+    get report() {
+        const gs = this.guard.stats;
+        const bs = this.breaker.stats;
+        const vs = this.validator.stats;
+        const ts = this.trace?.summary();
+        return [
+            '╔═══════════════════════════════╗',
+            '║  🛡 ARK × LangChain Report    ║',
+            '╠═══════════════════════════════╣',
+            `║  Tool Calls:     ${String(this.toolCalls).padEnd(11)} ║`,
+            `║  Intercepted:    ${String(this.intercepted).padEnd(11)} ║`,
+            `║  Blocked:        ${String(this.blocked).padEnd(11)} ║`,
+            `║  Save Rate:      ${gs.saveRate.padEnd(11)} ║`,
+            `║  Breaker:        ${bs.state.padEnd(11)} ║`,
+            `║  Reliability:    ${bs.reliability.padEnd(11)} ║`,
+            `║  Path Valid:     ${vs.blockRate.padEnd(11)} ║`,
+            `║  Spans:          ${String(ts?.totalSpans ?? 0).padEnd(11)} ║`,
+            `║  Status:         ${(ts?.status ?? 'ok').padEnd(11)} ║`,
+            '╚═══════════════════════════════╝',
+        ].join('\n');
+    }
+    get stats() {
+        return {
+            toolCalls: this.toolCalls,
+            intercepted: this.intercepted,
+            blocked: this.blocked,
+            guard: this.guard.stats,
+            breaker: this.breaker.stats,
+            validator: this.validator.stats,
+            trace: this.trace?.summary(),
+        };
+    }
+}
+exports.ARKCallbackHandler = ARKCallbackHandler;

package/dist/module-kit.d.ts

@@ -0,0 +1,64 @@
+/**
+ * ModuleKit — 可组合可靠性模块
+ * Gene source: GenericAgent（模块化能力魔方）+ nuwa-skill（认知蒸馏）
+ * Stack minimal modules into composable reliability pipelines.
+ */
+export interface ModuleResult {
+    action: 'allow' | 'block' | 'warn';
+    reason: string;
+    context: Record<string, unknown>;
+}
+export interface Module {
+    name: string;
+    enabled: boolean;
+    priority: number;
+    process(toolName: string, args: Record<string, unknown>, context: Record<string, unknown>): ModuleResult;
+    stats: Record<string, unknown>;
+}
+export declare class ModuleBlockError extends Error {
+    constructor(toolName: string, reason: string);
+}
+interface PipelineStats {
+    name: string;
+    modules: number;
+    totalCalls: number;
+    blocked: number;
+    allowed: number;
+    blockRate: string;
+    moduleList: string[];
+}
+export declare class ModulePipeline {
+    name: string;
+    modules: Module[];
+    private totalCalls;
+    private blockedCalls;
+    private allowedCalls;
+    constructor(name?: string);
+    add(module: Module): this;
+    remove(moduleName: string): boolean;
+    process(toolName: string, args: Record<string, unknown>): ModuleResult;
+    wrap<T extends (...args: unknown[]) => unknown>(toolFunc: T, toolName?: string): (...args: Parameters<T>) => ReturnType<T>;
+    get stats(): PipelineStats;
+}
+export declare class RateLimitModule implements Module {
+    name: string;
+    enabled: boolean;
+    priority: number;
+    maxCallsPerMinute: number;
+    private callTimestamps;
+    private blocked;
+    private passed;
+    constructor(maxCallsPerMinute?: number);
+    process(_toolName: string, _args: Record<string, unknown>, context: Record<string, unknown>): ModuleResult;
+    get stats(): Record<string, unknown>;
+}
+export declare class LoggingModule implements Module {
+    name: string;
+    enabled: boolean;
+    priority: number;
+    private log;
+    maxLogSize: number;
+    process(toolName: string, args: Record<string, unknown>, context: Record<string, unknown>): ModuleResult;
+    get stats(): Record<string, unknown>;
+}
+export {};