@fabrika/annotations 0.8.1 → 0.9.0-dev.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@fabrika/annotations",
-	"version": "0.8.1",
+	"version": "0.9.0-dev.2",
 	"type": "module",
 	"description": "React annotation state, text/block/region locators, editor and feedback surface.",
 	"license": "MIT",
@@ -16,28 +16,29 @@
 		"index.ts",
 		"src",
 		"!src/**/*.test.ts",
-		"!src/**/*.test.tsx"
+		"!src/**/*.test.tsx",
+		"types"
 	],
 	"exports": {
 		".": {
 			"bun": "./index.ts",
-			"types": "./index.ts",
+			"types": "./types/index.d.ts",
 			"default": "./index.ts"
 		},
 		"./runtime": {
 			"bun": "./src/runtime.ts",
-			"types": "./src/runtime.ts",
+			"types": "./types/src/runtime.d.ts",
 			"default": "./src/runtime.ts"
 		},
 		"./schemas": {
 			"bun": "./src/schemas.ts",
-			"types": "./src/schemas.ts",
+			"types": "./types/src/schemas.d.ts",
 			"default": "./src/schemas.ts"
 		},
 		"./styles.css": "./src/styles.css",
 		"./testing/dom.ts": {
 			"bun": "./src/testing/dom.ts",
-			"types": "./src/testing/dom.ts",
+			"types": "./types/src/testing/dom.d.ts",
 			"default": "./src/testing/dom.ts"
 		}
 	},

package/types/index.d.ts

@@ -0,0 +1,27 @@
+export { AnnotationCtx, AnnotationHostContext, SessionContext, useAnnotationHost, useAnnotations } from '@fabrika/annotations/runtime';
+export { extractContext, formatSnippetInContext } from './src/annotationContext';
+export { ANNOTATABLE_SELECTOR, ANNOTATION_TARGETS, BLOCK_SELECTOR, describeSnippet, findAnnotationElement, findSnippetElement, getBlockSnippet, restoreAnnotationTargets, } from './src/annotationDom';
+export { AnnotationDraftFooter } from './src/AnnotationDraftFooter';
+export type { AnnotationDraftFooterProps } from './src/AnnotationDraftFooter';
+export { AnnotationEditor, AttachButton, ImageThumbnails, imageToUrl } from './src/AnnotationEditor';
+export { AnnotationList } from './src/AnnotationList';
+export type { AnnotationListProps } from './src/AnnotationList';
+export { renderAnnotation } from './src/annotationMarkdown';
+export type { RenderableAnnotation } from './src/annotationMarkdown';
+export { AnnotationProvider } from './src/AnnotationProvider';
+export type { AnnotationProviderProps } from './src/AnnotationProvider';
+export { sealTarget } from './src/annotationTarget';
+export type { AnnotationTarget, SealedAnnotationTarget, TargetAnnotation } from './src/annotationTarget';
+export { blockTarget } from './src/blockTarget';
+export type { BlockLocator } from './src/blockTarget';
+export { renameMarkId, restoreMarks, setMarkActive, unwrapMarks, updateAllMarkStates, wrapRangeWithMark } from './src/highlightRange';
+export { AnnotationCreatePopover, AnnotationEditPopover, AnnotationPopover, Popover } from './src/Popover';
+export { createRegionOverlay, describeRegion, findRegionHost, isDrawableRegion, REGION_HOST_ATTR, REGION_UNITS, regionBetween, regionPointIn, regionStyle, regionTarget, } from './src/regionTarget';
+export type { RegionBox, RegionLocator, RegionPoint, RegionShape } from './src/regionTarget';
+export type { Annotation, AnnotationAttachment, AnnotationAuthor, AnnotationContext, AnnotationContextValue, AnnotationHost, AnnotationState, } from './src/runtime';
+export { textTarget } from './src/textTarget';
+export type { TextLocator } from './src/textTarget';
+export { useAnnotationState } from './src/useAnnotationState';
+export { useRegionAnnotation } from './src/useRegionAnnotation';
+export { useTextAnnotation } from './src/useTextAnnotation';
+export { autoResizeTextarea, fileAnnotationPath, generateAnnotationId, hostAcceptsUploads, RESPONSE_ANNOTATION_PATH } from './src/utils';

package/types/src/AnnotationDraftFooter.d.ts

@@ -0,0 +1,26 @@
+import type React from 'react';
+/**
+ * The foot of a draft: the note that belongs to no one annotation, and the
+ * action that sends the draft off.
+ *
+ * What counts as content, and what the payload looks like, is the host's —
+ * hence `hasContent` and a bare `onSubmit`. The two slots are where a host
+ * hangs whatever else its submit step needs (a preview button, a validation
+ * notice) without this component learning about it.
+ */
+export interface AnnotationDraftFooterProps {
+    /** Whether the draft says anything. Hosts count more than annotations and
+     *  the general note, so they decide. */
+    hasContent: boolean;
+    onSubmit: () => void;
+    /** Submitting an empty draft — an explicit "nothing to say", not a no-op. */
+    onSubmitEmpty: () => void;
+    /** Sits between the note and the actions: validation, status, a warning. */
+    notice?: React.ReactNode;
+    /** Sits left of the submit button, sharing the row. */
+    secondaryAction?: React.ReactNode;
+    placeholder?: string;
+    submitLabel?: string;
+    emptyLabel?: string;
+}
+export declare function AnnotationDraftFooter({ hasContent, onSubmit, onSubmitEmpty, notice, secondaryAction, placeholder, submitLabel, emptyLabel, }: AnnotationDraftFooterProps): React.JSX.Element;

package/types/src/AnnotationEditor.d.ts

@@ -0,0 +1,35 @@
+import React from 'react';
+interface AnnotationEditorProps {
+    note: string;
+    onNoteChange: (note: string) => void;
+    images: string[];
+    onAddImage: (path: string) => void;
+    onRemoveImage: (path: string) => void;
+    sessionId: string;
+    placeholder?: string;
+    autoFocus?: boolean;
+    autoResize?: boolean;
+    readOnly?: boolean;
+    onKeyDown?: (e: React.KeyboardEvent<HTMLTextAreaElement>) => void;
+    onTextareaClick?: (e: React.MouseEvent<HTMLTextAreaElement>) => void;
+    textareaRef?: React.MutableRefObject<HTMLTextAreaElement | null>;
+    textareaClassName?: string;
+    textareaStyle?: React.CSSProperties;
+    minHeight?: number;
+    /** "always" (default), "on-focus" (sidebar), or "none" (popover — use openFilePickerRef) */
+    attachButton?: 'always' | 'on-focus' | 'none';
+    /** Parent can store the open-file-picker function for external trigger */
+    openFilePickerRef?: React.MutableRefObject<(() => void) | null>;
+}
+export declare function imageToUrl(path: string): string;
+export declare function AnnotationEditor({ note, onNoteChange, images, onAddImage, onRemoveImage, sessionId, placeholder, autoFocus, autoResize, readOnly, onKeyDown, onTextareaClick, textareaRef: externalRef, textareaClassName, textareaStyle, minHeight, attachButton, openFilePickerRef, }: AnnotationEditorProps): React.JSX.Element;
+/** Small attach-image button — reusable in editor and popover button bar */
+export declare function AttachButton({ onClick, size }: {
+    onClick: () => void;
+    size?: number;
+}): React.JSX.Element;
+/** Read-only image thumbnails for display in read-only annotations */
+export declare function ImageThumbnails({ images }: {
+    images: string[];
+}): React.JSX.Element | null;
+export {};

package/types/src/AnnotationList.d.ts

@@ -0,0 +1,17 @@
+import type { Annotation } from './AnnotationProvider';
+export interface AnnotationListProps {
+    annotations: Annotation[];
+    /** Frozen view: notes read as text, nothing is deletable, and the list does
+     *  not chase the active card. */
+    readOnly?: boolean;
+    /** A card just became the active one — hosts reveal what it points at here. */
+    onSelect?: (ann: Annotation) => void;
+    /** Backs the reveal button. Omit it and no button is drawn. */
+    onReveal?: (ann: Annotation) => void;
+    /** Remote annotations ticked for submission. Pass both or neither — a host
+     *  with no notion of remote annotations passes neither and gets none of the
+     *  remote affordances. */
+    includedRemoteIds?: Set<string>;
+    onToggleRemoteId?: (id: string) => void;
+}
+export declare function AnnotationList({ annotations, readOnly, onSelect, onReveal, includedRemoteIds, onToggleRemoteId, }: AnnotationListProps): import("react").JSX.Element;

package/types/src/AnnotationProvider.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { Annotation, AnnotationState } from './runtime';
+export { useAnnotations } from '@fabrika/annotations/runtime';
+export type { Annotation, AnnotationContext, AnnotationContextValue, AnnotationState } from './runtime';
+export interface AnnotationProviderProps {
+    scope: string;
+    isReadOnly?: boolean;
+    remoteAnnotations?: Annotation[];
+    loadState: (scope: string) => Promise<AnnotationState | null>;
+    saveState: (scope: string, state: AnnotationState) => void;
+    children: React.ReactNode;
+}
+export declare function AnnotationProvider(props: AnnotationProviderProps): React.JSX.Element;

package/types/src/Popover.d.ts

@@ -0,0 +1,54 @@
+import React from 'react';
+interface PopoverProps {
+    anchorEl: HTMLElement;
+    scrollContainer?: HTMLElement | null;
+    onClose: () => void;
+    /** Selectors that should not trigger outside-click close */
+    ignoreSelector?: string;
+    zIndex?: string;
+    padding?: string;
+    width?: string;
+    children: React.ReactNode;
+}
+export declare function Popover({ anchorEl, scrollContainer, onClose, ignoreSelector, zIndex, padding, width, children }: PopoverProps): React.ReactPortal;
+interface AnnotationPopoverProps {
+    anchorEl: HTMLElement;
+    scrollContainer?: HTMLElement | null;
+    snippet: string;
+    /** Max length for displayed snippet (default 100) */
+    truncateAt?: number;
+    /** Custom header instead of the default quoted snippet */
+    header?: React.ReactNode;
+    /** Initial note text (for edit mode) */
+    initialNote?: string;
+    /** Initial images (for edit mode) */
+    initialImages?: string[];
+    /** Called on confirm — passes note and images */
+    onConfirm: (note: string, images: string[]) => void;
+    /** Called on cancel / close without saving */
+    onCancel: () => void;
+    /** Called when annotation should be deleted (edit mode) */
+    onDelete?: () => void;
+}
+export declare function AnnotationPopover({ anchorEl, scrollContainer, snippet, truncateAt, header, initialNote, initialImages, onConfirm, onCancel, onDelete, }: AnnotationPopoverProps): React.JSX.Element;
+interface AnnotationCreatePopoverProps {
+    anchorEl: HTMLElement;
+    scrollContainer?: HTMLElement | null;
+    snippet: string;
+    truncateAt?: number;
+    header?: React.ReactNode;
+    onAdd: (note: string, images?: string[]) => void;
+    onCancel: () => void;
+}
+export declare function AnnotationCreatePopover({ anchorEl, scrollContainer, snippet, truncateAt, header, onAdd, onCancel }: AnnotationCreatePopoverProps): React.JSX.Element;
+interface AnnotationEditPopoverProps {
+    anchorEl: HTMLElement;
+    scrollContainer?: HTMLElement | null;
+    initialNote: string;
+    initialImages?: string[];
+    onUpdate: (note: string, images: string[]) => void;
+    onDelete: () => void;
+    onClose: () => void;
+}
+export declare function AnnotationEditPopover({ anchorEl, scrollContainer, initialNote, initialImages, onUpdate, onDelete, onClose }: AnnotationEditPopoverProps): React.JSX.Element;
+export {};

package/types/src/annotationContext.d.ts

@@ -0,0 +1,15 @@
+import type { AnnotationContext } from './AnnotationProvider';
+/**
+ * Extract disambiguation context from a Range:
+ * - surrounding text (before/after the selection)
+ * - hierarchy path (Section title → Task label)
+ */
+export declare function extractContext(range: Range, planContainer: HTMLElement): AnnotationContext;
+/**
+ * Format a snippet with surrounding context for disambiguation.
+ * Short snippets get before/after context.
+ */
+export declare function formatSnippetInContext(ann: {
+    snippet: string;
+    context?: AnnotationContext;
+}): string;

package/types/src/annotationDom.d.ts

@@ -0,0 +1,8 @@
+import { type SealedAnnotationTarget, type TargetAnnotation } from './annotationTarget';
+import type { Annotation } from './runtime';
+export { ANNOTATABLE_SELECTOR, BLOCK_SELECTOR, getBlockSnippet } from './blockTarget';
+export declare const ANNOTATION_TARGETS: SealedAnnotationTarget[];
+export declare function findSnippetElement(snippet: string, root: ParentNode): HTMLElement | null;
+export declare function restoreAnnotationTargets(root: HTMLElement, annotations: readonly TargetAnnotation[]): void;
+export declare function describeSnippet(snippet: string): string;
+export declare function findAnnotationElement(annotation: Annotation, root?: ParentNode): HTMLElement | null;

package/types/src/annotationMarkdown.d.ts

@@ -0,0 +1,26 @@
+import type { AnnotationAttachment, AnnotationContext } from './runtime';
+/**
+ * What rendering one annotation reads off it. Every `Annotation` satisfies this,
+ * and so can a record that is not one: how a single annotation reads as markdown
+ * is the half of feedback that belongs to no particular document format.
+ */
+export interface RenderableAnnotation {
+    snippet: string;
+    note: string;
+    /** Set when the annotation points into a file. With `context.lineStart` it
+     *  switches the quote to numbered source lines. */
+    filePath?: string;
+    context?: AnnotationContext;
+    /** Attached images as bare paths/URLs — what the local editor writes. */
+    images?: string[];
+    /** Attached files carried on the wire — what a shared canvas sends back.
+     *  A host may populate either field; both are rendered. */
+    attachments?: AnnotationAttachment[];
+}
+/**
+ * One annotation as markdown: what was annotated, quoted, then the note and any
+ * attachments under it. Ends on a blank line so entries stack.
+ *
+ * The caller owns everything around it — headings, grouping, ordering.
+ */
+export declare function renderAnnotation(ann: RenderableAnnotation): string;

package/types/src/annotationTarget.d.ts

@@ -0,0 +1,54 @@
+/**
+ * How a snippet names something on the page.
+ *
+ * `Annotation.snippet` is the only field that ties an annotation to a domain —
+ * everything else (draft persistence, sidebar, popover, notes, attachments,
+ * markdown, submit) works on any annotation whatever it points at. A target is
+ * that one tie, pulled out as a strategy: give the kernel a new target and it
+ * can annotate a new kind of thing without another line changing.
+ */
+/** What a target may read off the annotation it resolves — DOM identity, not feedback. */
+export interface TargetAnnotation {
+    id: string;
+    snippet: string;
+    context?: {
+        before: string;
+        after: string;
+        hierarchy: string[];
+    };
+}
+export interface AnnotationTarget<L extends object> {
+    /** Names the strategy. */
+    readonly kind: string;
+    /** Read a snippet this target wrote. Null means the snippet is not its own. */
+    parse(snippet: string): L | null;
+    /** Write the locator back into the snippet key. The exact inverse of `parse`. */
+    format(locator: L): string;
+    /**
+     * The element the locator names, searched inside `root`. Targets whose
+     * annotation lives in DOM this target itself drew — an inline mark, an
+     * overlay box — return null here and are resolved by their annotation id
+     * instead; see findAnnotationElement.
+     */
+    find(locator: L, root: ParentNode): HTMLElement | null;
+    /**
+     * Put this annotation's own decoration back into `root`, if it is not there
+     * already. Called after every render, for every annotation, so it must be
+     * idempotent and cheap on a snippet it does not own.
+     */
+    restore?(locator: L, root: HTMLElement, ann: TargetAnnotation): void;
+    /** A one-line label a reader (or a coding agent) can act on. */
+    describe?(locator: L): string;
+}
+/** An AnnotationTarget with its locator type sealed inside, so targets whose
+ *  locators have nothing in common can share one list. */
+export interface SealedAnnotationTarget {
+    readonly kind: string;
+    owns(snippet: string): boolean;
+    find(snippet: string, root: ParentNode): HTMLElement | null;
+    restore(root: HTMLElement, ann: TargetAnnotation): void;
+    describe(snippet: string): string | null;
+}
+/** Close over the locator type, so parse and find can never be called with
+ *  a locator the other one did not produce. */
+export declare function sealTarget<L extends object>(target: AnnotationTarget<L>): SealedAnnotationTarget;

package/types/src/blockTarget.d.ts

@@ -0,0 +1,15 @@
+import type { AnnotationTarget } from './annotationTarget';
+/**
+ * The blocks that can carry a block annotation — a strict subset of
+ * BLOCK_SELECTOR, since interactive controls are navigable but not annotatable.
+ */
+export declare const ANNOTATABLE_SELECTOR: string;
+/** Every block the keyboard arrows walk through. */
+export declare const BLOCK_SELECTOR: string;
+/** The snippet identifier for a block, or null if nothing can be annotated here. */
+export declare function getBlockSnippet(block: HTMLElement): string | null;
+/** A block is its own locator: the snippet is the text that identifies it. */
+export interface BlockLocator {
+    snippet: string;
+}
+export declare const blockTarget: AnnotationTarget<BlockLocator>;

package/types/src/highlightRange.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Wraps the current browser Range in <mark> elements with the given annotation ID.
+ * Works for multiline / cross-element selections.
+ */
+export declare function wrapRangeWithMark(range: Range, annotationId: string): HTMLElement[];
+/**
+ * Whether the annotation index carries this text. Line-number gutters and text
+ * that already belongs to another annotation are outside it. Everything that
+ * records a snippet or its context is matched back against that index later, so
+ * all of them have to skip exactly the same runs.
+ */
+export declare function isIndexedText(node: Text): boolean;
+/**
+ * A selection's text as the annotation index will read it back. The raw
+ * selection is not that: it carries the gutter and any text already inside
+ * another annotation, none of which the index holds — so a snippet taken from
+ * it names something that cannot be found again.
+ */
+export declare function rangeIndexText(range: Range): string;
+/**
+ * Update the visual state of marks for a given annotation ID.
+ */
+export declare function setMarkActive(annotationId: string, active: boolean): void;
+/**
+ * Update active state for annotation marks.
+ * Only touches marks for the previous and current active IDs to avoid full DOM scans.
+ */
+export declare function updateAllMarkStates(activeId: string | null, prevActiveId?: string | null): void;
+/**
+ * Rename annotation ID on existing marks (e.g. temp → real ID).
+ */
+export declare function renameMarkId(oldId: string, newId: string): void;
+/**
+ * Restore marks for persisted annotations by finding their snippet text in the DOM.
+ * Uses before/after context for disambiguation when the same text appears multiple times.
+ */
+export declare function restoreMarks(container: HTMLElement, annotations: {
+    id: string;
+    snippet: string;
+    filePath?: string;
+    context?: {
+        before: string;
+        after: string;
+        hierarchy: string[];
+    };
+}[]): void;
+/**
+ * Remove the decoration for a given annotation ID, restoring the original text
+ * nodes an inline mark wrapped.
+ */
+export declare function unwrapMarks(annotationId: string): void;

package/types/src/popoverPosition.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Read a CSS width the popover will be styled with. Only px is a width this
+ * placement can reason about; anything else falls back to the default rather
+ * than clamping against a number that means something different.
+ */
+export declare function pxWidth(css: string): number | undefined;
+/**
+ * Calculate popover position relative to an anchor element.
+ * Returns absolute position within the scroll container (or body).
+ */
+export declare function getPopoverPosition(anchor: HTMLElement, scrollContainer?: HTMLElement | null, popoverWidth?: number): {
+    style: Record<string, string>;
+    parent: HTMLElement;
+};

package/types/src/regionTarget.d.ts

@@ -0,0 +1,61 @@
+import type { AnnotationTarget } from './annotationTarget';
+/**
+ * A rectangle or ellipse drawn inside an image block, so a reader can point at
+ * one corner of a screenshot instead of the whole picture.
+ *
+ * Coordinates are normalized against the image box, which is a uniform scale of
+ * the image's natural size — that is what lets a region survive a resize, a
+ * zoom or a different screen. They are stored on a fixed integer grid rather
+ * than as floats: a float printed into the snippet and read back is not
+ * guaranteed to be the same float, and a locator that shifts by one ulp names
+ * a region nobody drew.
+ */
+/** The grid a region snaps to: hundredths of a percent of the image box. */
+export declare const REGION_UNITS = 10000;
+export type RegionShape = 'rect' | 'ellipse';
+export interface RegionPoint {
+    x: number;
+    y: number;
+}
+/** Left, top, width and height, all in REGION_UNITS. */
+export interface RegionBox extends RegionPoint {
+    w: number;
+    h: number;
+}
+export interface RegionLocator extends RegionBox {
+    /** The image block the region sits in — the same `src` `[Image]` is keyed by. */
+    src: string;
+    shape: RegionShape;
+}
+/** Marks the element a region is measured against: the image's own box, not the
+ *  `<figure>`, which also holds the caption and would skew every percentage. */
+export declare const REGION_HOST_ATTR = "data-annotation-image";
+export declare function clampUnit(value: number): number;
+/** Where a pointer landed inside a box, on the region grid. Null for a box with
+ *  no extent — happy-dom and a not-yet-laid-out image both report zero. */
+export declare function regionPointIn(box: {
+    width: number;
+    height: number;
+}, offsetX: number, offsetY: number): RegionPoint | null;
+/** The box two drag corners span, kept inside the image. */
+export declare function regionBetween(a: RegionPoint, b: RegionPoint): RegionBox;
+export declare function isDrawableRegion(box: RegionBox): boolean;
+/** CSS geometry for the overlay. REGION_UNITS is percent × 100, so every value
+ *  the grid holds divides out exactly. */
+export declare function regionStyle(box: RegionBox): {
+    left: string;
+    top: string;
+    width: string;
+    height: string;
+};
+export declare function describeRegion(locator: RegionLocator): string;
+/** The image box a region belongs to. Compared attribute by attribute rather
+ *  than through a selector, because an image src is a path and may carry any
+ *  character a selector would have to escape. */
+export declare function findRegionHost(src: string, root: ParentNode): HTMLElement | null;
+export declare function applyRegionStyle(el: HTMLElement, box: RegionBox): void;
+/** The overlay box for one region. It carries `data-annotation-id`, so the
+ *  hover, active-state and delete plumbing that already drives inline marks
+ *  drives these too. */
+export declare function createRegionOverlay(box: RegionBox, shape: RegionShape, annotationId: string): HTMLElement;
+export declare const regionTarget: AnnotationTarget<RegionLocator>;

package/types/src/runtime.d.ts

@@ -0,0 +1,56 @@
+export interface AnnotationContext {
+    before: string;
+    after: string;
+    hierarchy: string[];
+    lineStart?: number;
+    lineEnd?: number;
+}
+export interface AnnotationAuthor {
+    id: string;
+    name: string;
+}
+export interface AnnotationAttachment {
+    url: string;
+    mime?: string;
+}
+export interface Annotation {
+    id: string;
+    snippet: string;
+    note: string;
+    createdAt: string;
+    filePath?: string;
+    canvasFile?: string;
+    context?: AnnotationContext;
+    images?: string[];
+    attachments?: AnnotationAttachment[];
+    source?: 'local' | 'remote';
+    author?: AnnotationAuthor;
+}
+export interface AnnotationState {
+    annotations: Annotation[];
+    generalNote: string;
+}
+export interface AnnotationContextValue extends AnnotationState {
+    addAnnotation: (snippet: string, note: string, filePath?: string) => void;
+    addAnnotationWithId: (id: string, snippet: string, note: string, filePath?: string, context?: AnnotationContext, images?: string[], canvasFile?: string) => void;
+    updateAnnotation: (id: string, note: string) => void;
+    removeAnnotation: (id: string) => void;
+    addAnnotationImage: (id: string, imagePath: string) => void;
+    removeAnnotationImage: (id: string, imagePath: string) => void;
+    setGeneralNote: (text: string) => void;
+    clearAll: () => void;
+    activeAnnotationId: string | null;
+    setActiveAnnotationId: (id: string | null) => void;
+    isReadOnly: boolean;
+}
+export interface AnnotationHost {
+    sessionId: string;
+    isShared: boolean;
+    fsAvailable: boolean;
+    uploadUrl: (() => string) | null;
+}
+export declare const AnnotationCtx: import("react").Context<AnnotationContextValue | null>;
+export declare const SessionContext: import("react").Context<string>;
+export declare const AnnotationHostContext: import("react").Context<AnnotationHost>;
+export declare function useAnnotations(): AnnotationContextValue;
+export declare function useAnnotationHost(): AnnotationHost;