@aragon-agent/cli 0.6.46 → 0.6.48

package/dist/ui/editor-reducer.js

@@ -1,187 +0,0 @@
-/**
- * Composer editor state — F3 of tui-input-flicker-fix (§3.4).
- *
- * Ink creates its container with tag `0` — a LEGACY React root
- * (`ink/build/ink.js:59-61`). In a legacy root, `setState` called outside a
- * React event handler is NOT batched: each call schedules and immediately
- * flushes a synchronous render. `useInput`'s callback runs from a stdin
- * `'data'` listener, which is outside React entirely, so `PromptInput.insert`'s
- * five `setState` calls became five commits, five whole-tree Yoga layouts, and
- * — through Ink's 32 ms leading+trailing throttle — TWO full-frame repaints per
- * printable character (§2 R3). The flicker got worse the faster the user typed,
- * which is exactly what the report described.
- *
- * Collapsing the five always-together pieces of state into one reducer makes a
- * keystroke cost one commit. `fileMatches` deliberately stays a separate
- * `useState` in the component: it is written from the debounced async glob
- * effect, not from the key handler, so folding it in here would couple two
- * unrelated update sources.
- *
- * THE RULE A REVIEWER SHOULD CHECK LINE BY LINE: every branch of the `useInput`
- * callback performs at most ONE `dispatch` and then returns.
- *
- * Extracted from the component so it is unit-testable without mounting Ink.
- */
-import { expandRangeOverTokens, formatPasteToken, makePasteRecord, referencedIds, shouldCollapse, snapOutOfToken, } from './paste-tokens.js';
-import { snapGrapheme, stepGrapheme } from './editor-navigation.js';
-const NO_PASTES = new Map();
-export const INITIAL_EDITOR_STATE = {
-    buffer: '',
-    cursor: 0,
-    historyIndex: null,
-    dismissed: false,
-    sel: 0,
-    pastes: NO_PASTES,
-};
-/**
- * The three flags `resetDraftFlags()` used to clear with three separate
- * `setState` calls.
- *
- * Every action that CHANGES THE BUFFER resets them, and that is the pre-existing
- * semantics rather than a new rule: an edit invalidates the history cursor (the
- * draft is no longer the recalled entry), un-dismisses the popup (the user is
- * typing again, so suggestions should come back), and re-homes the selection
- * (the candidate list is about to be recomputed).
- */
-const DRAFT_FLAGS = {
-    historyIndex: null, dismissed: false, sel: 0, preferredVisualColumn: undefined,
-};
-/**
- * Drop payloads the buffer no longer references (I-7).
- *
- * A WRAPPER, NOT A LINE IN ONE BRANCH (P1-6). v1 of the design pruned only inside
- * `input`, which leaves `replace` (the action behind `Ctrl+U` / `Ctrl+K` /
- * `Ctrl+W` and every `applyEdit`), `backspace` and `recall` able to delete a token
- * without releasing its payload. A rule the body contradicts is worse than no
- * rule, because the next reader trusts the invariant.
- *
- * `moveCursor`, `select` and `dismiss` do not change the buffer and are left
- * alone, which keeps their "return the same object so React bails out" property.
- */
-function withPrune(next) {
-    if (next.pastes.size === 0)
-        return next;
-    const live = referencedIds(next.buffer);
-    // EVERY held id is tested, rather than `live.size === next.pastes.size`.
-    // Equal counts do not mean equal sets: `referencedIds` reads the BUFFER, which
-    // can name an id this map never held — a user who types `[Pasted text #99 +2
-    // lines]` by hand, or edits the number inside a real token. One such id
-    // balances out one deleted token and the cheap check then returns early with a
-    // payload the buffer no longer references, which is the leak I-7 forbids.
-    let stale = false;
-    for (const id of next.pastes.keys()) {
-        if (!live.has(id)) {
-            stale = true;
-            break;
-        }
-    }
-    if (!stale)
-        return next;
-    const kept = new Map();
-    for (const [id, record] of next.pastes)
-        if (live.has(id))
-            kept.set(id, record);
-    return { ...next, pastes: kept };
-}
-export function editorReducer(state, action) {
-    switch (action.type) {
-        case 'adopt':
-            return withPrune(action.state);
-        case 'insert': {
-            // D-8: typing can never land INSIDE a token. A no-op on a buffer with no
-            // tokens, which is every buffer until the first collapse.
-            const cursor = snapOutOfToken(state.buffer, snapGrapheme(state.buffer, state.cursor));
-            const buffer = state.buffer.slice(0, cursor) + action.text + state.buffer.slice(cursor);
-            return withPrune({
-                ...state,
-                ...DRAFT_FLAGS,
-                buffer,
-                cursor: snapGrapheme(buffer, cursor + action.text.length, true),
-            });
-        }
-        case 'replace':
-            return withPrune({
-                ...state,
-                ...DRAFT_FLAGS,
-                buffer: action.buffer,
-                cursor: snapGrapheme(action.buffer, action.cursor),
-            });
-        case 'backspace':
-        case 'delete': {
-            const cursor = snapGrapheme(state.buffer, state.cursor);
-            const backwards = action.type === 'backspace';
-            if (backwards ? cursor <= 0 : cursor >= state.buffer.length)
-                return state;
-            // G5: one `Backspace` immediately after `...lines]` removes the whole
-            // token and releases its payload, in ONE dispatch.
-            const other = stepGrapheme(state.buffer, cursor, backwards ? 'left' : 'right');
-            const range = expandRangeOverTokens(state.buffer, backwards ? other : cursor, backwards ? cursor : other);
-            const buffer = state.buffer.slice(0, range.from) + state.buffer.slice(range.to);
-            return withPrune({
-                ...state,
-                ...DRAFT_FLAGS,
-                buffer,
-                cursor: snapGrapheme(buffer, range.from),
-            });
-        }
-        case 'input': {
-            let buffer = state.buffer;
-            let cursor = snapOutOfToken(buffer, snapGrapheme(buffer, state.cursor));
-            let pastes = null;
-            for (const segment of action.segments) {
-                const collapse = segment.kind === 'paste' && shouldCollapse(segment.text);
-                let text = segment.text;
-                if (collapse) {
-                    const record = makePasteRecord(segment.id, segment.text);
-                    text = formatPasteToken(record);
-                    pastes = pastes ?? new Map(state.pastes);
-                    pastes.set(record.id, record);
-                }
-                buffer = buffer.slice(0, cursor) + text + buffer.slice(cursor);
-                cursor = snapGrapheme(buffer, cursor + text.length, true);
-            }
-            return withPrune({
-                ...state,
-                ...DRAFT_FLAGS,
-                buffer,
-                cursor,
-                ...(pastes ? { pastes } : {}),
-            });
-        }
-        case 'moveCursor': {
-            // NO DRAFT-FLAG RESET. Moving the caret is not an edit: clearing
-            // `historyIndex` here would end a history walk the moment the user pressed
-            // ← to look at what they recalled.
-            const cursor = snapGrapheme(state.buffer, action.cursor);
-            const preferredVisualColumn = action.preferredVisualColumn;
-            return state.cursor === cursor && state.preferredVisualColumn === preferredVisualColumn
-                ? state : { ...state, cursor, preferredVisualColumn };
-        }
-        case 'recall':
-            // `historyIndex` is SET, not reset, which is why recall cannot reuse
-            // `replace` — the two differ in exactly the field that keeps the walk
-            // alive. `dismissed` is forced TRUE (history-recall-autocomplete-popup):
-            // recalled content is not a query the user is typing, so the suggestion
-            // popup must not appear over it - while it is visible it owns Up/Down and
-            // the second Up moves the highlight instead of stepping history. Any
-            // buffer edit (insert / backspace / replace / input ...) re-arms the
-            // popup through DRAFT_FLAGS, so typing over a recall restores them. The
-            // same gate covers the `@file` popup, which shares `dismissed`.
-            // `sel` is still LEFT ALONE: invisible while dismissed, re-homed by the
-            // next buffer change; touching it would only widen the diff (K-7 note).
-            return withPrune({
-                ...state,
-                buffer: action.buffer,
-                cursor: snapGrapheme(action.buffer, action.cursor),
-                preferredVisualColumn: undefined,
-                historyIndex: action.historyIndex,
-                dismissed: true,
-            });
-        case 'select':
-            return state.sel === action.sel ? state : { ...state, sel: action.sel };
-        case 'dismiss':
-            return state.dismissed ? state : { ...state, dismissed: true };
-        case 'clear':
-            return INITIAL_EDITOR_STATE;
-    }
-}

package/dist/ui/enter-frames.d.ts

@@ -1,47 +0,0 @@
-export type ComposerFrame = {
-    kind: 'text';
-    text: string;
-} | {
-    kind: 'paste';
-    text: string;
-} | {
-    kind: 'newline';
-} | {
-    kind: 'submit';
-};
-/** True when this `input` carries at least one Enter frame -- the branch guard. */
-export declare function hasEnterFrame(input: string): boolean;
-/**
- * Decode paste regions before interpreting CR/LF or newline frames as keys.
- * Paste IDs remain the caller's responsibility.
- */
-export declare function splitEnterFrames(input: string): ComposerFrame[];
-/**
- * Merge newline runs with the paste frames that share the same `input`.
- *
- * Ink drains its buffer in one size-less `read()`, so the filter's TWO writes
- * (one per frame family) can arrive as ONE chunk carrying both a paste frame
- * and an Enter frame. Neither splitter alone preserves that order --
- * `splitPasteFrames` sanitises `\n` out of its text runs, and this module's
- * spans treat a paste payload as ordinary text -- so the merge walks the
- * ORIGINAL string once: paste frames become paste segments (payload through
- * `sanitisePaste`, as `splitPasteFrames` does), and the spans between them are
- * segmented with the SAME walker `splitEnterFrames` uses, which is what keeps
- * the two views from disagreeing about where a newline sits.
- *
- * Paste segments carry NO id here (P1-5); the caller assigns one per segment
- * only when it builds the reducer's action.
- */
-export declare function mergeWithPasteRuns(input: string, runs: ComposerFrame[]): ComposerFrame[];
-/**
- * Remove every Enter frame for a consumer that has no newline model of its
- * own, replacing each frame with `'\n'` (tui-shift-enter-copy-queue 3.5, the
- * I-12 analogue for this frame family).
- *
- * NO OTHER SANITISATION, unlike `stripPasteFrames`: the overlay call sites wrap
- * this INSIDE their existing `stripPasteFrames(...)` call, and the composite
- * keeps that function's byte-level guarantees. Composed the other way round a
- * lone NUL frame would survive as its payload letter; composed this way the
- * frame's newline lands exactly where a bare Ctrl+J lands today.
- */
-export declare function stripEnterFrames(input: string): string;

package/dist/ui/enter-frames.js

@@ -1,117 +0,0 @@
-import { ENTER_NEWLINE_FRAME, PASTE_CLOSE, PASTE_OPEN } from '../input/limits.js';
-import { sanitisePaste } from '../input/paste-parse.js';
-import { sanitiseTyped } from './paste-frames.js';
-/** True when this `input` carries at least one Enter frame -- the branch guard. */
-export function hasEnterFrame(input) {
-    return input.includes(ENTER_NEWLINE_FRAME);
-}
-/**
- * Split one paste-free span into ordered text, newline and submit intents.
- *
- * Every newline source -- frame or bare `\n` -- yields ONE
- * `{ kind: 'newline' }` segment, so the editor's existing `input`
- * action inserts it through the same path typing uses and the draft's row
- * budget applies unchanged. Non-newline text is accumulated and passed through
- * `sanitiseTyped` (I-14): a chunk that carries a frame can also carry the
- * keystrokes that arrived beside it, and a coalesced CR must not be spliced
- * back into the draft raw.
- */
-function splitEnterSpan(span) {
-    const segments = [];
-    let text = '';
-    const pushText = () => {
-        const clean = sanitiseTyped(text);
-        if (clean.length > 0)
-            segments.push({ kind: 'text', text: clean });
-        text = '';
-    };
-    let i = 0;
-    while (i < span.length) {
-        if (span.startsWith(ENTER_NEWLINE_FRAME, i)) {
-            pushText();
-            segments.push({ kind: 'newline' });
-            i += ENTER_NEWLINE_FRAME.length;
-            continue;
-        }
-        if (span[i] === '\r') {
-            pushText();
-            segments.push({ kind: 'submit' });
-            i += 1;
-            continue;
-        }
-        if (span[i] === '\n') {
-            pushText();
-            segments.push({ kind: 'newline' });
-            i += 1;
-            continue;
-        }
-        text += span[i];
-        i += 1;
-    }
-    pushText();
-    return segments;
-}
-/**
- * Decode paste regions before interpreting CR/LF or newline frames as keys.
- * Paste IDs remain the caller's responsibility.
- */
-export function splitEnterFrames(input) {
-    return input.includes(PASTE_OPEN)
-        ? mergeWithPasteRuns(input, []) : splitEnterSpan(input);
-}
-/**
- * Merge newline runs with the paste frames that share the same `input`.
- *
- * Ink drains its buffer in one size-less `read()`, so the filter's TWO writes
- * (one per frame family) can arrive as ONE chunk carrying both a paste frame
- * and an Enter frame. Neither splitter alone preserves that order --
- * `splitPasteFrames` sanitises `\n` out of its text runs, and this module's
- * spans treat a paste payload as ordinary text -- so the merge walks the
- * ORIGINAL string once: paste frames become paste segments (payload through
- * `sanitisePaste`, as `splitPasteFrames` does), and the spans between them are
- * segmented with the SAME walker `splitEnterFrames` uses, which is what keeps
- * the two views from disagreeing about where a newline sits.
- *
- * Paste segments carry NO id here (P1-5); the caller assigns one per segment
- * only when it builds the reducer's action.
- */
-export function mergeWithPasteRuns(input, runs) {
-    if (!input.includes(PASTE_OPEN))
-        return runs;
-    const merged = [];
-    let i = 0;
-    while (i < input.length) {
-        const open = input.indexOf(PASTE_OPEN, i);
-        if (open === -1) {
-            merged.push(...splitEnterSpan(input.slice(i)));
-            break;
-        }
-        merged.push(...splitEnterSpan(input.slice(i, open)));
-        const bodyStart = open + PASTE_OPEN.length;
-        const close = input.indexOf(PASTE_CLOSE, bodyStart);
-        const body = close === -1 ? input.slice(bodyStart) : input.slice(bodyStart, close);
-        const payload = sanitisePaste(body);
-        if (payload.length > 0)
-            merged.push({ kind: 'paste', text: payload });
-        if (close === -1)
-            break;
-        i = close + PASTE_CLOSE.length;
-    }
-    return merged;
-}
-/**
- * Remove every Enter frame for a consumer that has no newline model of its
- * own, replacing each frame with `'\n'` (tui-shift-enter-copy-queue 3.5, the
- * I-12 analogue for this frame family).
- *
- * NO OTHER SANITISATION, unlike `stripPasteFrames`: the overlay call sites wrap
- * this INSIDE their existing `stripPasteFrames(...)` call, and the composite
- * keeps that function's byte-level guarantees. Composed the other way round a
- * lone NUL frame would survive as its payload letter; composed this way the
- * frame's newline lands exactly where a bare Ctrl+J lands today.
- */
-export function stripEnterFrames(input) {
-    if (!hasEnterFrame(input))
-        return input;
-    return input.split(ENTER_NEWLINE_FRAME).join('\n');
-}

package/dist/ui/entries/AssistantEntry.d.ts

@@ -1,37 +0,0 @@
-/**
- * Render a streaming assistant entry: an optional collapsible thinking block
- * above the markdown-rendered answer text. Empty entries render nothing (a turn
- * that only produced tool calls has no assistant text).
- *
- * The role glyph and spacing belong to `EntryFrame` (§4.3) — including the
- * streaming spinner, which IS the role marker while text is arriving.
- *
- * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3):
- * every prop here is a scalar except `theme` and `caps`, both of which are
- * `useMemo`d in `App.tsx` and therefore referentially stable across frames
- * (I-L2-1, asserted by `render-memo.test.tsx`). If either ever becomes a fresh
- * object per render this boundary silently becomes a no-op — which is exactly
- * why that assertion exists rather than a comment.
- */
-import React from 'react';
-import type { Theme } from '../theme.js';
-import type { TermCapabilities } from '../capabilities.js';
-interface AssistantEntryProps {
-    text: string;
-    thinking?: string;
-    thinkingOpen: boolean;
-    thinkingVisible: boolean;
-    streaming: boolean;
-    aborted?: boolean;
-    /**
-     * Sealed reasoning time (§3.1.2). OMITTED WHEN UNKNOWN rather than printed as
-     * `0s`: a session restored from a file written by an older build has none, and
-     * `thought for 0s` is a lie where a bare `thought` is merely terse.
-     */
-    thinkingMs?: number;
-    theme: Theme;
-    caps: TermCapabilities;
-}
-declare function AssistantEntryImpl(props: AssistantEntryProps): React.ReactElement | null;
-export declare const AssistantEntry: React.MemoExoticComponent<typeof AssistantEntryImpl>;
-export {};

package/dist/ui/entries/AssistantEntry.js

@@ -1,43 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-/**
- * Render a streaming assistant entry: an optional collapsible thinking block
- * above the markdown-rendered answer text. Empty entries render nothing (a turn
- * that only produced tool calls has no assistant text).
- *
- * The role glyph and spacing belong to `EntryFrame` (§4.3) — including the
- * streaming spinner, which IS the role marker while text is arriving.
- *
- * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3):
- * every prop here is a scalar except `theme` and `caps`, both of which are
- * `useMemo`d in `App.tsx` and therefore referentially stable across frames
- * (I-L2-1, asserted by `render-memo.test.tsx`). If either ever becomes a fresh
- * object per render this boundary silently becomes a no-op — which is exactly
- * why that assertion exists rather than a comment.
- */
-import React from 'react';
-import { Box, Text } from 'ink';
-import { pickGlyphs } from '../glyphs.js';
-import { Markdown } from '../Markdown.js';
-import { splitLinesCached } from '../render-cache.js';
-import { clampLiveText } from '../live-clamp.js';
-import { formatDuration } from '../../agent/usage.js';
-function AssistantEntryImpl(props) {
-    const { text, thinking, thinkingOpen, thinkingVisible, streaming, aborted, thinkingMs, theme, caps, } = props;
-    const glyphs = pickGlyphs(caps);
-    const hasThinking = !!thinking && thinking.trim().length > 0;
-    const hasText = text.trim().length > 0;
-    if (!hasThinking && !hasText && !streaming)
-        return null;
-    // The thinking block is clamped to its TAIL while streaming even in
-    // full-screen mode: it is scratch reasoning the user reads the newest end of,
-    // and an unbounded one is the single easiest way to push a live entry past the
-    // whole viewport.
-    const thinkingRows = streaming ? STREAMING_THINKING_ROWS : undefined;
-    const clampedThinking = hasThinking && thinkingRows !== undefined
-        ? clampLiveText(thinking, thinkingRows)
-        : { text: thinking ?? '', hiddenRows: 0 };
-    return (_jsxs(Box, { flexDirection: "column", children: [hasThinking && thinkingVisible && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { wrap: "truncate", color: theme.thinking, children: [glyphs.thinking, " thinking", thinkingOpen ? glyphs.ellipsis : ''] }), _jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [clampedThinking.hiddenRows > 0 && (_jsxs(Text, { color: theme.muted, children: [glyphs.ellipsis, " ", clampedThinking.hiddenRows, " earlier", ' ', clampedThinking.hiddenRows === 1 ? 'line' : 'lines'] })), splitLinesCached(clampedThinking.text).map((line, i) => (_jsx(Text, { color: theme.thinking, dimColor: true, children: line }, i)))] })] })), hasThinking && !thinkingVisible && !streaming && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [glyphs.thinking, " thought", thinkingMs !== undefined ? ` for ${formatDuration(thinkingMs)}` : '', ` ${glyphs.midDot} ctrl+t to show`] })), (hasText || streaming) && (_jsxs(Box, { flexDirection: "column", children: [hasText ? (_jsx(Markdown, { text: text, theme: theme, caps: caps })) : (_jsx(Text, { color: theme.muted, children: glyphs.ellipsis })), aborted && _jsx(Text, { color: theme.noticeWarn, children: "[aborted]" })] }))] }));
-}
-/** Rows of live thinking kept on screen while an answer streams. */
-const STREAMING_THINKING_ROWS = 24;
-export const AssistantEntry = React.memo(AssistantEntryImpl);

package/dist/ui/entries/CompactionCard.d.ts

@@ -1,88 +0,0 @@
-/**
- * CompactionCard — one context compaction in the transcript
- * (context-auto-compaction §6.3).
- *
- * ASCII ONLY: every glyph comes from `pickGlyphs`, INCLUDING THE ARROW. The mock
- * in the design shows `112 -> 9 messages`; that arrow is `glyphs.arrowRight`, the
- * one `StatusBar` already uses, not a literal — `ui/` is inside
- * `glyphs.test.ts::inScope`, so a literal here fails the scan (P2-7).
- *
- * EXPANDABLE, UNLIKE `FastCard`. A critique is already clamped to
- * `fast.reviewMaxChars` before it reaches its card, so there is nothing hidden
- * for Ctrl+O to reveal; a summary is up to `summaryMaxChars` and there genuinely
- * is more to see. That is why `App`'s Ctrl+O predicate had to learn about this
- * kind — without it the card renders a hint that does nothing and expands an
- * older tool card instead (C-15 / P1-8 / AC-21).
- *
- * EVERY STRING DESCRIBES THE HISTORY, NEVER THE SCREEN (§6.4 / P2-9).
- * `/clear screen` empties the transcript view but not `messages`, so this card
- * can legitimately report a message count the visible rows do not add up to.
- * Nothing here says "above" or "earlier in this transcript". `/clear` itself is
- * the conversation boundary now: it drops the history and this card with it.
- */
-import React from 'react';
-import type { Theme } from '../theme.js';
-import type { TermCapabilities } from '../capabilities.js';
-import type { CompactionDecision, CompactionMode, CompactionPhase, CompactionUiTrigger } from '../../compaction/types.js';
-export interface CompactionCardProps {
-    decision?: CompactionDecision;
-    memoryVersion?: 2;
-    index: number;
-    trigger: CompactionUiTrigger;
-    mode: CompactionMode;
-    applied: boolean;
-    reason?: string;
-    messagesBefore: number;
-    messagesAfter: number;
-    tokensBefore: number;
-    tokensAfter: number;
-    summary?: string;
-    model: string;
-    durationMs?: number;
-    /** The live card's stage, so "compacting" also says WHAT (never-fires C). */
-    phase?: CompactionPhase;
-    /** Set when this cut existed only because `keepRecentTurns` was relaxed (B). */
-    keepRelaxed?: boolean;
-    retainedTurns?: number;
-    /** Messages the relaxed cut left verbatim, which is not the same as turns. */
-    retainedMessages?: number;
-    keepRecentTurnsUsed?: number;
-    /** Messages the digest left out and therefore cannot be quoted (A1). */
-    elidedMessages?: number;
-    /**
-     * Wall-clock since the card opened, LIVE ONLY
-     * (context-auto-compaction-hardening §3.6 / W5).
-     *
-     * Rendered in the position `durationMs` occupies once settled, so the number
-     * does not move when the card settles. Only the single live card receives it,
-     * so exactly one memoized card re-renders per second.
-     */
-    elapsedMs?: number;
-    /** Set when tail relief clipped the retained turns (W2). */
-    tailRelief?: {
-        messages: number;
-        charsRemoved: number;
-    };
-    live: boolean;
-    expanded?: boolean;
-    reducedMotion?: boolean;
-    theme: Theme;
-    caps: TermCapabilities;
-}
-/**
- * The card's colour.
- *
- * `truncated` is a WARNING rather than the accent, because it is a real and
- * bounded data loss the user is entitled to notice; `applied: false` is an error
- * because the run is still at the occupancy that triggered it.
- */
-export declare function compactionCardColor(props: Pick<CompactionCardProps, 'live' | 'applied' | 'mode'>, theme: Theme): string | undefined;
-declare function CompactionCardImpl(props: CompactionCardProps): React.ReactElement;
-/**
- * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).
- * `mapEntry` already preserves object identity for untouched entries, so the
- * props below are stable references on a settled card, and `theme` / `caps` are
- * `useMemo`d in `App.tsx` (I-L2-1).
- */
-export declare const CompactionCard: React.MemoExoticComponent<typeof CompactionCardImpl>;
-export {};