Skip to content

entity-viz-kit/react

Generated from actual exported declarations. These signatures and comments are not a second specification. See the integration guide and documented verification limits.

See the declaration and integration guide.

export declare function AnchorStatus({ resolution }: {
readonly resolution: AnchorResolution | null;
}): ReactElement;

Experimental. Outside the 1.0 stability promise; it may change in any minor release (system-r-0117).

View-only, distance-readable audience rendering of one immutable snapshot. It holds no operator store and exposes no actions; scale and density come from the published presentation. REQ: integration-r-0077 REQ: integration-r-0078 REQ: system-r-0087

export declare function AudienceDisplay(props: AudienceDisplayProps): ReactElement;

Experimental. Outside the 1.0 stability promise; it may change in any minor release (system-r-0117).

See the declaration and integration guide.

export interface AudienceDisplayProps {
readonly snapshot: AudienceSnapshot | null;
readonly status: AudienceStatus;
/** Host-rendered graph (the graph module is optional and not imported by /react). */
readonly graph?: ReactNode;
}

Experimental. Outside the 1.0 stability promise; it may change in any minor release (system-r-0117).

See the declaration and integration guide.

export type AudienceStatus = 'waiting' | 'live' | 'held' | 'ended' | 'stale' | 'reconnecting';

See the declaration and integration guide.

DEFAULT_READING_STRINGS: Readonly<ReadingStrings>

See the declaration and integration guide.

DEFAULT_STRINGS: Readonly<EvkStrings>

See the declaration and integration guide.

DEFAULT_SURFACE_STRINGS: Readonly<SurfaceStrings>

Native modal dialog for sheets/popovers; nonmodal region for desktop panels. No router/store. Focus returns without scrolling the originating result; the host controls open/back state. REQ: components-r-0035 REQ: system-r-0086

export declare function DetailContainer(props: DetailContainerProps): ReactElement | null;

See the declaration and integration guide.

export interface DetailContainerProps {
readonly open: boolean;
readonly title: string;
readonly children?: ReactNode;
readonly variant?: 'auto' | 'panel' | 'sheet' | 'popover';
readonly onClose: () => void;
readonly onBack?: (() => void) | undefined;
readonly focusKey?: string | undefined;
readonly fallbackFocus?: (() => HTMLElement | null) | undefined;
}

Structured source data only; no unsafe HTML path. REQ: components-r-0025 REQ: components-r-0036

export declare function DocumentResult(props: DocumentResultProps): ReactElement;

See the declaration and integration guide.

export interface DocumentResultProps extends EntityActions {
readonly document: ResultDocument;
readonly sourceRevision?: number | null | undefined;
readonly onOpenSource?: ((value: ResultDocument) => void) | undefined;
}

Original project-owned vector data shared by DOM and graph renderers. No font/network asset. REQ: core-r-0004 REQ: graph-r-0051 REQ: system-r-0085

ENTITY_GLYPH_PATHS: Readonly<Record<string, string>>

See the declaration and integration guide.

export interface EntityActions {
readonly registry: EntityRegistry;
readonly selectedEntityIds?: readonly EntityId[] | undefined;
readonly inspectedEntityId?: EntityId | null | undefined;
readonly onAddEntity?: ((id: EntityId) => void) | undefined;
readonly onInspectEntity?: ((id: EntityId) => void) | undefined;
}

See the declaration and integration guide.

export declare function EntityCard(props: EntityProfileProps): ReactElement;

See the declaration and integration guide.

export declare function EntityGlyph({ name, label, className }: EntityGlyphProps): ReactElement;

See the declaration and integration guide.

export interface EntityGlyphProps {
readonly name: string;
readonly label?: string;
readonly className?: string;
}

Standalone mention with explicit candidate actions. Passage uses the same action surface below its source text, keeping copied source text free of injected button labels. REQ: components-r-0026 REQ: components-r-0027 REQ: components-r-0029 REQ: components-r-0030

export declare function EntityMention(props: EntityMentionProps): ReactElement;

See the declaration and integration guide.

export interface EntityMentionProps extends EntityActions {
readonly mentionId: MentionId;
readonly entityIds: readonly EntityId[];
readonly text: string;
}

Images require an explicit local resource policy. No provider/default URL is fetched. Profiles receive data through the controller/host; they do not invent their own async cache. REQ: components-r-0031 REQ: components-r-0032 REQ: components-r-0036

export declare function EntityProfile(props: EntityProfileProps): ReactElement;

See the declaration and integration guide.

export interface EntityProfileProps extends EntityActions {
readonly entity: Entity | null;
readonly availability?: 'available' | 'unavailable' | 'withdrawn' | undefined;
readonly sourceUrl?: string | undefined;
readonly attribution?: string | undefined;
readonly onShowConnections?: ((id: EntityId) => void) | undefined;
readonly onOpenSource?: ((entity: Entity) => void) | undefined;
readonly allowImage?: ((url: string) => boolean) | undefined;
readonly compact?: boolean | undefined;
}

Controlled free-text input and separate semantic entity controls. The parent owns query state; ephemeral focus/popup/composition state never becomes a second query store. REQ: components-r-0014 REQ: components-r-0015 REQ: components-r-0016 REQ: components-r-0017 REQ: components-r-0018 REQ: components-r-0019 REQ: components-r-0024 REQ: system-r-0086 REQ: system-r-0087

export declare function EntityQueryInput(props: EntityQueryInputProps): ReactElement;

See the declaration and integration guide.

export interface EntityQueryInputProps {
readonly query: Query;
readonly registry: EntityRegistry;
readonly tagOrder?: readonly EntityId[];
readonly onAction: (action: Action) => void;
readonly onSubmit?: (() => void) | undefined;
readonly onCompositionChange?: ((composing: boolean) => void) | undefined;
readonly onInspect?: ((id: EntityId) => void) | undefined;
readonly inspectedId?: EntityId | undefined;
readonly suggestions?: readonly Recommendation[];
readonly suggestionPhase?: AsyncPhase;
readonly suggestionsStale?: boolean;
readonly maxSuggestions?: number;
readonly disabled?: boolean;
readonly inputRef?: Ref<HTMLInputElement>;
readonly label?: string;
readonly placeholder?: string;
}

Ready-made controls over the host-owned controller. The host explicitly calls start() and dispose(). Pass these same query.add/inspect actions from future mentions, graph vertices and page highlights. REQ: components-r-0014 REQ: components-r-0015 REQ: components-r-0019 REQ: components-r-0021 REQ: components-r-0022 REQ: components-r-0023

export declare function EntitySearchControls(props: EntitySearchControlsProps): ReactElement;

See the declaration and integration guide.

export interface EntitySearchControlsProps {
readonly controller: EntityController;
readonly showSummary?: boolean;
readonly canClearContext?: boolean;
readonly canInspect?: boolean;
readonly onInspect?: (entityId: EntityId) => void;
}

Visual identity plus explicit sibling controls. No nested buttons or click-to-toggle removal. Text remains escaped React children; custom renderers are local host code. REQ: core-r-0004 REQ: components-r-0014 REQ: components-r-0015 REQ: components-r-0018 REQ: components-r-0024 REQ: system-r-0088

export declare function EntityTag(props: EntityTagProps): ReactElement;

See the declaration and integration guide.

export interface EntityTagProps {
readonly entity: Entity;
readonly entityType?: EntityType | undefined;
readonly selected?: boolean;
readonly inspected?: boolean;
readonly unresolved?: boolean;
readonly disabled?: boolean;
readonly showDetail?: boolean;
readonly disambiguate?: boolean;
readonly actionLabel?: string;
readonly onActivate?: ((id: EntityId) => void) | undefined;
readonly onInspect?: ((id: EntityId) => void) | undefined;
readonly onRemove?: ((id: EntityId) => void) | undefined;
readonly primaryRef?: Ref<HTMLButtonElement> | undefined;
readonly removeRef?: Ref<HTMLButtonElement> | undefined;
readonly onRemoveKeyDown?: ((event: KeyboardEvent<HTMLButtonElement>) => void) | undefined;
}

A scoped, nestable design surface. No global styles, storage, network assets or state store. Labels/glyph hooks are local render functions, never serialized backend data. REQ: system-r-0085 REQ: system-r-0086 REQ: system-r-0087 REQ: system-r-0089

export declare function EntityVizProvider(props: EntityVizProviderProps): ReactElement;

See the declaration and integration guide.

export interface EntityVizProviderProps {
readonly children?: ReactNode;
readonly theme?: 'light' | 'dark' | 'auto';
readonly density?: 'comfortable' | 'compact';
readonly mode?: 'standard' | 'compact' | 'presentation';
readonly scale?: number;
readonly direction?: 'ltr' | 'rtl';
readonly locale?: string;
readonly strings?: Partial<EvkStrings>;
readonly readingStrings?: Partial<ReadingStrings>;
readonly surfaceStrings?: Partial<SurfaceStrings>;
readonly className?: string;
readonly style?: CSSProperties;
readonly typeLabel?: (type: EntityType) => string;
readonly renderGlyph?: (name: string) => ReactNode;
readonly renderLabel?: (entity: Entity) => ReactNode;
}

Original quotation remains visible even when current-source anchoring fails. REQ: core-r-0040 REQ: core-r-0042 REQ: components-r-0044 REQ: components-r-0045

export declare function EvidenceItem(props: EvidenceItemProps): ReactElement;

See the declaration and integration guide.

export interface EvidenceItemProps extends EntityActions {
readonly evidence: Evidence;
readonly source?: SourceDocument | null | undefined;
readonly onOpenSource?: ((evidence: Evidence) => void) | undefined;
readonly endpointIds?: readonly import('../../../../core/src/ts/index.ts').EntityId[] | undefined;
}

Rendering partitions overlaps, never resolves entity ambiguity, and retains native hyperlinks. Plain source spans remain selectable; entity actions are an adjacent keyboard-accessible chooser. REQ: components-r-0025 REQ: components-r-0026 REQ: components-r-0027 REQ: components-r-0028 REQ: components-r-0029 REQ: components-r-0030 REQ: components-r-0045

export declare function EvidencePassage(props: EvidencePassageProps): ReactElement;

See the declaration and integration guide.

export interface EvidencePassageProps extends EntityActions {
readonly snippet: Snippet;
readonly evidenceRanges?: readonly TextRange[] | undefined;
readonly endpointIds?: readonly EntityId[] | undefined;
readonly label?: string | undefined;
readonly sourceKey?: string | undefined;
readonly showNavigator?: boolean | undefined;
}

See the declaration and integration guide.

export interface EvkConfiguration {
readonly strings: Readonly<EvkStrings>;
readonly readingStrings: Readonly<ReadingStrings>;
readonly surfaceStrings: Readonly<SurfaceStrings>;
readonly direction: 'ltr' | 'rtl';
readonly typeLabel?: ((type: EntityType) => string) | undefined;
readonly renderGlyph?: ((name: string) => ReactNode) | undefined;
readonly renderLabel?: ((entity: Entity) => ReactNode) | undefined;
}

Localizable UI copy. Entity labels, type labels and supplied reasons remain host data. REQ: system-r-0087

export interface EvkStrings {
searchLabel: string;
placeholder: string;
selectedEntities: string;
suggestions: string;
recommendations: string;
search: string;
clearQuery: string;
clearContext: string;
contextLabel: string;
noContext: string;
noSelection: string;
freeText: string;
querySummary: string;
inputHelp: string;
noSuggestions: string;
noRecommendations: string;
loadingSuggestions: string;
initial: string;
searching: string;
updating: string;
empty: string;
failed: string;
unavailable: string;
partial: string;
disposed: string;
retry: string;
previousResults: string;
previousRecommendations: string;
retainedRecommendation: string;
selected: string;
inspected: string;
unknownType: string;
detailsUnavailable: string;
add: (name: string) => string;
inspect: (name: string) => string;
remove: (name: string) => string;
added: (name: string) => string;
removed: (name: string) => string;
alreadySelected: (name: string) => string;
selectionCount: (count: number) => string;
resultCount: (count: number) => string;
revision: (revision: number) => string;
suggestionsLimited: (shown: number, total: number) => string;
}

Controlled inspection content. Panels, routers and graph edges all reuse this same pair/evidence model.

export declare function InspectionContent(props: InspectionContentProps): ReactElement;

See the declaration and integration guide.

export interface InspectionContentProps {
readonly controller: EntityController;
readonly relations?: readonly PairRelation[] | undefined;
readonly onNavigate?: ((inspection: Inspection) => void) | undefined;
readonly onOpenEvidenceSource?: ((evidence: Evidence) => void) | undefined;
readonly sourceEvidence?: Evidence | undefined;
readonly evidencePair?: PairRelation | undefined;
readonly allowImage?: ((url: string) => boolean) | undefined;
readonly onShowConnections?: ((id: EntityId) => void) | undefined;
}

Optional ready-made reading navigation. Only bounded inspection IDs are kept in local history; actual records stay in the controller’s context-scoped latest-only resource slots. REQ: components-r-0033 REQ: components-r-0035 REQ: components-r-0045

export declare function InspectionPanel(props: InspectionPanelProps): ReactElement;

See the declaration and integration guide.

export interface InspectionPanelProps {
readonly controller: EntityController;
readonly relations?: readonly PairRelation[] | undefined;
readonly variant?: 'auto' | 'panel' | 'sheet' | 'popover' | undefined;
readonly fallbackFocus?: (() => HTMLElement | null) | undefined;
readonly allowImage?: ((url: string) => boolean) | undefined;
readonly onShowConnections?: ((id: EntityId) => void) | undefined;
}

Experimental. Outside the 1.0 stability promise; it may change in any minor release (system-r-0117).

Operator presentation controls. Private inspection never changes the audience by itself: only Publish sends, and only what was explicitly chosen. Reset returns the audience to an overview of the same query (presentation only; the query is untouched). REQ: integration-r-0077 REQ: integration-r-0078 REQ: system-r-0087

export declare function PresentationControls(props: PresentationControlsProps): ReactElement;

Experimental. Outside the 1.0 stability promise; it may change in any minor release (system-r-0117).

See the declaration and integration guide.

export interface PresentationControlsProps {
/** What the audience currently sees, and what the operator is privately inspecting. */
readonly presenting: Inspection;
readonly inspecting: Inspection;
readonly describe: (inspection: Inspection) => string;
readonly held: boolean;
readonly published: number | null;
readonly changedSincePublish: boolean;
readonly scale: number;
readonly pairing: string;
readonly audienceUrl?: string;
readonly onPresentSelection: () => void;
readonly onPublish: () => void;
readonly onHold: (held: boolean) => void;
readonly onReset: () => void;
readonly onScale: (scale: number) => void;
/** A problem to show the operator (for example a publish that could not be sent). */
readonly message?: string | null;
/** Offered when another operator window has taken over the audience. */
readonly onTakeOver?: () => void;
}

Explicit query intent and host context are separate, reusable presentation blocks. REQ: components-r-0023 REQ: system-r-0085 REQ: system-r-0089

export declare function QuerySummary({ state, registry, onClearContext, onClearQuery }: QuerySummaryProps): ReactElement;

See the declaration and integration guide.

export interface QuerySummaryProps {
readonly state: InteractionState;
readonly registry: EntityRegistry;
readonly onClearContext?: (() => void) | undefined;
readonly onClearQuery?: (() => void) | undefined;
}

Primary activation inspects only when a host supplies that capability. Removal is always separate.

export declare function QueryTag(props: QueryTagProps): ReactElement;

See the declaration and integration guide.

export interface QueryTagProps extends Omit<EntityTagProps, 'selected' | 'onActivate' | 'onRemove' | 'actionLabel'> {
readonly onRemove: (id: EntityId) => void;
}

Localizable reading/evidence UI; labels and claims remain host-provided data. REQ: system-r-0087

export interface ReadingStrings {
documents: string;
noTitle: string;
noSnippet: string;
invalidData: string;
unavailable: string;
withdrawn: string;
openSource: string;
previousPage: string;
nextPage: string;
loadMore: string;
close: string;
back: string;
actions: string;
entityCandidates: string;
passageEntities: string;
add: string;
inspect: string;
profile: string;
aliases: string;
properties: string;
showMore: string;
showLess: string;
connections: string;
loading: string;
failed: string;
retry: string;
noRelationship: string;
noEvidence: string;
relation: string;
originalQuote: string;
currentSource: string;
evidence: string;
supports: string;
contradicts: string;
uncertain: string;
exact: string;
reanchored: string;
ambiguous: string;
notLocated: string;
sourceUnavailable: string;
notLoaded: string;
sourceVersion: string;
selectedEvidence: string;
previousResults: string;
empty: string;
page: (page: number, pages: number) => string;
characters: (start: number, end: number, total: number) => string;
}

Recommendations are stable controls, not a constantly replaced list of links. A focused recommendation disappearing on refresh is retained until blur, visibly marked, but never carried across a context boundary. Mouse/touch/keyboard activation shares the same action. REQ: components-r-0014 REQ: components-r-0016 REQ: components-r-0021 REQ: components-r-0024 REQ: system-r-0086

export declare function RecommendedEntities(props: RecommendedEntitiesProps): ReactElement;

See the declaration and integration guide.

export interface RecommendedEntitiesProps {
readonly registry: EntityRegistry;
readonly recommendations: readonly Recommendation[];
readonly selectedIds: readonly EntityId[];
readonly onAdd: (entityId: EntityId) => void;
readonly onInspect?: ((entityId: EntityId) => void) | undefined;
readonly phase?: AsyncPhase;
readonly stale?: boolean;
readonly disabled?: boolean;
readonly contextKey?: string;
readonly onFocusFallback?: (() => void) | undefined;
readonly sourceRevision?: number | null;
readonly currentRevision?: number;
}

One pair, all directional assertions. Co-occurrence is not a predicate and missing evidence is distinct from a missing relation. Supporting/contrary/uncertain links are not collapsed. REQ: components-r-0043 REQ: components-r-0044 REQ: components-r-0046

export declare function RelationEvidencePanel(props: RelationEvidencePanelProps): ReactElement;

See the declaration and integration guide.

export interface RelationEvidencePanelProps extends EntityActions {
readonly relation: PairRelation | null;
readonly evidence?: readonly Evidence[] | undefined;
readonly onOpenEvidence?: ((id: EvidenceId) => void) | undefined;
readonly onOpenSource?: ((evidence: Evidence) => void) | undefined;
}

Semantic relation navigation remains available after the graph renderer is added.

export declare function RelationNavigator(props: RelationNavigatorProps): ReactElement;

See the declaration and integration guide.

export interface RelationNavigatorProps extends EntityActions {
readonly relations: readonly PairRelation[];
readonly onSelect: (id: PairId) => void;
}

Bounded pagination (maximum 100 passages/page). Selection never resets reading/page state. Controlled pages permit host-owned navigation. Paging moves focus to the result region without scrolling the source page. REQ: components-r-0025 REQ: components-r-0034 REQ: components-r-0035

export declare function SearchResults(props: SearchResultsProps): ReactElement;

See the declaration and integration guide.

export interface SearchResultsProps extends EntityActions {
readonly documents: readonly ResultDocument[];
readonly phase?: AsyncPhase | undefined;
readonly sourceRevision?: number | null | undefined;
readonly currentRevision?: number | undefined;
readonly contextKey?: string | undefined;
readonly pageSize?: number | undefined;
readonly page?: number | undefined;
readonly onPageChange?: ((page: number) => void) | undefined;
readonly onOpenSource?: ((value: ResultDocument) => void) | undefined;
readonly nextCursor?: string | null | undefined;
readonly onLoadMore?: ((cursor: string) => void) | undefined;
}

Old results remain actionable in the same context, explicitly attributed to their old revision. The core clears them on a context change. Retry always applies to current host intent. REQ: components-r-0021 REQ: components-r-0022

export declare function SearchStatus({ search, currentRevision, onRetry }: SearchStatusProps): ReactElement;

See the declaration and integration guide.

export interface SearchStatusProps {
readonly search: AsyncState<SearchResponse>;
readonly currentRevision: number;
readonly onRetry?: (() => void) | undefined;
}

Bounded current-source window. Current offsets are separate from original citation offsets. Ambiguous/unavailable anchors produce no authoritative target highlight. REQ: core-r-0038 REQ: core-r-0040 REQ: core-r-0041 REQ: core-r-0042 REQ: components-r-0045

export declare function SourceViewer(props: SourceViewerProps): ReactElement;

See the declaration and integration guide.

export interface SourceViewerProps extends EntityActions {
readonly source: SourceDocument;
readonly anchor?: TextAnchor | undefined;
readonly windowSize?: number | undefined;
}

Localizable copy for the workspace layout and the operator/audience presentation components. Entity labels, pane labels and presentation content remain host data. REQ: system-r-0087

export interface SurfaceStrings {
resizePanes: (primary: string, secondary: string) => string;
paneShare: (percent: number, primary: string) => string;
paneCollapsed: (secondary: string) => string;
showPane: (secondary: string) => string;
hidePane: (secondary: string) => string;
audienceDisplay: string;
presenting: string;
inspectingPrivately: string;
audience: string;
audienceHeld: string;
nothingPublished: string;
livePublication: (publication: number, unpublishedChanges: boolean) => string;
presentSelection: string;
publish: string;
hold: string;
releaseHold: string;
resetOverview: string;
heldNote: string;
takeOver: string;
audienceScale: string;
scaleValue: (scale: number) => string;
pairingCode: string;
openAudience: string;
statusWaiting: string;
statusLive: string;
statusHeld: string;
statusEnded: string;
statusStale: string;
statusReconnecting: string;
productName: string;
currentQuestion: string;
overview: string;
query: string;
connections: string;
presentedItem: string;
documents: string;
nothingYet: string;
}

Subscribe without creating/starting/disposing a host-owned controller. For SSR, the host owns a request-scoped controller and transfers the same initial state to hydration. REQ: core-r-0009 REQ: components-r-0019

export declare function useEntityController(controller: EntityController, serverSnapshot?: ControllerSnapshot): ControllerSnapshot;

See the declaration and integration guide.

export declare function useEvkConfiguration(): EvkConfiguration;

One integration point for fixed, keyed lazy slots. No independent per-card race implementation. REQ: components-r-0033 REQ: components-r-0036 REQ: components-r-0046

export declare function useInspectionLoader(controller: EntityController): void;

See the declaration and integration guide.

export declare function useRegistryRevision(registry: EntityRegistry): number;

Two-pane workspace with a keyboard-operable separator (arrows, Home/End, Enter to collapse), pointer resizing on the separator only, minimum sizes, and stacking on narrow containers (container width, not device detection). It stores nothing; hosts persist onLayoutChange only if they choose to. REQ: integration-r-0075 REQ: integration-r-0076 REQ: system-r-0087

export declare function WorkspaceLayout(props: WorkspaceLayoutProps): ReactElement;

See the declaration and integration guide.

export interface WorkspaceLayoutProps {
readonly primary: ReactNode;
readonly secondary: ReactNode;
readonly primaryLabel: string;
readonly secondaryLabel: string;
/** Controlled layout; omit for internal state. Layout never touches query or graph state. */
readonly layout?: WorkspaceLayoutState;
readonly defaultLayout?: WorkspaceLayoutState;
readonly onLayoutChange?: (layout: WorkspaceLayoutState) => void;
/** Minimum pane widths in CSS pixels, and the container width below which panes stack. */
readonly minPrimary?: number;
readonly minSecondary?: number;
readonly stackBelow?: number;
}

See the declaration and integration guide.

export interface WorkspaceLayoutState {
readonly ratio: number;
readonly secondaryOpen: boolean;
}