@nestpilot/mcp-app 1.0.0

package/dist/src/rate-limit.js

@@ -0,0 +1,41 @@
+/**
+ * In-memory rate limiter — sliding window per key.
+ * Adapted from mcp-edge.
+ */
+export class InMemoryRateLimiter {
+    windowMs;
+    maxRequests;
+    buckets = new Map();
+    constructor(windowMs, maxRequests) {
+        this.windowMs = windowMs;
+        this.maxRequests = maxRequests;
+    }
+    check(key, nowMs = Date.now()) {
+        const existing = this.buckets.get(key);
+        if (!existing || nowMs - existing.windowStartMs >= this.windowMs) {
+            this.buckets.set(key, { count: 1, windowStartMs: nowMs });
+            return {
+                allowed: true,
+                remaining: this.maxRequests - 1,
+                resetAtMs: nowMs + this.windowMs,
+                retryAfterSeconds: 0,
+            };
+        }
+        if (existing.count >= this.maxRequests) {
+            const resetAtMs = existing.windowStartMs + this.windowMs;
+            return {
+                allowed: false,
+                remaining: 0,
+                resetAtMs,
+                retryAfterSeconds: Math.max(1, Math.ceil((resetAtMs - nowMs) / 1000)),
+            };
+        }
+        existing.count += 1;
+        return {
+            allowed: true,
+            remaining: Math.max(0, this.maxRequests - existing.count),
+            resetAtMs: existing.windowStartMs + this.windowMs,
+            retryAfterSeconds: 0,
+        };
+    }
+}

package/dist/src/security.d.ts

@@ -0,0 +1,19 @@
+import type { IncomingHttpHeaders } from "node:http";
+import type { AppConfig } from "./config.js";
+export type AuthResult = {
+    ok: true;
+    userId: string;
+    tokenHash?: string;
+    bearerToken?: string;
+} | {
+    ok: false;
+    statusCode: number;
+    message: string;
+};
+/**
+ * Decodes the `sub` claim from a JWT payload without validating the signature.
+ * The backend is the authoritative JWT validator - this is only used for
+ * logging and rate-limiting context.
+ */
+export declare function decodeJwtSub(token: string): string | undefined;
+export declare function authenticateRequest(headers: IncomingHttpHeaders, config: AppConfig): AuthResult;

package/dist/src/security.js

@@ -0,0 +1,118 @@
+/**
+ * Request authentication - adapted from mcp-edge.
+ *
+ * Supports three modes:
+ *   - "token" (default): Opaque bearer tokens validated against MCP_AUTH_TOKENS
+ *   - "jwt-passthrough": Bearer JWT forwarded to backend as-is; sub claim
+ *     decoded locally for logging/rate-limiting only
+ *   - No auth required: Falls back to X-User-ID header or default user
+ */
+import { createHash } from "node:crypto";
+function readHeader(headers, name) {
+    const raw = headers[name];
+    return Array.isArray(raw) ? raw[0] : raw;
+}
+function hashToken(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+/**
+ * Decodes the `sub` claim from a JWT payload without validating the signature.
+ * The backend is the authoritative JWT validator - this is only used for
+ * logging and rate-limiting context.
+ */
+export function decodeJwtSub(token) {
+    try {
+        const parts = token.split(".");
+        if (parts.length !== 3)
+            return undefined;
+        // JWT payload is base64url-encoded; convert to standard base64
+        const base64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+        const json = Buffer.from(base64, "base64").toString("utf-8");
+        const payload = JSON.parse(json);
+        return typeof payload.sub === "string" ? payload.sub : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function authenticateRequest(headers, config) {
+    const userHeader = readHeader(headers, "x-user-id")?.trim();
+    const authHeader = readHeader(headers, "authorization");
+    // JWT passthrough mode
+    if (config.authMode === "jwt-passthrough") {
+        if (!authHeader || !authHeader.toLowerCase().startsWith("bearer ")) {
+            if (config.requireAuth) {
+                return {
+                    ok: false,
+                    statusCode: 401,
+                    message: "Missing bearer token. Provide Authorization: Bearer <jwt>.",
+                };
+            }
+            return {
+                ok: true,
+                userId: userHeader && userHeader.length > 0
+                    ? userHeader
+                    : config.defaultUserId,
+            };
+        }
+        const token = authHeader.slice("Bearer ".length).trim();
+        if (!token) {
+            if (config.requireAuth) {
+                return { ok: false, statusCode: 401, message: "Bearer token is empty." };
+            }
+            return {
+                ok: true,
+                userId: userHeader && userHeader.length > 0
+                    ? userHeader
+                    : config.defaultUserId,
+            };
+        }
+        // Decode sub claim for logging/rate-limiting; backend validates the JWT
+        const sub = decodeJwtSub(token);
+        return {
+            ok: true,
+            userId: sub ?? userHeader ?? config.defaultUserId,
+            bearerToken: token,
+        };
+    }
+    // Opaque token mode
+    const authRequired = config.requireAuth || config.authTokens.size > 0;
+    if (!authRequired) {
+        return {
+            ok: true,
+            userId: userHeader && userHeader.length > 0
+                ? userHeader
+                : config.defaultUserId,
+        };
+    }
+    if (!authHeader || !authHeader.toLowerCase().startsWith("bearer ")) {
+        return {
+            ok: false,
+            statusCode: 401,
+            message: "Missing bearer token. Provide Authorization: Bearer <token>.",
+        };
+    }
+    const token = authHeader.slice("Bearer ".length).trim();
+    if (!token) {
+        return { ok: false, statusCode: 401, message: "Bearer token is empty." };
+    }
+    if (config.authTokens.size === 0) {
+        return {
+            ok: false,
+            statusCode: 500,
+            message: "MCP auth is enabled but MCP_AUTH_TOKENS is not configured.",
+        };
+    }
+    if (!config.authTokens.has(token)) {
+        return { ok: false, statusCode: 401, message: "Invalid bearer token." };
+    }
+    const tokenHash = hashToken(token).slice(0, 16);
+    return {
+        ok: true,
+        userId: userHeader && userHeader.length > 0
+            ? userHeader
+            : `token:${tokenHash}`,
+        tokenHash,
+        bearerToken: token,
+    };
+}

package/dist/src/skills/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Skill Pack v1 — FEAT-0057
+ *
+ * Public API surface for the Retirement Skill Pack v1.
+ *
+ * @feature FEAT-0057
+ * @design DES-0055
+ */
+export { SkillManifestV1Schema, validateManifest, requireValidManifest, type SkillManifestV1, type SkillConstraint, type RequiredTool, type SkillIOField, type SkillIO, type SkillExample, type ManifestValidation, type ManifestValidationResult, type ManifestValidationError, } from "./skill-manifest-schema.js";
+export { registerSkill, lookupSkill, getAllSkills, checkCompatibility, requireCompatibility, semverSatisfies, _resetSkillRegistry, type SkillLookup, type SkillLookupResult, type SkillLookupMiss, type CompatibilityCheck, type CompatibilityCheckResult, type CompatibilityCheckFailure, type CompatibilityToolFailure, } from "./skill-registry.js";
+export { executeSkill, validateIO, _resetRunCounter, type ExecutionRecord, type ExecutionContext, type ExecutionStatus, type StepTrace, type IOValidation, type IOValidationResult, type IOValidationError, } from "./skill-executor.js";
+export { loadPlanContext, createScenarioFromTemplate, draftProposalFromScenario, validateProposalAgainstPolicy, generateAdvisorSummary, RETIREMENT_PACK_V1, RETIREMENT_PACK_VERSION, RETIREMENT_PACK_NAME, } from "./retirement-pack-v1.js";

package/dist/src/skills/index.js

@@ -0,0 +1,16 @@
+/**
+ * Skill Pack v1 — FEAT-0057
+ *
+ * Public API surface for the Retirement Skill Pack v1.
+ *
+ * @feature FEAT-0057
+ * @design DES-0055
+ */
+// Schema and validation
+export { SkillManifestV1Schema, validateManifest, requireValidManifest, } from "./skill-manifest-schema.js";
+// Registry
+export { registerSkill, lookupSkill, getAllSkills, checkCompatibility, requireCompatibility, semverSatisfies, _resetSkillRegistry, } from "./skill-registry.js";
+// Executor
+export { executeSkill, validateIO, _resetRunCounter, } from "./skill-executor.js";
+// Retirement Pack v1 manifests
+export { loadPlanContext, createScenarioFromTemplate, draftProposalFromScenario, validateProposalAgainstPolicy, generateAdvisorSummary, RETIREMENT_PACK_V1, RETIREMENT_PACK_VERSION, RETIREMENT_PACK_NAME, } from "./retirement-pack-v1.js";

package/dist/src/skills/retirement-pack-v1.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Retirement Skill Pack v1 — FEAT-0057
+ *
+ * Five core retirement workflow skill manifests in v1 format.
+ * Each manifest declares typed I/O contracts, safety constraints,
+ * required tool dependencies with minimum contract versions,
+ * and example input/output pairs.
+ *
+ * Skills:
+ *   1. load-plan-context
+ *   2. create-scenario-from-template
+ *   3. draft-proposal-from-scenario
+ *   4. validate-proposal-against-policy
+ *   5. generate-advisor-summary
+ *
+ * @feature FEAT-0057
+ * @design DES-0055
+ */
+import type { SkillManifestV1 } from "./skill-manifest-schema.js";
+export declare const loadPlanContext: SkillManifestV1;
+export declare const createScenarioFromTemplate: SkillManifestV1;
+export declare const draftProposalFromScenario: SkillManifestV1;
+export declare const validateProposalAgainstPolicy: SkillManifestV1;
+export declare const generateAdvisorSummary: SkillManifestV1;
+/** All five core retirement skills in v1 format. */
+export declare const RETIREMENT_PACK_V1: ReadonlyArray<SkillManifestV1>;
+export declare const RETIREMENT_PACK_VERSION = "1.0.0";
+export declare const RETIREMENT_PACK_NAME = "retirement-v1";

package/dist/src/skills/retirement-pack-v1.js

@@ -0,0 +1,295 @@
+// ── 1. Load Plan Context ────────────────────────────────────────────────
+export const loadPlanContext = {
+    skillId: "load-plan-context",
+    version: "1.0.0",
+    displayName: "Load Plan Context",
+    description: "Loads and validates a retirement plan context from user inputs, producing a normalized plan object for downstream skills.",
+    pack: "retirement-v1",
+    requiredTools: [
+        { toolName: "create_plan", minContractVersion: "1.0.0" },
+    ],
+    inputSchema: {
+        fields: [
+            { name: "currentAge", type: "number", required: true, description: "Current age of the plan holder" },
+            { name: "retireAge", type: "number", required: true, description: "Target retirement age" },
+            { name: "currentBalance", type: "number", required: true, description: "Current portfolio balance in USD" },
+            { name: "monthlyContribution", type: "number", required: true, description: "Monthly contribution in USD" },
+            { name: "expectedReturnRate", type: "number", required: true, description: "Expected annual return rate (decimal)" },
+            { name: "withdrawalRate", type: "number", required: false, description: "Annual withdrawal rate in retirement (decimal)" },
+        ],
+    },
+    outputSchema: {
+        fields: [
+            { name: "projectedBalanceAtRetirement", type: "number", required: true, description: "Projected balance at retirement age" },
+            { name: "readinessScore", type: "number", required: true, description: "Retirement readiness score (0-100)" },
+            { name: "yearsToRetirement", type: "number", required: true, description: "Years until target retirement age" },
+        ],
+    },
+    constraints: [
+        { description: "Must not recommend specific investment products", enforced: true },
+        { description: "All assumptions must be surfaced in output", enforced: true },
+        { description: "Return rate must be user-provided, not predicted", enforced: true },
+    ],
+    nonPermittedActions: [
+        "Recommend specific funds or advisors",
+        "Modify user account data",
+        "Execute financial transactions",
+    ],
+    sensitiveDataRequirements: [
+        "Financial balance information",
+        "Age and retirement timeline",
+    ],
+    examples: [
+        {
+            description: "Basic plan context for a 40-year-old",
+            input: {
+                currentAge: 40,
+                retireAge: 65,
+                currentBalance: 250000,
+                monthlyContribution: 2000,
+                expectedReturnRate: 0.07,
+            },
+            expectedOutput: {
+                projectedBalanceAtRetirement: 1200000,
+                readinessScore: 82,
+                yearsToRetirement: 25,
+            },
+        },
+    ],
+};
+// ── 2. Create Scenario from Template ────────────────────────────────────
+export const createScenarioFromTemplate = {
+    skillId: "create-scenario-from-template",
+    version: "1.0.0",
+    displayName: "Create Scenario from Template",
+    description: "Creates a what-if retirement scenario from a predefined template, comparing against a base plan to surface deltas and trade-offs.",
+    pack: "retirement-v1",
+    requiredTools: [
+        { toolName: "create_plan", minContractVersion: "1.0.0" },
+        { toolName: "run_scenario", minContractVersion: "1.0.0" },
+    ],
+    inputSchema: {
+        fields: [
+            { name: "basePlan", type: "object", required: true, description: "Base retirement plan context" },
+            { name: "scenarioType", type: "string", required: true, description: "Template type: early-retirement, market-downturn, delayed-ss, roth-conversion" },
+            { name: "adjustments", type: "object", required: false, description: "Override parameters for the scenario" },
+        ],
+    },
+    outputSchema: {
+        fields: [
+            { name: "scenarioResult", type: "object", required: true, description: "Full scenario projection result" },
+            { name: "deltaVsBase", type: "object", required: true, description: "Differences compared to the base plan" },
+            { name: "tradeOffs", type: "array", required: true, description: "List of identified trade-offs" },
+        ],
+    },
+    constraints: [
+        { description: "Scenarios are exploration, not recommendations", enforced: true },
+        { description: "Must always present delta vs. base case", enforced: true },
+        { description: "Frame as 'if X then Y', never 'you should do X'", enforced: true },
+    ],
+    nonPermittedActions: [
+        "Present scenarios as advice or recommendations",
+        "Hide assumptions behind scenario adjustments",
+        "Execute trades or account changes",
+    ],
+    sensitiveDataRequirements: [
+        "Full retirement plan context",
+        "Portfolio balance details",
+    ],
+    examples: [
+        {
+            description: "Early retirement scenario — retire at 60 instead of 65",
+            input: {
+                basePlan: { currentAge: 40, retireAge: 65, currentBalance: 250000 },
+                scenarioType: "early-retirement",
+                adjustments: { retireAge: 60 },
+            },
+            expectedOutput: {
+                scenarioResult: { projectedBalance: 850000 },
+                deltaVsBase: { balanceDelta: -350000, yearsDelta: -5 },
+                tradeOffs: ["Lower balance at retirement", "More years in retirement"],
+            },
+        },
+    ],
+};
+// ── 3. Draft Proposal from Scenario ─────────────────────────────────────
+export const draftProposalFromScenario = {
+    skillId: "draft-proposal-from-scenario",
+    version: "1.0.0",
+    displayName: "Draft Proposal from Scenario",
+    description: "Generates a structured retirement proposal document from a completed scenario, suitable for advisor review or client presentation.",
+    pack: "retirement-v1",
+    requiredTools: [
+        { toolName: "run_scenario", minContractVersion: "1.0.0" },
+        { toolName: "run_forecast", minContractVersion: "1.0.0" },
+    ],
+    inputSchema: {
+        fields: [
+            { name: "scenarioResult", type: "object", required: true, description: "Completed scenario projection result" },
+            { name: "clientName", type: "string", required: true, description: "Client display name for the proposal" },
+            { name: "includeCharts", type: "boolean", required: false, description: "Whether to include chart data in output" },
+        ],
+    },
+    outputSchema: {
+        fields: [
+            { name: "proposalTitle", type: "string", required: true, description: "Generated proposal title" },
+            { name: "sections", type: "array", required: true, description: "Ordered list of proposal sections" },
+            { name: "assumptions", type: "array", required: true, description: "All assumptions used in the proposal" },
+            { name: "forecastSummary", type: "object", required: true, description: "Condensed forecast data for the proposal" },
+        ],
+    },
+    constraints: [
+        { description: "Proposals must disclose all assumptions", enforced: true },
+        { description: "Must not include product recommendations", enforced: true },
+        { description: "All numbers must be traceable to forecast output", enforced: true },
+    ],
+    nonPermittedActions: [
+        "Include affiliate links or product pitches",
+        "Omit assumptions from the proposal",
+        "Present projections as guarantees",
+    ],
+    sensitiveDataRequirements: [
+        "Client name",
+        "Full scenario and forecast data",
+    ],
+    examples: [
+        {
+            description: "Proposal draft for a base retirement scenario",
+            input: {
+                scenarioResult: { projectedBalance: 1200000, readinessScore: 82 },
+                clientName: "Jane Doe",
+                includeCharts: true,
+            },
+            expectedOutput: {
+                proposalTitle: "Retirement Proposal — Jane Doe",
+                sections: ["Executive Summary", "Forecast Details", "Assumptions", "Next Steps"],
+                assumptions: ["7% annual return", "3% inflation", "65 retirement age"],
+                forecastSummary: { balanceAtRetirement: 1200000, monthlyIncome: 4800 },
+            },
+        },
+    ],
+};
+// ── 4. Validate Proposal Against Policy ─────────────────────────────────
+export const validateProposalAgainstPolicy = {
+    skillId: "validate-proposal-against-policy",
+    version: "1.0.0",
+    displayName: "Validate Proposal Against Policy",
+    description: "Validates a retirement proposal against platform policies and compliance rules, blocking non-compliant content with explicit reasons.",
+    pack: "retirement-v1",
+    requiredTools: [
+        { toolName: "verify_forecast", minContractVersion: "1.0.0" },
+    ],
+    inputSchema: {
+        fields: [
+            { name: "proposal", type: "object", required: true, description: "The proposal to validate" },
+            { name: "policyRules", type: "array", required: true, description: "List of policy rule IDs to check against" },
+        ],
+    },
+    outputSchema: {
+        fields: [
+            { name: "compliant", type: "boolean", required: true, description: "Whether the proposal passes all policy checks" },
+            { name: "violations", type: "array", required: true, description: "List of policy violations found (empty if compliant)" },
+            { name: "verificationTrace", type: "object", required: true, description: "Detailed verification trace for audit" },
+        ],
+    },
+    constraints: [
+        { description: "Policy violations must block proposal delivery", enforced: true },
+        { description: "Each violation must include a machine-readable reason code", enforced: true },
+        { description: "Verification trace must be included for audit trail", enforced: true },
+    ],
+    nonPermittedActions: [
+        "Skip policy checks for any reason",
+        "Suppress or hide policy violations",
+        "Auto-approve proposals without verification",
+    ],
+    sensitiveDataRequirements: [
+        "Full proposal content",
+        "Policy rule definitions",
+    ],
+    examples: [
+        {
+            description: "Compliant proposal with no violations",
+            input: {
+                proposal: {
+                    proposalTitle: "Retirement Proposal — Jane Doe",
+                    assumptions: ["7% annual return"],
+                },
+                policyRules: ["no-product-recs", "assumptions-disclosed"],
+            },
+            expectedOutput: {
+                compliant: true,
+                violations: [],
+                verificationTrace: { checkedRules: 2, passedRules: 2 },
+            },
+        },
+    ],
+};
+// ── 5. Generate Advisor Summary ─────────────────────────────────────────
+export const generateAdvisorSummary = {
+    skillId: "generate-advisor-summary",
+    version: "1.0.0",
+    displayName: "Generate Advisor Summary",
+    description: "Generates a concise advisor-facing summary from a validated proposal and forecast, highlighting key metrics, risks, and recommended discussion points.",
+    pack: "retirement-v1",
+    requiredTools: [
+        { toolName: "run_forecast", minContractVersion: "1.0.0" },
+        { toolName: "coach", minContractVersion: "1.0.0" },
+    ],
+    inputSchema: {
+        fields: [
+            { name: "proposal", type: "object", required: true, description: "Validated retirement proposal" },
+            { name: "forecastData", type: "object", required: true, description: "Full forecast projection data" },
+            { name: "clientProfile", type: "object", required: true, description: "Client demographic and risk profile" },
+        ],
+    },
+    outputSchema: {
+        fields: [
+            { name: "summaryTitle", type: "string", required: true, description: "Summary document title" },
+            { name: "keyMetrics", type: "object", required: true, description: "Headline metrics for the advisor" },
+            { name: "risks", type: "array", required: true, description: "Identified risks and concerns" },
+            { name: "discussionPoints", type: "array", required: true, description: "Suggested topics for client meeting" },
+        ],
+    },
+    constraints: [
+        { description: "Summary is for advisor use only, not client-facing", enforced: true },
+        { description: "Must include risk factors and longevity assessment", enforced: true },
+        { description: "Discussion points must be actionable, not generic", enforced: true },
+    ],
+    nonPermittedActions: [
+        "Share advisor summary directly with clients",
+        "Include specific product recommendations",
+        "Omit identified risk factors",
+    ],
+    sensitiveDataRequirements: [
+        "Client demographic profile",
+        "Full forecast and proposal data",
+        "Risk assessment details",
+    ],
+    examples: [
+        {
+            description: "Advisor summary for a near-retirement client",
+            input: {
+                proposal: { proposalTitle: "Retirement Proposal — John Smith" },
+                forecastData: { balanceAtRetirement: 1500000, monthlyIncome: 6000 },
+                clientProfile: { age: 62, riskTolerance: "moderate" },
+            },
+            expectedOutput: {
+                summaryTitle: "Advisor Brief — John Smith",
+                keyMetrics: { readinessScore: 88, yearsOfCoverage: 28 },
+                risks: ["Longevity risk beyond age 90", "Healthcare cost inflation"],
+                discussionPoints: ["Roth conversion window before RMDs", "Medicare enrollment timing"],
+            },
+        },
+    ],
+};
+// ── Pack index ──────────────────────────────────────────────────────────
+/** All five core retirement skills in v1 format. */
+export const RETIREMENT_PACK_V1 = [
+    loadPlanContext,
+    createScenarioFromTemplate,
+    draftProposalFromScenario,
+    validateProposalAgainstPolicy,
+    generateAdvisorSummary,
+];
+export const RETIREMENT_PACK_VERSION = "1.0.0";
+export const RETIREMENT_PACK_NAME = "retirement-v1";

package/dist/src/skills/skill-executor.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Skill Executor Adapter — FEAT-0057
+ *
+ * Validates input/output schemas per skill and runs skill steps
+ * through the MCP tool dispatch pipeline. Emits typed output
+ * and execution trace records.
+ *
+ * @feature FEAT-0057
+ * @design DES-0055
+ */
+import type { SkillManifestV1, SkillIO } from "./skill-manifest-schema.js";
+import { type PolicyDecision, type UserRole } from "../policy/policy-engine.js";
+export type ExecutionStatus = "success" | "blocked" | "error";
+export interface StepTrace {
+    toolName: string;
+    status: "executed" | "skipped" | "blocked";
+    durationMs: number;
+    policyDecision?: PolicyDecision;
+}
+export interface ExecutionRecord {
+    runId: string;
+    skillId: string;
+    version: string;
+    status: ExecutionStatus;
+    stepTrace: StepTrace[];
+    policyDecisions: PolicyDecision[];
+    startedAt: string;
+    completedAt: string;
+    output?: Record<string, unknown>;
+    error?: string;
+}
+export interface ExecutionContext {
+    actorId: string;
+    role: UserRole;
+    input: Record<string, unknown>;
+    /** Tool call dispatcher — injected to decouple from transport. */
+    callTool: (toolName: string, args: Record<string, unknown>) => Promise<unknown>;
+}
+export interface IOValidationResult {
+    valid: true;
+}
+export interface IOValidationError {
+    valid: false;
+    errors: string[];
+}
+export type IOValidation = IOValidationResult | IOValidationError;
+/**
+ * Validates a payload against a skill I/O schema definition.
+ * Checks that all required fields are present and have the correct type.
+ */
+export declare function validateIO(payload: Record<string, unknown>, schema: SkillIO, direction: "input" | "output"): IOValidation;
+/**
+ * Executes a skill by:
+ *   1. Running compatibility checks against tool contracts.
+ *   2. Validating input against the skill's input schema.
+ *   3. Evaluating policy for each required tool.
+ *   4. Calling each required tool via the injected dispatcher.
+ *   5. Validating output against the skill's output schema.
+ *   6. Returning an execution record with full trace.
+ */
+export declare function executeSkill(manifest: SkillManifestV1, ctx: ExecutionContext): Promise<ExecutionRecord>;
+/**
+ * Resets the run counter (for testing only).
+ */
+export declare function _resetRunCounter(): void;