@wowok/agent-mcp 2.6.1 → 2.6.3

package/dist/index.js

@@ -14,6 +14,47 @@ import { registerAllTools } from "./tools/index.js";
 if (process.env.WOWOK_TELEMETRY === "false" || process.env.WOWOK_TELEMETRY === "0") {
     setTelemetryEnabled(false);
 }
+process.on("unhandledRejection", (reason, promise) => {
+    const reasonStr = reason instanceof Error
+        ? `${reason.name}: ${reason.message}\n${reason.stack ?? ""}`
+        : String(reason);
+    console.error(`[unhandledRejection] ${new Date().toISOString()}`);
+    console.error(`  reason: ${reasonStr}`);
+});
+process.on("uncaughtException", (error) => {
+    console.error(`[uncaughtException] ${new Date().toISOString()}`);
+    console.error(`  name: ${error.name}`);
+    console.error(`  message: ${error.message}`);
+    console.error(`  stack: ${error.stack ?? ""}`);
+});
+process.on("beforeExit", (code) => {
+    console.error(`[beforeExit] ${new Date().toISOString()} code=${code} — event loop empty, process would exit`);
+    console.error(`  active handles: ${process._getActiveHandles?.()?.length ?? "?"}`);
+    console.error(`  active requests: ${process._getActiveRequests?.()?.length ?? "?"}`);
+});
+process.on("exit", (code) => {
+    console.error(`[exit] ${new Date().toISOString()} code=${code} — process exiting`);
+});
+process.stdin.on("end", () => {
+    console.error(`[stdin end] ${new Date().toISOString()} — MCP client closed stdin`);
+});
+process.stdin.on("close", () => {
+    console.error(`[stdin close] ${new Date().toISOString()} — stdin stream closed`);
+});
+let keepaliveTimer = null;
+function startKeepalive() {
+    if (keepaliveTimer)
+        return;
+    keepaliveTimer = setInterval(() => {
+        const mem = process.memoryUsage();
+        const heapUsedMB = Math.round(mem.heapUsed / 1024 / 1024);
+        const heapTotalMB = Math.round(mem.heapTotal / 1024 / 1024);
+        const rssMB = Math.round(mem.rss / 1024 / 1024);
+        const level = heapUsedMB > 1200 ? "WARNING" : heapUsedMB > 800 ? "INFO" : "DEBUG";
+        console.error(`[memory ${level}] heap=${heapUsedMB}MB/${heapTotalMB}MB rss=${rssMB}MB`);
+    }, 60_000);
+}
+startKeepalive();
 const SERVER_DESCRIPTION = `WoWok MCP Server - Making It Easy for AI Agents to Communicate, Collaborate, Trade, and Trust.
 
 ## CRITICAL: Unified Single-Tool Architecture
@@ -210,5 +251,14 @@ async function main() {
         await server.close();
         process.exit(0);
     });
+    process.on("SIGTERM", async () => {
+        console.error(`[SIGTERM] ${new Date().toISOString()} — graceful shutdown`);
+        try {
+            await server.close();
+        }
+        catch {
+        }
+        process.exit(0);
+    });
 }
 main().catch(console.error);

package/dist/knowledge/deployment-scanner.js

@@ -672,7 +672,7 @@ export function analyzeMachineAndServiceReadiness(input) {
                 add(findings, "D-20", "warning", `No Service block in the deployment doc includes a compensation_fund_add step. ` +
                     `Without deposit, arbitration rulings that award refunds to buyers cannot be paid out from the Service. ` +
                     `Industries like freelance may not require this (info), but rental/travel/education typically do.`, "§3.2 / §4.2 Service blocks", `Add a compensation_fund_add step for the Service (e.g., data.compensation_fund_add = {balance: <amount>}). ` +
-                    `Recommended: 5× the max single-order amount (P1-1 evaluation rule).`);
+                    `Recommended: 3-10× the max single-order amount, depending on industry (subscription: 3×, retail: 5×, rental: 10×). See P1-1 evaluation rule.`);
             }
         }
     }

package/dist/knowledge/fund-layer.d.ts

@@ -0,0 +1,72 @@
+import type { ENTRYPOINT } from "@wowok/wowok";
+export interface OfficialTokenEntry {
+    type: string;
+    symbol: string;
+    decimals: number;
+    name: string;
+    description: string;
+}
+export type TokenNetwork = "gas" | "testnet" | "mainnet";
+export declare const OFFICIAL_TOKEN_REGISTRY: Record<TokenNetwork, OfficialTokenEntry[]>;
+export declare function getRegistryForNetwork(network?: string): OfficialTokenEntry[];
+export type TokenSource = "registry" | "cache" | "onchain";
+export interface TokenResolution {
+    type: string;
+    symbol: string;
+    decimals: number;
+    name: string;
+    source: TokenSource;
+    verified: boolean;
+}
+export declare function findInRegistryByType(tokenType: string, network?: string): OfficialTokenEntry | undefined;
+export declare function findInRegistryBySymbol(symbol: string, network?: string): OfficialTokenEntry[];
+export declare function resolveTokenByType(tokenType: string, network?: ENTRYPOINT): Promise<TokenResolution | undefined>;
+export declare function resolveTokensBySymbol(symbol: string, network?: ENTRYPOINT, preferredType?: string): Promise<TokenResolution[]>;
+export interface ParsedAmount {
+    smallestUnit: bigint;
+    displayAmount: string;
+    originalInput: string | number;
+    tokenType: string;
+    tokenSymbol: string;
+    decimals: number;
+    converted: boolean;
+    source: TokenSource;
+    verified: boolean;
+}
+export declare function isAmountWithSymbol(value: unknown): boolean;
+export declare function parseAmount(amount: string | number, tokenType: string, network?: ENTRYPOINT): Promise<ParsedAmount>;
+export declare function smallestToDisplay(value: bigint, decimals: number): string;
+export interface FundFieldConfirmation {
+    path: string;
+    displayAmount: string;
+    tokenType: string;
+    tokenSymbol: string;
+    verified: boolean;
+    source: TokenSource;
+    converted: boolean;
+    context: string;
+}
+export interface TokenAmbiguity {
+    symbol: string;
+    candidates: {
+        type: string;
+        decimals: number;
+        source: TokenSource;
+        verified: boolean;
+    }[];
+}
+export interface FundConfirmationRequest {
+    requiresConfirmation: boolean;
+    reason: string;
+    fields: FundFieldConfirmation[];
+    ambiguities: TokenAmbiguity[];
+    message: string;
+}
+export declare function generateFundConfirmation(fields: FundFieldConfirmation[], ambiguities?: TokenAmbiguity[]): FundConfirmationRequest;
+export interface FundProcessResult {
+    convertedData: any;
+    warnings: string[];
+    confirmation: FundConfirmationRequest | null;
+}
+export declare function processFundOperation(data: any, operationType: string, network?: ENTRYPOINT): Promise<FundProcessResult>;
+export declare function generateSkillsHint(confirmation: FundConfirmationRequest | null): string | null;

package/dist/knowledge/fund-layer.js

@@ -0,0 +1,420 @@
+import { GasTokenType } from "@wowok/wowok";
+const GAS_TOKENS = [
+    {
+        type: "0x2::wow::WOW",
+        symbol: "WOW",
+        decimals: 9,
+        name: "Wowok Token",
+        description: "Default platform gas token for all WoWok operations. 1 WOW = 10^9 MIST. Available on testnet and mainnet.",
+    },
+];
+const TESTNET_TOKENS = [];
+function buildMainnetTokensFromSDK() {
+    try {
+        const { MAINNET_BRIDGE_CONFIG } = require("@wowok/wowok");
+        if (!MAINNET_BRIDGE_CONFIG?.tokens)
+            return [];
+        const seen = new Set();
+        return MAINNET_BRIDGE_CONFIG.tokens
+            .filter((t) => {
+            if (seen.has(t.wowTypeTag))
+                return false;
+            seen.add(t.wowTypeTag);
+            return true;
+        })
+            .map((t) => ({
+            type: t.wowTypeTag,
+            symbol: t.symbol,
+            decimals: t.wowDecimals,
+            name: `${t.symbol} (Bridge)`,
+            description: t.description ?? `Bridge token on WOW mainnet. ${t.wowDecimals} decimals.`,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+export const OFFICIAL_TOKEN_REGISTRY = {
+    gas: GAS_TOKENS,
+    testnet: TESTNET_TOKENS,
+    mainnet: buildMainnetTokensFromSDK(),
+};
+export function getRegistryForNetwork(network) {
+    return [
+        ...OFFICIAL_TOKEN_REGISTRY.gas,
+        ...(network === "testnet" ? OFFICIAL_TOKEN_REGISTRY.testnet : []),
+        ...(network === "mainnet" ? OFFICIAL_TOKEN_REGISTRY.mainnet : []),
+    ];
+}
+export function findInRegistryByType(tokenType, network) {
+    const gasMatch = OFFICIAL_TOKEN_REGISTRY.gas.find((t) => t.type === tokenType);
+    if (gasMatch)
+        return gasMatch;
+    const netTokens = getRegistryForNetwork(network);
+    return netTokens.find((t) => t.type === tokenType);
+}
+export function findInRegistryBySymbol(symbol, network) {
+    const lower = symbol.toLowerCase();
+    const gasMatches = OFFICIAL_TOKEN_REGISTRY.gas.filter((t) => t.symbol.toLowerCase() === lower);
+    const netTokens = getRegistryForNetwork(network);
+    const netMatches = netTokens.filter((t) => t.symbol.toLowerCase() === lower && !gasMatches.some((g) => g.type === t.type));
+    return [...gasMatches, ...netMatches];
+}
+export async function resolveTokenByType(tokenType, network) {
+    const registryEntry = findInRegistryByType(tokenType, network);
+    if (registryEntry) {
+        return {
+            type: registryEntry.type,
+            symbol: registryEntry.symbol,
+            decimals: registryEntry.decimals,
+            name: registryEntry.name,
+            source: "registry",
+            verified: true,
+        };
+    }
+    try {
+        const { TokenInfo } = await import("@wowok/wowok");
+        const tokenInfo = TokenInfo.Instance();
+        const fetched = await tokenInfo.fetch(tokenType, undefined, network);
+        if (fetched) {
+            return {
+                type: fetched.type,
+                symbol: fetched.symbol ?? "",
+                decimals: fetched.decimals ?? 0,
+                name: fetched.name ?? "",
+                source: "cache",
+                verified: false,
+            };
+        }
+    }
+    catch {
+    }
+    return undefined;
+}
+export async function resolveTokensBySymbol(symbol, network, preferredType) {
+    const results = [];
+    const registryMatches = findInRegistryBySymbol(symbol, network);
+    for (const entry of registryMatches) {
+        results.push({
+            type: entry.type,
+            symbol: entry.symbol,
+            decimals: entry.decimals,
+            name: entry.name,
+            source: "registry",
+            verified: true,
+        });
+    }
+    try {
+        const { query_local_token_list } = await import("@wowok/wowok");
+        const cached = await query_local_token_list({ symbol });
+        for (const token of cached) {
+            if (results.some((r) => r.type === token.type))
+                continue;
+            results.push({
+                type: token.type,
+                symbol: token.symbol ?? "",
+                decimals: token.decimals ?? 0,
+                name: token.name ?? "",
+                source: "cache",
+                verified: false,
+            });
+        }
+    }
+    catch {
+    }
+    if (preferredType) {
+        results.sort((a, b) => {
+            if (a.type === preferredType)
+                return -1;
+            if (b.type === preferredType)
+                return 1;
+            if (a.verified && !b.verified)
+                return -1;
+            if (!a.verified && b.verified)
+                return 1;
+            return 0;
+        });
+    }
+    return results;
+}
+const AMOUNT_WITH_SYMBOL = /^(\d+(?:\.\d+)?)\s*([A-Za-z][A-Za-z0-9]*)$/;
+export function isAmountWithSymbol(value) {
+    if (typeof value !== "string")
+        return false;
+    const match = value.match(AMOUNT_WITH_SYMBOL);
+    if (!match)
+        return false;
+    const symbol = match[2];
+    return symbol.length >= 2 && symbol.length <= 10;
+}
+export async function parseAmount(amount, tokenType, network) {
+    const originalInput = amount;
+    const resolution = await resolveTokenByType(tokenType, network);
+    const decimals = resolution?.decimals ?? 9;
+    const symbol = resolution?.symbol ?? "";
+    const source = resolution?.source ?? "registry";
+    const verified = resolution?.verified ?? false;
+    if (typeof amount === "string") {
+        const match = amount.match(AMOUNT_WITH_SYMBOL);
+        if (match) {
+            const numericPart = parseFloat(match[1]);
+            const symbolPart = match[2];
+            if (symbol && symbolPart.toLowerCase() !== symbol.toLowerCase()) {
+                throw new Error(`Amount symbol "${symbolPart}" does not match the expected token symbol "${symbol}" ` +
+                    `(type: ${tokenType}). Either use the correct symbol or pass a pure numeric value ` +
+                    `in smallest units (e.g., ${(numericPart * Math.pow(10, decimals)).toFixed(0)}).`);
+            }
+            const smallestUnit = displayToSmallestUnit(numericPart, decimals);
+            return {
+                smallestUnit,
+                displayAmount: `${numericPart} ${symbolPart}`,
+                originalInput,
+                tokenType,
+                tokenSymbol: symbol || symbolPart,
+                decimals,
+                converted: true,
+                source,
+                verified,
+            };
+        }
+    }
+    let smallestUnit;
+    try {
+        smallestUnit = BigInt(amount);
+    }
+    catch {
+        throw new Error(`Invalid amount: "${amount}". Expected a number, a numeric string (smallest unit), ` +
+            `or a display-format string like "2.5WOW" (matching the token's symbol).`);
+    }
+    const displayValue = smallestToDisplay(smallestUnit, decimals);
+    return {
+        smallestUnit,
+        displayAmount: symbol ? `${displayValue} ${symbol}` : displayValue,
+        originalInput,
+        tokenType,
+        tokenSymbol: symbol,
+        decimals,
+        converted: false,
+        source,
+        verified,
+    };
+}
+function displayToSmallestUnit(display, decimals) {
+    const str = display.toString();
+    const [wholePart, fracPart = ""] = str.split(".");
+    const paddedFrac = fracPart.padEnd(decimals, "0").slice(0, decimals);
+    const combined = wholePart + paddedFrac;
+    return BigInt(combined || "0");
+}
+export function smallestToDisplay(value, decimals) {
+    const divisor = BigInt(10) ** BigInt(decimals);
+    const whole = value / divisor;
+    const frac = value % divisor;
+    if (frac === 0n)
+        return whole.toString();
+    const fracStr = frac.toString().padStart(decimals, "0").replace(/0+$/, "");
+    return `${whole.toString()}.${fracStr}`;
+}
+export function generateFundConfirmation(fields, ambiguities = []) {
+    const hasAmbiguity = ambiguities.length > 0;
+    const parts = [
+        "MONEY TRANSACTION CONFIRMATION REQUIRED",
+        "",
+    ];
+    for (const field of fields) {
+        const verifiedTag = field.verified ? " [VERIFIED]" : " [UNVERIFIED]";
+        const sourceTag = ` (source: ${field.source})`;
+        parts.push(`  • ${field.context}: ${field.displayAmount}${verifiedTag}${sourceTag}`);
+        if (field.converted) {
+            parts.push(`    (converted from display format to smallest unit)`);
+        }
+    }
+    if (hasAmbiguity) {
+        parts.push("", "AMBIGUITY WARNING — multiple tokens share the same symbol:");
+        for (const amb of ambiguities) {
+            parts.push(`  Symbol "${amb.symbol}" matches:`);
+            for (const c of amb.candidates) {
+                const vTag = c.verified ? " [VERIFIED]" : " [UNVERIFIED]";
+                parts.push(`    - type: ${c.type}, decimals: ${c.decimals}${vTag} (source: ${c.source})`);
+            }
+            parts.push(`    → Specify the full type string in type_parameter to disambiguate.`);
+        }
+    }
+    parts.push("", "This operation involves money. Please confirm before proceeding.");
+    return {
+        requiresConfirmation: true,
+        reason: hasAmbiguity
+            ? "Money transaction with ambiguous token symbol — user must specify full type"
+            : "Money transaction requires user confirmation",
+        fields,
+        ambiguities,
+        message: parts.join("\n"),
+    };
+}
+function extractTokenType(data, operationType) {
+    if (data?.object && typeof data.object === "object" && data.object.type_parameter) {
+        return data.object.type_parameter;
+    }
+    if (operationType === "payment" && data?.type_parameter) {
+        return data.type_parameter;
+    }
+    return GasTokenType;
+}
+const MONETARY_FIELDS = {
+    service: [
+        { path: "sales.sales", context: "Service sale price", isArray: true, amountField: "price" },
+        { path: "compensation_fund_add.balance", context: "Service compensation fund deposit" },
+        { path: "order_new.buy.total_pay.balance", context: "Order payment amount" },
+        { path: "discount.discount_value", context: "Discount value" },
+    ],
+    arbitration: [
+        { path: "dispute.fee.balance", context: "Arbitration dispute fee" },
+        { path: "fee", context: "Arbitration fee" },
+    ],
+    reward: [
+        { path: "coin_add.balance", context: "Reward coin add" },
+    ],
+    treasury: [
+        { path: "deposit.coin.balance", context: "Treasury deposit amount" },
+        { path: "withdraw.amount.fixed", context: "Treasury withdrawal amount" },
+    ],
+    payment: [
+        { path: "revenue", context: "Payment amount", isArray: true, amountField: "amount.balance" },
+    ],
+};
+function getNestedValue(obj, path) {
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+        if (current == null)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+export async function processFundOperation(data, operationType, network) {
+    const result = {
+        convertedData: data,
+        warnings: [],
+        confirmation: null,
+    };
+    const fields = MONETARY_FIELDS[operationType];
+    if (!fields) {
+        return result;
+    }
+    const tokenType = extractTokenType(data, operationType);
+    const confirmationFields = [];
+    const ambiguities = [];
+    const seenSymbols = new Map();
+    for (const fieldDesc of fields) {
+        const isArr = fieldDesc.isArray === true;
+        const amountField = fieldDesc.amountField;
+        if (isArr && amountField) {
+            const arr = getNestedValue(data, fieldDesc.path);
+            if (Array.isArray(arr)) {
+                for (let i = 0; i < arr.length; i++) {
+                    const item = arr[i];
+                    const parts = amountField.split(".");
+                    let parentObj = item;
+                    for (let j = 0; j < parts.length - 1; j++) {
+                        parentObj = parentObj?.[parts[j]];
+                        if (parentObj == null)
+                            break;
+                    }
+                    const finalKey = parts[parts.length - 1];
+                    if (parentObj && parentObj[finalKey] != null) {
+                        const path = `${fieldDesc.path}[${i}].${amountField}`;
+                        await processSingleField(parentObj, finalKey, path, fieldDesc.context, tokenType, network, result, confirmationFields, ambiguities, seenSymbols);
+                    }
+                }
+            }
+        }
+        else {
+            const lastDot = fieldDesc.path.lastIndexOf(".");
+            const parentPath = lastDot >= 0 ? fieldDesc.path.slice(0, lastDot) : "";
+            const finalKey = lastDot >= 0 ? fieldDesc.path.slice(lastDot + 1) : fieldDesc.path;
+            const parentObj = parentPath ? getNestedValue(data, parentPath) : data;
+            if (parentObj && parentObj[finalKey] != null) {
+                await processSingleField(parentObj, finalKey, fieldDesc.path, fieldDesc.context, tokenType, network, result, confirmationFields, ambiguities, seenSymbols);
+            }
+        }
+    }
+    if (confirmationFields.length > 0) {
+        result.confirmation = generateFundConfirmation(confirmationFields, ambiguities);
+        const totalAmounts = confirmationFields.length;
+        const hasUnverified = confirmationFields.some((f) => !f.verified);
+        const hasAmbiguity = ambiguities.length > 0;
+        if (hasAmbiguity) {
+            result.warnings.push(`AMBIGUOUS TOKEN: ${ambiguities.length} token symbol(s) have multiple candidates. ` +
+                `User must specify full type string in type_parameter to disambiguate. ` +
+                `See confirmation message for details.`);
+        }
+        if (hasUnverified) {
+            result.warnings.push(`UNVERIFIED TOKEN: some monetary fields use tokens not in the official registry. ` +
+                `Precision was resolved from cache/on-chain. Verify the token type before proceeding.`);
+        }
+        result.warnings.push(`MONEY CONFIRMATION: ${totalAmounts} monetary field(s) require user confirmation. ` +
+            `Token type: ${tokenType}. Use env.confirmed=true after user consent.`);
+    }
+    return result;
+}
+async function processSingleField(parentObj, fieldKey, fieldPath, context, tokenType, network, result, confirmationFields, ambiguities, seenSymbols) {
+    const value = parentObj[fieldKey];
+    if (value == null)
+        return;
+    try {
+        const parsed = await parseAmount(value, tokenType, network);
+        if (parsed.converted) {
+            parentObj[fieldKey] = parsed.smallestUnit.toString();
+        }
+        confirmationFields.push({
+            path: fieldPath,
+            displayAmount: parsed.displayAmount,
+            tokenType: parsed.tokenType,
+            tokenSymbol: parsed.tokenSymbol,
+            verified: parsed.verified,
+            source: parsed.source,
+            converted: parsed.converted,
+            context,
+        });
+        if (parsed.tokenSymbol && parsed.source !== "registry") {
+            const symbolKey = parsed.tokenSymbol.toLowerCase();
+            let candidates = seenSymbols.get(symbolKey);
+            if (!candidates) {
+                const allMatches = await resolveTokensBySymbol(parsed.tokenSymbol, network, tokenType);
+                if (allMatches.length > 1) {
+                    candidates = allMatches;
+                    seenSymbols.set(symbolKey, candidates);
+                    ambiguities.push({
+                        symbol: parsed.tokenSymbol,
+                        candidates: candidates.map((c) => ({
+                            type: c.type,
+                            decimals: c.decimals,
+                            source: c.source,
+                            verified: c.verified,
+                        })),
+                    });
+                }
+            }
+        }
+    }
+    catch (err) {
+        result.warnings.push(`FUND LAYER ERROR at ${fieldPath}: ${err.message}`);
+    }
+}
+export function generateSkillsHint(confirmation) {
+    if (!confirmation || !confirmation.requiresConfirmation)
+        return null;
+    const hasAmbiguity = confirmation.ambiguities.length > 0;
+    if (hasAmbiguity) {
+        return ("SKILLS HINT: This money transaction has ambiguous token symbols. " +
+            "If the wowok-safety skill is installed, it can guide the user through " +
+            "interactive disambiguation. Otherwise, the MCP fund layer has already " +
+            "listed all candidates in the confirmation message — ask the user to " +
+            "specify the full token type string in type_parameter.");
+    }
+    return ("SKILLS HINT: This money transaction requires user confirmation. " +
+        "If the wowok-safety skill is installed, it provides R1-R10 confirmation " +
+        "dialogue scripts. Otherwise, present the confirmation message to the user " +
+        "and proceed only after explicit consent (env.confirmed=true).");
+}

package/dist/knowledge/guard-render.d.ts

@@ -0,0 +1,57 @@
+export interface GuardNodeForRender {
+    type: string;
+    nodes?: GuardNodeForRender[];
+    node?: GuardNodeForRender;
+    nodeLeft?: GuardNodeForRender;
+    nodeRight?: GuardNodeForRender;
+    query?: number | string;
+    object?: {
+        identifier?: number;
+        convert_witness?: number;
+    };
+    parameters?: GuardNodeForRender[];
+    identifier?: number;
+    context?: string;
+    historyIdx?: GuardNodeForRender;
+    sessionIdx?: GuardNodeForRender;
+    forwardIdx?: GuardNodeForRender;
+    where?: GuardNodeForRender;
+    find?: GuardNodeForRender;
+    objectLeft?: GuardNodeForRender;
+    objectRight?: GuardNodeForRender;
+    recipient?: GuardNodeForRender;
+}
+export interface GuardRenderInput {
+    root: GuardNodeForRender;
+    table?: Array<{
+        identifier: number;
+        name?: string;
+        value_type: string | number;
+        b_submission: boolean;
+        value?: unknown;
+    }>;
+    guardName?: string | null;
+    guardAddress?: string | null;
+    rely?: {
+        guards: string[];
+        logic_or?: boolean;
+    } | null;
+}
+export declare function renderGuardMermaid(root: GuardNodeForRender, options?: {
+    colored?: boolean;
+}): string;
+export declare function renderGuardTreeIndented(input: GuardRenderInput): string;
+export declare function parseGuardTreeIndented(text: string): {
+    success: boolean;
+    data?: GuardNodeForRender;
+    errors: string[];
+};
+export declare function renderGuardAscii(input: GuardRenderInput): string;
+export declare function renderGuardMarkmap(input: GuardRenderInput): string;
+export declare function parseGuardTableJSON(text: string): Array<{
+    identifier: number;
+    name?: string;
+    value_type: string | number;
+    b_submission: boolean;
+    value?: unknown;
+}> | null;