@planu/cli 4.13.0 → 5.0.0

package/dist/engine/spec-changelog/core.js

@@ -1,176 +0,0 @@
-// engine/spec-changelog/core.ts — Changelog entry creation and persistence
-import { readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-const CHANGELOG_FILENAME = 'CHANGELOG.md';
-const CHANGELOG_VERSION_COMMENT = '<!-- changelog-version: 1 -->';
-/** Format a single changelog entry as Markdown. */
-export function formatEntry(entry, specId) {
-    const lines = [];
-    lines.push(`## ${entry.timestamp} — ${entry.type}`);
-    lines.push('');
-    lines.push(`**Tool**: ${entry.triggeredBy}`);
-    lines.push(`**Descripcion**: ${entry.description}`);
-    lines.push('');
-    if (entry.before !== undefined && entry.after !== undefined) {
-        if (entry.type === 'status_changed') {
-            lines.push(`**Antes**: ${entry.before.status} | **Despues**: ${entry.after.status}`);
-            lines.push(`**Progreso**: ${entry.before.completedCount}/${entry.before.criteriaCount} → ${entry.after.completedCount}/${entry.after.criteriaCount}`);
-        }
-        else {
-            lines.push(`**Criterios antes**: ${entry.before.criteriaCount} | **Criterios despues**: ${entry.after.criteriaCount}`);
-            if (entry.type === 'progress_updated') {
-                lines.push(`**Progreso**: ${entry.before.completedCount}/${entry.before.criteriaCount} → ${entry.after.completedCount}/${entry.after.criteriaCount}`);
-            }
-        }
-        lines.push('');
-    }
-    if (entry.diff !== undefined) {
-        const { added, removed, modified } = entry.diff;
-        const hasCriteriaChanges = added.length > 0 || removed.length > 0 || modified.length > 0;
-        if (hasCriteriaChanges) {
-            lines.push('### Criterios modificados');
-            for (const item of added) {
-                lines.push(`\u2795 ${item}`);
-            }
-            for (const item of removed) {
-                lines.push(`\u2796 ${item}`);
-            }
-            for (const item of modified) {
-                lines.push(`\u270f\ufe0f ${item.after} (antes: ${item.before})`);
-            }
-            lines.push('');
-        }
-    }
-    lines.push('---');
-    lines.push('');
-    void specId; // referenced in header externally
-    return lines.join('\n');
-}
-/** Build the full CHANGELOG.md header for a spec. */
-function buildHeader(specId, specTitle) {
-    const title = specTitle ? `${specId}: ${specTitle}` : specId;
-    return [CHANGELOG_VERSION_COMMENT, '', `# Changelog — ${title}`, '', ''].join('\n');
-}
-/** Parse the timestamp from the first entry in a CHANGELOG.md content. */
-export function parseFirstEntryTimestamp(content) {
-    // Matches lines like: ## 2026-03-04T14:23:00Z — reconciled
-    const match = /^## (\d{4}-\d{2}-\d{2}T[\d:.]+Z) —/m.exec(content);
-    return match?.[1] ?? null;
-}
-/** Parse changelog entries from a CHANGELOG.md content string. */
-export function parseChangelogEntries(content, specId) {
-    const entries = [];
-    // Split on section headers: ## <timestamp> — <type>
-    const sectionRegex = /^## (\d{4}-\d{2}-\d{2}T[\d:.]+Z) — (\w+)/gm;
-    const matches = [...content.matchAll(sectionRegex)];
-    for (const match of matches) {
-        const timestamp = match[1];
-        const type = match[2];
-        if (timestamp === undefined || type === undefined) {
-            continue;
-        }
-        const sectionStart = match.index;
-        const nextIdx = matches.indexOf(match) + 1;
-        const nextMatch = nextIdx < matches.length ? matches[nextIdx] : undefined;
-        const sectionEnd = nextMatch?.index ?? content.length;
-        const sectionContent = content.slice(sectionStart, sectionEnd);
-        // Extract tool name
-        const toolMatch = /\*\*Tool\*\*: (.+)/.exec(sectionContent);
-        const triggeredBy = toolMatch?.[1]?.trim() ?? 'unknown';
-        // Extract description
-        const descMatch = /\*\*Descripcion\*\*: (.+)/.exec(sectionContent);
-        const description = descMatch?.[1]?.trim() ?? '';
-        entries.push({
-            timestamp,
-            type: type,
-            description,
-            triggeredBy,
-        });
-    }
-    void specId;
-    return entries;
-}
-/** Read the CHANGELOG.md for a spec directory. Returns null if not found. */
-export async function readChangelog(options) {
-    const { specDir, specId } = options;
-    const filePath = join(specDir, CHANGELOG_FILENAME);
-    try {
-        const content = await readFile(filePath, 'utf-8');
-        const entries = parseChangelogEntries(content, specId);
-        return { specId, entries };
-    }
-    catch {
-        return null;
-    }
-}
-/** Read only the timestamp of the last (most recent) changelog entry. Optimized for list_specs. */
-export async function readLastModifiedTimestamp(specDir) {
-    const filePath = join(specDir, CHANGELOG_FILENAME);
-    try {
-        const content = await readFile(filePath, 'utf-8');
-        return parseFirstEntryTimestamp(content);
-    }
-    catch {
-        return null;
-    }
-}
-/** Append a new entry to the CHANGELOG.md for a spec. Creates the file if it doesn't exist. */
-export async function appendChangelogEntry(options) {
-    const { specDir, specId, entry } = options;
-    const filePath = join(specDir, CHANGELOG_FILENAME);
-    try {
-        let existingContent = '';
-        let hasHeader = false;
-        try {
-            existingContent = await readFile(filePath, 'utf-8');
-            hasHeader = existingContent.includes(CHANGELOG_VERSION_COMMENT);
-        }
-        catch {
-            // File doesn't exist yet — will create fresh
-        }
-        const entryMarkdown = formatEntry(entry, specId);
-        let newContent;
-        if (!hasHeader) {
-            newContent = buildHeader(specId) + entryMarkdown + existingContent;
-        }
-        else {
-            // Insert after the header block (after the # Changelog line)
-            const insertAfterPattern = /^# Changelog[^\n]*\n\n/m;
-            const match = insertAfterPattern.exec(existingContent);
-            if (match) {
-                const insertAt = match.index + match[0].length;
-                newContent =
-                    existingContent.slice(0, insertAt) + entryMarkdown + existingContent.slice(insertAt);
-            }
-            else {
-                // Fallback: append after existing content
-                newContent = existingContent + entryMarkdown;
-            }
-        }
-        await writeFile(filePath, newContent, 'utf-8');
-        return true;
-    }
-    catch (error) {
-        console.error(`[spec-changelog] Failed to write CHANGELOG.md for ${specId}:`, error);
-        return false;
-    }
-}
-/** Format a relative date string (e.g. "hace 2 dias") for a timestamp. */
-export function formatRelativeDate(timestamp) {
-    const date = new Date(timestamp);
-    const now = new Date();
-    const diffMs = now.getTime() - date.getTime();
-    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
-    if (diffDays === 0) {
-        return 'hoy';
-    }
-    if (diffDays === 1) {
-        return 'hace 1 dia';
-    }
-    if (diffDays <= 30) {
-        return `hace ${diffDays} dias`;
-    }
-    // Older than 30 days: return ISO date portion
-    return timestamp.slice(0, 10);
-}
-//# sourceMappingURL=core.js.map

package/dist/engine/spec-changelog/diff.d.ts

@@ -1,18 +0,0 @@
-import type { CriteriaDiff } from '../../types/index.js';
-/** Normalize a criteria text for comparison (trim, collapse whitespace). */
-export declare function normalizeCriteriaText(text: string): string;
-/**
- * Compute a simple similarity score (0–1) between two strings.
- * Uses character bigram overlap.
- */
-export declare function similarityScore(a: string, b: string): number;
-/**
- * Compute semantic diff between two sets of criteria texts.
- * Returns added, removed, and modified criteria.
- */
-export declare function computeCriteriaDiff(before: string[], after: string[]): CriteriaDiff;
-/**
- * Returns true if the diff contains any actual changes.
- */
-export declare function hasDiffChanges(diff: CriteriaDiff): boolean;
-//# sourceMappingURL=diff.d.ts.map

package/dist/engine/spec-changelog/diff.js

@@ -1,121 +0,0 @@
-// engine/spec-changelog/diff.ts — Semantic diff calculation for spec criteria
-/** Normalize a criteria text for comparison (trim, collapse whitespace). */
-export function normalizeCriteriaText(text) {
-    return text
-        .replace(/^#+\s+/, '') // remove markdown headers
-        .replace(/\*\*/g, '') // remove bold markers
-        .replace(/\s+/g, ' ') // collapse whitespace
-        .trim()
-        .toLowerCase();
-}
-/**
- * Compute a simple similarity score (0–1) between two strings.
- * Uses character bigram overlap.
- */
-export function similarityScore(a, b) {
-    if (a.length === 0 && b.length === 0) {
-        return 0;
-    }
-    if (a === b) {
-        return 1;
-    }
-    if (a.length === 0 || b.length === 0) {
-        return 0;
-    }
-    const buildBigrams = (str) => {
-        const bigrams = new Set();
-        for (let i = 0; i < str.length - 1; i++) {
-            bigrams.add(str.slice(i, i + 2));
-        }
-        return bigrams;
-    };
-    const bigramsA = buildBigrams(a);
-    const bigramsB = buildBigrams(b);
-    let intersection = 0;
-    for (const bigram of bigramsA) {
-        if (bigramsB.has(bigram)) {
-            intersection++;
-        }
-    }
-    const total = bigramsA.size + bigramsB.size;
-    // Single-char strings produce no bigrams — fall back to exact match
-    if (total === 0) {
-        return a === b ? 1 : 0;
-    }
-    return (2 * intersection) / total;
-}
-/**
- * Compute semantic diff between two sets of criteria texts.
- * Returns added, removed, and modified criteria.
- */
-export function computeCriteriaDiff(before, after) {
-    const normalizedBefore = before.map(normalizeCriteriaText);
-    const normalizedAfter = after.map(normalizeCriteriaText);
-    const SIMILARITY_THRESHOLD = 0.6;
-    const matchedBeforeIndices = new Set();
-    const matchedAfterIndices = new Set();
-    const modified = [];
-    // Find modifications: pairs with high similarity but not identical
-    for (let i = 0; i < normalizedBefore.length; i++) {
-        const nb = normalizedBefore[i];
-        /* v8 ignore next 2 — noUncheckedIndexedAccess guard; array built with .map() so never undefined */
-        if (nb === undefined) {
-            continue;
-        }
-        let bestScore = 0;
-        let bestJ = -1;
-        for (let j = 0; j < normalizedAfter.length; j++) {
-            if (matchedAfterIndices.has(j)) {
-                continue;
-            }
-            const na = normalizedAfter[j];
-            /* v8 ignore next 2 — noUncheckedIndexedAccess guard; array built with .map() so never undefined */
-            if (na === undefined) {
-                continue;
-            }
-            const score = similarityScore(nb, na);
-            if (score > bestScore) {
-                bestScore = score;
-                bestJ = j;
-            }
-        }
-        if (bestScore >= SIMILARITY_THRESHOLD && bestJ !== -1) {
-            matchedBeforeIndices.add(i);
-            matchedAfterIndices.add(bestJ);
-            const beforeText = before[i];
-            const afterText = after[bestJ];
-            // Only report as modified if texts actually differ
-            if (beforeText !== undefined && afterText !== undefined && beforeText !== afterText) {
-                modified.push({ before: beforeText, after: afterText });
-            }
-        }
-    }
-    // Removed: unmatched before items
-    const removed = [];
-    for (let i = 0; i < before.length; i++) {
-        if (!matchedBeforeIndices.has(i)) {
-            const text = before[i];
-            if (text !== undefined) {
-                removed.push(text);
-            }
-        }
-    }
-    // Added: unmatched after items
-    const added = [];
-    for (let j = 0; j < after.length; j++) {
-        if (!matchedAfterIndices.has(j)) {
-            const text = after[j];
-            if (text !== undefined) {
-                added.push(text);
-            }
-        }
-    }
-    return { added, removed, modified };
-}
-/**
- * Returns true if the diff contains any actual changes.
- */
-export function hasDiffChanges(diff) {
-    return diff.added.length > 0 || diff.removed.length > 0 || diff.modified.length > 0;
-}
-//# sourceMappingURL=diff.js.map

package/dist/engine/spec-changelog/index.d.ts

@@ -1,3 +0,0 @@
-export * from './core.js';
-export * from './diff.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/engine/spec-changelog/index.js

@@ -1,4 +0,0 @@
-// engine/spec-changelog/index.ts — Barrel export for spec-changelog module
-export * from './core.js';
-export * from './diff.js';
-//# sourceMappingURL=index.js.map

package/dist/engine/telemetry/geo-resolver.d.ts

@@ -1,9 +0,0 @@
-import type { GeoData } from '../../types/index.js';
-/**
- * Returns geo data for the current machine IP.
- * Cached after the first successful call; null if the lookup fails or times out.
- */
-export declare function resolveGeo(): Promise<GeoData | null>;
-/** Reset cache — used in tests. */
-export declare function resetGeoCache(): void;
-//# sourceMappingURL=geo-resolver.d.ts.map

package/dist/engine/telemetry/geo-resolver.js

@@ -1,43 +0,0 @@
-// engine/telemetry/geo-resolver.ts — Cached geo-IP lookup for telemetry enrichment.
-// Uses ip-api.com (free, no API key, 45 req/min). Called once per process lifecycle.
-// Never throws — geo enrichment is purely best-effort.
-let cachedGeo = null;
-let lookupAttempted = false;
-/**
- * Returns geo data for the current machine IP.
- * Cached after the first successful call; null if the lookup fails or times out.
- */
-export async function resolveGeo() {
-    if (lookupAttempted) {
-        return cachedGeo;
-    }
-    lookupAttempted = true;
-    try {
-        const res = await fetch('http://ip-api.com/json/?fields=country,countryCode,city,timezone', {
-            signal: AbortSignal.timeout(2_000),
-        });
-        if (!res.ok) {
-            return null;
-        }
-        const data = (await res.json());
-        if (typeof data.countryCode !== 'string') {
-            return null;
-        }
-        cachedGeo = {
-            country: typeof data.country === 'string' ? data.country : '',
-            countryCode: data.countryCode,
-            city: typeof data.city === 'string' ? data.city : '',
-            timezone: typeof data.timezone === 'string' ? data.timezone : '',
-        };
-        return cachedGeo;
-    }
-    catch {
-        return null;
-    }
-}
-/** Reset cache — used in tests. */
-export function resetGeoCache() {
-    cachedGeo = null;
-    lookupAttempted = false;
-}
-//# sourceMappingURL=geo-resolver.js.map

package/dist/engine/trial-engine.d.ts

@@ -1,5 +0,0 @@
-export declare function getInstallationId(): string;
-export declare function getTrialStatus(_projectId?: string): null;
-export declare function isTrialActive(_projectId?: string): boolean;
-export declare function requestTrial(_projectId?: string): Promise<void>;
-//# sourceMappingURL=trial-engine.d.ts.map

package/dist/engine/trial-engine.js

@@ -1,14 +0,0 @@
-// engine/trial-engine.ts — Trial stub (trial tools removed in SPEC-533)
-export function getInstallationId() {
-    return 'n/a';
-}
-export function getTrialStatus(_projectId) {
-    return null;
-}
-export function isTrialActive(_projectId) {
-    return false;
-}
-export async function requestTrial(_projectId) {
-    // No-op: trial tools removed
-}
-//# sourceMappingURL=trial-engine.js.map

package/dist/engine/usage-tracker/rate-check.d.ts

@@ -1,7 +0,0 @@
-import type { RateLimitResult } from '../../types/index.js';
-/**
- * Evaluates both daily limit and cooldown in a single call.
- * Returns the first failing check, or an allowed result if both pass.
- */
-export declare function evaluateRateLimit(callCount: number, maxCalls: number, lastCallAt: string | null, now: Date): RateLimitResult;
-//# sourceMappingURL=rate-check.d.ts.map

package/dist/engine/usage-tracker/rate-check.js

@@ -1,18 +0,0 @@
-// engine/usage-tracker/rate-check.ts — Composed rate-limit evaluation (pure, no I/O).
-import { checkDailyLimit, checkCooldown } from './rate-limiter.js';
-/**
- * Evaluates both daily limit and cooldown in a single call.
- * Returns the first failing check, or an allowed result if both pass.
- */
-export function evaluateRateLimit(callCount, maxCalls, lastCallAt, now) {
-    const daily = checkDailyLimit(callCount, maxCalls);
-    if (!daily.allowed) {
-        return daily;
-    }
-    const cooldown = checkCooldown(lastCallAt, now);
-    if (!cooldown.allowed) {
-        return cooldown;
-    }
-    return daily;
-}
-//# sourceMappingURL=rate-check.js.map

package/dist/engine/usage-tracker/rate-limiter.d.ts

@@ -1,14 +0,0 @@
-import type { RateLimitResult } from '../../types/index.js';
-/** Minimum milliseconds required between consecutive tool calls. */
-export declare const COOLDOWN_MS = 2000;
-/**
- * Checks whether the caller has exceeded the daily call limit.
- * Returns an allowed result when maxCalls is -1 (unlimited).
- */
-export declare function checkDailyLimit(callCount: number, maxCalls: number): RateLimitResult;
-/**
- * Checks whether enough time has passed since the last tool call.
- * Passes when lastCallAt is null (no previous call recorded).
- */
-export declare function checkCooldown(lastCallAt: string | null, now: Date): RateLimitResult;
-//# sourceMappingURL=rate-limiter.d.ts.map

package/dist/engine/usage-tracker/rate-limiter.js

@@ -1,73 +0,0 @@
-// engine/usage-tracker/rate-limiter.ts — Rate limiting logic (pure functions, no I/O).
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-/** Minimum milliseconds required between consecutive tool calls. */
-export const COOLDOWN_MS = 2000;
-// ---------------------------------------------------------------------------
-// Daily limit check
-// ---------------------------------------------------------------------------
-/**
- * Checks whether the caller has exceeded the daily call limit.
- * Returns an allowed result when maxCalls is -1 (unlimited).
- */
-export function checkDailyLimit(callCount, maxCalls) {
-    if (maxCalls === -1) {
-        return {
-            allowed: true,
-            reason: null,
-            message: 'Unlimited calls available.',
-            remainingCalls: -1,
-        };
-    }
-    const remaining = maxCalls - callCount;
-    if (remaining <= 0) {
-        return {
-            allowed: false,
-            reason: 'daily_limit',
-            message: `Daily call limit of ${String(maxCalls)} reached. Limit resets at midnight UTC.`,
-            remainingCalls: 0,
-        };
-    }
-    return {
-        allowed: true,
-        reason: null,
-        message: `${String(remaining)} of ${String(maxCalls)} daily calls remaining.`,
-        remainingCalls: remaining,
-    };
-}
-// ---------------------------------------------------------------------------
-// Cooldown check
-// ---------------------------------------------------------------------------
-/**
- * Checks whether enough time has passed since the last tool call.
- * Passes when lastCallAt is null (no previous call recorded).
- */
-export function checkCooldown(lastCallAt, now) {
-    if (lastCallAt === null) {
-        return {
-            allowed: true,
-            reason: null,
-            message: 'No previous call recorded.',
-            remainingCalls: -1,
-        };
-    }
-    const lastCallMs = new Date(lastCallAt).getTime();
-    const elapsedMs = now.getTime() - lastCallMs;
-    if (elapsedMs < COOLDOWN_MS) {
-        const waitMs = COOLDOWN_MS - elapsedMs;
-        return {
-            allowed: false,
-            reason: 'cooldown',
-            message: `Rate limit: please wait ${String(waitMs)}ms before the next call.`,
-            remainingCalls: -1,
-        };
-    }
-    return {
-        allowed: true,
-        reason: null,
-        message: 'Cooldown period elapsed.',
-        remainingCalls: -1,
-    };
-}
-//# sourceMappingURL=rate-limiter.js.map

package/dist/engine/usage-tracker/trial.d.ts

@@ -1,27 +0,0 @@
-/** Number of days in the full trial period. */
-export declare const TRIAL_DAYS = 30;
-/**
- * Returns the number of whole days elapsed since the given ISO 8601 timestamp.
- */
-export declare function calculateDaysSinceFirstRun(firstRunAt: string): number;
-/**
- * Returns true if the installation is still within the 30-day trial period.
- */
-export declare function isTrialActive(firstRunAt: string): boolean;
-/**
- * Returns the number of days remaining in the trial period.
- * Returns 0 if the trial has already expired.
- */
-export declare function trialDaysRemaining(firstRunAt: string): number;
-/**
- * Returns tool/spec/daily-call limits based on the current trial status.
- *
- * - Day 1–30  (trial active):  { tools: 20, specs: 5, dailyCalls: 50 }
- * - Day 31+   (trial expired): { tools: 10, specs: 3, dailyCalls: 30 }
- */
-export declare function getTrialLimits(firstRunAt: string): {
-    tools: number;
-    specs: number;
-    dailyCalls: number;
-};
-//# sourceMappingURL=trial.d.ts.map

package/dist/engine/usage-tracker/trial.js

@@ -1,49 +0,0 @@
-// engine/usage-tracker/trial.ts — Trial period logic (pure functions, no I/O).
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-/** Number of days in the full trial period. */
-export const TRIAL_DAYS = 30;
-const MS_PER_DAY = 24 * 60 * 60 * 1000;
-// ---------------------------------------------------------------------------
-// Trial calculations
-// ---------------------------------------------------------------------------
-/**
- * Returns the number of whole days elapsed since the given ISO 8601 timestamp.
- */
-export function calculateDaysSinceFirstRun(firstRunAt) {
-    const firstRunMs = new Date(firstRunAt).getTime();
-    const nowMs = Date.now();
-    const elapsedMs = nowMs - firstRunMs;
-    return Math.floor(elapsedMs / MS_PER_DAY);
-}
-/**
- * Returns true if the installation is still within the 30-day trial period.
- */
-export function isTrialActive(firstRunAt) {
-    return calculateDaysSinceFirstRun(firstRunAt) < TRIAL_DAYS;
-}
-/**
- * Returns the number of days remaining in the trial period.
- * Returns 0 if the trial has already expired.
- */
-export function trialDaysRemaining(firstRunAt) {
-    const elapsed = calculateDaysSinceFirstRun(firstRunAt);
-    return Math.max(0, TRIAL_DAYS - elapsed);
-}
-// ---------------------------------------------------------------------------
-// Limit resolution
-// ---------------------------------------------------------------------------
-/**
- * Returns tool/spec/daily-call limits based on the current trial status.
- *
- * - Day 1–30  (trial active):  { tools: 20, specs: 5, dailyCalls: 50 }
- * - Day 31+   (trial expired): { tools: 10, specs: 3, dailyCalls: 30 }
- */
-export function getTrialLimits(firstRunAt) {
-    if (isTrialActive(firstRunAt)) {
-        return { tools: 20, specs: 5, dailyCalls: 50 };
-    }
-    return { tools: 10, specs: 3, dailyCalls: 30 };
-}
-//# sourceMappingURL=trial.js.map

package/dist/engine/webhook/event-handlers.d.ts

@@ -1,25 +0,0 @@
-import type { LemonSqueezyWebhookPayload, WebhookProcessResult } from '../../types/index.js';
-/**
- * Handles subscription_cancelled: the customer cancelled their subscription.
- * The tier should be reverted to free when the subscription period ends.
- */
-export declare function handleSubscriptionCancelled(payload: LemonSqueezyWebhookPayload): WebhookProcessResult;
-/**
- * Handles subscription_updated: plan tier may have changed (upgrade/downgrade).
- */
-export declare function handleSubscriptionUpdated(payload: LemonSqueezyWebhookPayload): WebhookProcessResult;
-/**
- * Handles license_key_created: a new license key was issued (after purchase).
- * This is informational — the user will activate the key via activate_license tool.
- */
-export declare function handleLicenseKeyCreated(payload: LemonSqueezyWebhookPayload): WebhookProcessResult;
-/**
- * Returns a generic "acknowledged" result for unhandled but recognised events.
- */
-export declare function handleUnknownEvent(eventType: string): WebhookProcessResult;
-/**
- * Dispatches a parsed webhook payload to the appropriate event handler.
- * Unhandled but valid events are acknowledged with a 200 response.
- */
-export declare function dispatchWebhookEvent(payload: LemonSqueezyWebhookPayload): WebhookProcessResult;
-//# sourceMappingURL=event-handlers.d.ts.map