@xnetjs/react 0.0.2 → 0.1.0

package/dist/experimental-B2FrBnkV.d.ts

@@ -0,0 +1,1584 @@
+import { PropertyBuilder, DefinedSchema, QueryAST, QueryASTPlannerGate, QueryASTAggregateExecution, InferCreateProps, TaskSchema, NodeState, NodeId, AuthGrant } from '@xnetjs/data';
+import { Q as QueryFilter, c as QueryListResult, F as FlatNode } from './useQuery-D7ajycrc.js';
+import { TimelineEntry, HistoryTarget, HistoricalState, PropertyDiff, UndoManagerOptions, AuditEntry, ActivitySummary, DiffResult, BlameInfo, VerificationOptions, VerificationResult } from '@xnetjs/history';
+import { DID, AuthAction, AuthTrace, AuthTraceStep } from '@xnetjs/core';
+import { SyncStatus, SyncManager, SyncProgress } from '@xnetjs/runtime';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Identity, KeyBundle, PQKeyRegistry, HybridKeyBundle } from '@xnetjs/identity';
+import * as react from 'react';
+import { ReactNode, JSX as JSX$1 } from 'react';
+import { SecurityLevel, UnifiedSignature, VerificationResult as VerificationResult$1 } from '@xnetjs/crypto';
+import { PluginRegistry, RegisteredPlugin, ViewContribution, CommandContribution, SlashCommandContribution, SidebarContribution, EditorContribution, PropertyHandlerContribution, BlockContribution, SettingContribution, ImporterContribution } from '@xnetjs/plugins';
+import './instrumentation-CpIuG2y5.js';
+import './telemetry-context-B7r6H1KW.js';
+
+interface TaskProjectionReferenceInput {
+    url: string;
+    provider: string | null;
+    kind: string | null;
+    refId: string | null;
+    title: string | null;
+    subtitle: string | null;
+    icon: string | null;
+    embedUrl: string | null;
+    metadata: string;
+}
+interface TaskProjectionInput {
+    taskId: string;
+    /** Surface-specific anchor (page block id or canvas object id) */
+    blockId: string;
+    title: string;
+    completed: boolean;
+    parentTaskId: string | null;
+    sortKey: string;
+    assignees: string[];
+    dueDate: string | null;
+    references: TaskProjectionReferenceInput[];
+}
+type TaskProjectionHost = 'page' | 'canvas';
+interface UseTaskProjectionSyncOptions {
+    /** Which Task relation property anchors tasks to this surface */
+    host: TaskProjectionHost;
+    /** The hosting node id (page id or canvas id); null disables sync */
+    hostId: string | null;
+    debounceMs?: number;
+}
+interface UseTaskProjectionSyncResult {
+    handleTasksChange: (tasks: TaskProjectionInput[]) => void;
+    syncing: boolean;
+    error: Error | null;
+}
+declare function useTaskProjectionSync({ host, hostId, debounceMs }: UseTaskProjectionSyncOptions): UseTaskProjectionSyncResult;
+
+/**
+ * usePageTaskSync - Reconcile page task rows with Task nodes.
+ *
+ * Checklist items inside page editors remain the inline editing surface, while
+ * Task nodes stay the canonical cross-surface records for querying and reuse.
+ * Thin wrapper over useTaskProjectionSync (host: 'page'); semantics in
+ * docs/specs/PAGE_TASK_RECONCILIATION.md.
+ */
+
+type PageTaskReferenceInput = TaskProjectionReferenceInput;
+type PageTaskInput = TaskProjectionInput;
+interface UsePageTaskSyncOptions {
+    pageId: string | null;
+    debounceMs?: number;
+}
+type UsePageTaskSyncResult = UseTaskProjectionSyncResult;
+declare function usePageTaskSync({ pageId, debounceMs }: UsePageTaskSyncOptions): UsePageTaskSyncResult;
+
+/**
+ * useFind - guarded AST query hook for advanced Node reads.
+ */
+
+type UseFindOptions<P extends Record<string, PropertyBuilder> = Record<string, PropertyBuilder>> = Pick<QueryFilter<P>, 'includeDeleted' | 'materializedView' | 'mode' | 'search' | 'source'>;
+type UseFindResult<P extends Record<string, PropertyBuilder>> = QueryListResult<P> & {
+    /** Canonical planner gate for the supplied AST. */
+    plannerGate: QueryASTPlannerGate;
+    /** Runtime blockers that prevented this hook from executing the AST. */
+    blockers: string[];
+    /** Whether the AST was compiled and subscribed through the current query runtime. */
+    canExecute: boolean;
+    /** Aggregate results computed over the loaded query snapshot. */
+    aggregates: QueryASTAggregateExecution | null;
+};
+declare function useFind<P extends Record<string, PropertyBuilder>>(schema: DefinedSchema<P>, ast: QueryAST, options?: UseFindOptions<P>): UseFindResult<P>;
+
+/**
+ * useTasks - Task-specific query helpers built on top of useQuery.
+ */
+
+type TaskNode = FlatNode<(typeof TaskSchema)['_properties']>;
+type TaskStatus = NonNullable<InferCreateProps<(typeof TaskSchema)['_properties']>['status']>;
+type UseTasksOptions = {
+    pageId?: string | null;
+    assigneeDid?: string | null;
+    includeCompleted?: boolean;
+    statuses?: TaskStatus[];
+    parentTaskId?: string | null;
+    dueDateFilter?: 'any' | 'overdue' | 'today' | 'next-7-days' | 'none';
+};
+type TaskTreeItem = {
+    task: TaskNode;
+    depth: number;
+    children: TaskTreeItem[];
+};
+type UseTasksResult = {
+    data: TaskNode[];
+    tree: TaskTreeItem[];
+    loading: boolean;
+    error: Error | null;
+    reload: () => void;
+};
+declare function useTasks({ pageId, assigneeDid, includeCompleted, statuses, parentTaskId, dueDateFilter }?: UseTasksOptions): UseTasksResult;
+
+interface UseCommentsOptions {
+    /** The Node ID to get comments for (any schema) */
+    nodeId: string;
+    /** Optional: filter to specific anchor type */
+    anchorType?: 'text' | 'cell' | 'row' | 'column' | 'canvas-position' | 'canvas-object' | 'node';
+}
+interface CommentThread {
+    /** The root comment (holds anchor data and resolved state) */
+    root: CommentNode;
+    /** Replies to this thread (sorted by Lamport time) */
+    replies: CommentNode[];
+}
+/** Flattened comment node for easier access */
+interface CommentNode {
+    id: string;
+    schemaId: string;
+    createdAt: number;
+    lamportTime: number;
+    wallTime: number;
+    properties: {
+        target: string;
+        targetSchema?: string;
+        inReplyTo?: string;
+        anchorType: string;
+        anchorData: string;
+        content: string;
+        attachments?: string[];
+        replyToUser?: string;
+        replyToCommentId?: string;
+        resolved: boolean;
+        resolvedBy?: string;
+        resolvedAt?: number;
+        edited: boolean;
+        editedAt?: number;
+        createdBy: string;
+    };
+}
+interface AddCommentOptions {
+    /** Comment content (GitHub-flavored markdown) */
+    content: string;
+    /** Type of anchor */
+    anchorType: 'text' | 'cell' | 'row' | 'column' | 'canvas-position' | 'canvas-object' | 'node';
+    /** JSON-encoded anchor data */
+    anchorData: string;
+    /** Schema IRI of the target Node (optimization) */
+    targetSchema?: string;
+}
+interface ReplyContext {
+    /** DID of user being replied to (for "replying to @user" UI) */
+    replyToUser?: string;
+    /** Comment ID being referenced (for "in reply to X" display) */
+    replyToCommentId?: string;
+}
+interface UseCommentsResult {
+    /** All comments on the target node */
+    comments: CommentNode[];
+    /** Comments grouped into threads (root + replies) */
+    threads: CommentThread[];
+    /** Total comment count */
+    count: number;
+    /** Count of unresolved threads */
+    unresolvedCount: number;
+    /** Whether loading */
+    loading: boolean;
+    /** Any error */
+    error: Error | null;
+    /** Add a new root comment */
+    addComment: (options: AddCommentOptions) => Promise<string | null>;
+    /** Reply to a thread */
+    replyTo: (rootCommentId: string, content: string, context?: ReplyContext) => Promise<string | null>;
+    /** Resolve a thread */
+    resolveThread: (rootCommentId: string) => Promise<void>;
+    /** Reopen a resolved thread */
+    reopenThread: (rootCommentId: string) => Promise<void>;
+    /** Delete a comment (soft delete) */
+    deleteComment: (commentId: string) => Promise<void>;
+    /** Delete an entire thread (root + all replies) */
+    deleteThread: (rootCommentId: string) => Promise<void>;
+    /** Edit a comment */
+    editComment: (commentId: string, content: string) => Promise<void>;
+    /** Reload comments */
+    reload: () => Promise<void>;
+}
+/**
+ * Universal hook for comments on any Node.
+ */
+declare function useComments({ nodeId, anchorType }: UseCommentsOptions): UseCommentsResult;
+
+/**
+ * Moderated comment hooks for public surfaces.
+ */
+
+type CommentVisibility = 'visible' | 'collapsed' | 'quarantined' | 'hidden';
+type PublicInteractionMode = 'open' | 'authenticated' | 'trusted' | 'reviewed' | 'closed';
+type PublicInteractionSurface = 'comment' | 'reply' | 'reaction' | 'quote' | 'mention' | 'communityNote' | 'message' | 'crawl' | 'index';
+type FirstContactMode = 'allow' | 'slow-mode' | 'quarantine' | 'review' | 'block';
+type PublicModerationMode = 'off' | 'label-only' | 'post-review' | 'pre-filter' | 'pre-review';
+interface ModerationLabelSummary {
+    id: string;
+    target: string;
+    value: string;
+    confidence: number;
+    sourceWeight: number;
+    sourceType?: string;
+    sourceDID?: string;
+    evidenceRefs?: string;
+    expiresAt?: number;
+    negates?: string;
+    createdAt: number;
+}
+interface PublicInteractionPolicySnapshot {
+    id: string;
+    target: string;
+    targetSchema?: string;
+    scope?: string;
+    commentMode: PublicInteractionMode;
+    replyMode: PublicInteractionMode;
+    reactionMode: PublicInteractionMode;
+    quoteMode: PublicInteractionMode;
+    mentionMode: PublicInteractionMode;
+    communityNoteMode: PublicInteractionMode;
+    messageMode: PublicInteractionMode;
+    crawlMode: PublicInteractionMode;
+    indexMode: PublicInteractionMode;
+    defaultVisibility: CommentVisibility;
+    firstContactMode: FirstContactMode;
+    moderationMode: PublicModerationMode;
+    slowModeSeconds?: number;
+    maxRootCommentsPerHour?: number;
+    maxRepliesPerHour?: number;
+    maxReactionsPerHour?: number;
+    maxMentionsPerComment?: number;
+    minimumAccountAgeHours?: number;
+    minimumReputation?: number;
+    trustThreshold?: number;
+    quarantineConfidenceThreshold?: number;
+    hideConfidenceThreshold?: number;
+    requiresVerifiedIdentity: boolean;
+    acceptsPolicySubscriptions: boolean;
+    policyLists: string[];
+    activeLabels: string[];
+    maintainers: string[];
+    moderators: string[];
+    policyPublishers: string[];
+    trustedDIDs: string[];
+    mutedDIDs: string[];
+    blockedDIDs: string[];
+    updatedAt: number;
+    createdAt: number;
+}
+interface ModeratedCommentNode {
+    comment: CommentNode;
+    visibility: CommentVisibility;
+    labels: ModerationLabelSummary[];
+    reasons: string[];
+    visible: boolean;
+}
+interface ModeratedCommentThread {
+    root: ModeratedCommentNode;
+    replies: ModeratedCommentNode[];
+    visibleReplies: ModeratedCommentNode[];
+    visible: boolean;
+    hiddenReplyCount: number;
+    collapsedReplyCount: number;
+    quarantinedReplyCount: number;
+}
+interface InteractionPermission {
+    allowed: boolean;
+    requiresReview: boolean;
+    mode: PublicInteractionMode;
+    reasons: string[];
+}
+interface ModerationFilterOptions {
+    hiddenLabels?: readonly string[];
+    collapsedLabels?: readonly string[];
+    includeCollapsed?: boolean;
+    includeQuarantined?: boolean;
+    includeHidden?: boolean;
+    minimumLabelConfidence?: number;
+}
+interface UseModeratedThreadOptions extends ModerationFilterOptions {
+    thread: CommentThread | null;
+    labelIndex?: ReadonlyMap<string, readonly ModerationLabelSummary[]>;
+    policy?: PublicInteractionPolicySnapshot | null;
+}
+interface UseVisibleCommentsOptions extends UseCommentsOptions, ModerationFilterOptions {
+    viewerDID?: string;
+    isAuthenticated?: boolean;
+    isVerified?: boolean;
+    policy?: PublicInteractionPolicySnapshot | null;
+}
+interface UseVisibleCommentsResult extends Omit<UseCommentsResult, 'comments' | 'threads' | 'count' | 'unresolvedCount' | 'addComment' | 'replyTo'> {
+    comments: CommentNode[];
+    threads: CommentThread[];
+    allComments: CommentNode[];
+    allThreads: CommentThread[];
+    moderatedThreads: ModeratedCommentThread[];
+    moderationByCommentId: ReadonlyMap<string, ModeratedCommentNode>;
+    moderationLabels: ModerationLabelSummary[];
+    policy: PublicInteractionPolicySnapshot | null;
+    policyLoading: boolean;
+    policyError: Error | null;
+    count: number;
+    unresolvedCount: number;
+    hiddenCount: number;
+    collapsedCount: number;
+    quarantinedCount: number;
+    canAddRootComment: InteractionPermission;
+    canReply: InteractionPermission;
+    addComment: (options: AddCommentOptions) => Promise<string | null>;
+    replyTo: (rootCommentId: string, content: string, context?: ReplyContext) => Promise<string | null>;
+}
+declare function summarizeModerationLabel(node: NodeState, now?: number): ModerationLabelSummary | null;
+declare function summarizePublicInteractionPolicy(node: NodeState): PublicInteractionPolicySnapshot | null;
+declare function selectActiveInteractionPolicy(policies: readonly PublicInteractionPolicySnapshot[]): PublicInteractionPolicySnapshot | null;
+declare function selectPublicInteractionMode(policy: PublicInteractionPolicySnapshot | null, surface: PublicInteractionSurface): PublicInteractionMode;
+declare function createModerationLabelIndex(labels: readonly ModerationLabelSummary[]): Map<string, ModerationLabelSummary[]>;
+declare function evaluateInteractionPermission(mode: PublicInteractionMode, policy: PublicInteractionPolicySnapshot | null, options?: {
+    viewerDID?: string;
+    isAuthenticated?: boolean;
+    isVerified?: boolean;
+}): InteractionPermission;
+declare function evaluateCommentModeration(comment: CommentNode, options?: {
+    labels?: readonly ModerationLabelSummary[];
+    policy?: PublicInteractionPolicySnapshot | null;
+} & ModerationFilterOptions): ModeratedCommentNode;
+declare function moderateThread(thread: CommentThread, options?: {
+    labelIndex?: ReadonlyMap<string, readonly ModerationLabelSummary[]>;
+    policy?: PublicInteractionPolicySnapshot | null;
+} & ModerationFilterOptions): ModeratedCommentThread;
+declare function useModeratedThread({ thread, labelIndex, policy, hiddenLabels, collapsedLabels, includeCollapsed, includeQuarantined, includeHidden, minimumLabelConfidence }: UseModeratedThreadOptions): ModeratedCommentThread | null;
+declare function useVisibleComments(options: UseVisibleCommentsOptions): UseVisibleCommentsResult;
+
+/**
+ * Policy-filtered counters for public reactions and replies.
+ */
+
+type ReactionType = 'like' | 'repost' | 'bookmark' | 'emoji';
+interface ReactionNode {
+    id: string;
+    target: string;
+    targetSchema?: string;
+    reactionType: ReactionType;
+    reactor: string;
+    emoji?: string;
+    annotation?: string;
+    createdAt: number;
+    createdBy: string;
+}
+interface ReactionCounterSnapshot {
+    likes: number;
+    reposts: number;
+    bookmarks: number;
+    emoji: number;
+    replies: number;
+    totalReactions: number;
+    total: number;
+}
+interface UsePolicyFilteredReactionCountersOptions extends ModerationFilterOptions {
+    nodeId: string;
+    targetSchema?: string;
+    viewerDID?: string;
+    isAuthenticated?: boolean;
+    isVerified?: boolean;
+    policy?: PublicInteractionPolicySnapshot | null;
+}
+interface AddReactionOptions {
+    reactionType: ReactionType;
+    emoji?: string;
+    annotation?: string;
+}
+interface UsePolicyFilteredReactionCountersResult {
+    reactions: ReactionNode[];
+    visibleReactions: ReactionNode[];
+    counts: ReactionCounterSnapshot;
+    rawCounts: ReactionCounterSnapshot;
+    hiddenReactionCount: number;
+    loading: boolean;
+    error: Error | null;
+    policy: PublicInteractionPolicySnapshot | null;
+    canReact: InteractionPermission;
+    canRepost: InteractionPermission;
+    addReaction: (options: AddReactionOptions) => Promise<string | null>;
+    removeReaction: (reactionId: string) => Promise<void>;
+    toggleReaction: (options: AddReactionOptions) => Promise<string | null>;
+    reload: () => Promise<void>;
+}
+declare function summarizeReactionNode(node: NodeState): ReactionNode | null;
+declare function isReactionVisible(reaction: ReactionNode, labels: readonly ModerationLabelSummary[], policy: PublicInteractionPolicySnapshot | null, options?: ModerationFilterOptions): boolean;
+declare function dedupeReactions(reactions: readonly ReactionNode[]): ReactionNode[];
+declare function createReactionCounterSnapshot(reactions: readonly ReactionNode[], replies: number): ReactionCounterSnapshot;
+declare function usePolicyFilteredReactionCounters({ nodeId, targetSchema, viewerDID, isAuthenticated, isVerified, policy: providedPolicy, hiddenLabels, collapsedLabels, includeCollapsed, includeQuarantined, includeHidden, minimumLabelConfidence }: UsePolicyFilteredReactionCountersOptions): UsePolicyFilteredReactionCountersResult;
+
+/**
+ * Message request and first-contact quarantine helpers.
+ */
+
+type MessageRequestStatus = 'pending' | 'accepted' | 'declined' | 'quarantined' | 'blocked' | 'expired';
+type FirstContactAdmission = 'allow' | 'message-request' | 'quarantine' | 'review' | 'block';
+type FirstContactVisibility = 'inbox' | 'requests' | 'quarantine' | 'hidden';
+type MessageRequestNode = {
+    id: string;
+    conversationKey: string;
+    sender: string;
+    recipient: string;
+    target?: string;
+    targetSchema?: string;
+    firstMessageRef?: string;
+    firstMessagePreview?: string;
+    status: MessageRequestStatus;
+    admission: FirstContactAdmission;
+    reasonCodes: string[];
+    confidence?: number;
+    policy?: string;
+    policyMode?: FirstContactMode;
+    quarantineUntil?: number;
+    expiresAt?: number;
+    respondedAt?: number;
+    respondedBy?: string;
+    reviewers: string[];
+    notes?: string;
+    createdAt: number;
+    createdBy: string;
+};
+type FirstContactDecisionInput = {
+    senderDID?: string;
+    recipientDID?: string;
+    policy?: PublicInteractionPolicySnapshot | null;
+    existingRequests?: readonly MessageRequestNode[];
+    isAuthenticated?: boolean;
+    isVerified?: boolean;
+    now?: number;
+};
+type FirstContactDecision = {
+    admission: FirstContactAdmission;
+    status: MessageRequestStatus;
+    visibility: FirstContactVisibility;
+    notifyRecipient: boolean;
+    requiresReview: boolean;
+    shouldCreateRequest: boolean;
+    reasons: string[];
+    reasonCodes: string[];
+    confidence: number;
+    quarantineUntil?: number;
+};
+type CreateMessageRequestOptions = {
+    senderDID: string;
+    recipientDID: string;
+    target?: string;
+    targetSchema?: string;
+    firstMessageRef?: string;
+    firstMessagePreview?: string;
+    expiresAt?: number;
+    reviewers?: readonly string[];
+    notes?: string;
+};
+type MessageRequestProperties = {
+    conversationKey: string;
+    sender: string;
+    recipient: string;
+    target?: string;
+    targetSchema?: string;
+    firstMessageRef?: string;
+    firstMessagePreview?: string;
+    status: MessageRequestStatus;
+    admission: FirstContactAdmission;
+    reasonCodes: string[];
+    confidence: number;
+    policy?: string;
+    policyMode?: FirstContactMode;
+    quarantineUntil?: number;
+    expiresAt?: number;
+    reviewers: string[];
+    notes?: string;
+};
+type UseMessageRequestsOptions = {
+    recipientDID?: string;
+    senderDID?: string;
+    policy?: PublicInteractionPolicySnapshot | null;
+    isAuthenticated?: boolean;
+    isVerified?: boolean;
+    includeResolved?: boolean;
+};
+type UseMessageRequestsResult = {
+    requests: MessageRequestNode[];
+    pendingRequests: MessageRequestNode[];
+    quarantinedRequests: MessageRequestNode[];
+    acceptedRequests: MessageRequestNode[];
+    blockedRequests: MessageRequestNode[];
+    loading: boolean;
+    error: Error | null;
+    evaluateFirstContact: (input: FirstContactDecisionInput) => FirstContactDecision;
+    createMessageRequest: (options: CreateMessageRequestOptions) => Promise<string | null>;
+    acceptRequest: (requestId: string, responderDID?: string) => Promise<void>;
+    declineRequest: (requestId: string, responderDID?: string) => Promise<void>;
+    quarantineRequest: (requestId: string, responderDID?: string) => Promise<void>;
+    blockRequest: (requestId: string, responderDID?: string) => Promise<void>;
+    reload: () => Promise<void>;
+};
+declare function createConversationKey(senderDID: string, recipientDID: string): string;
+declare function summarizeMessageRequest(node: NodeState, now?: number): MessageRequestNode | null;
+declare function findLatestMessageRequest(requests: readonly MessageRequestNode[], senderDID: string, recipientDID: string): MessageRequestNode | null;
+declare function hasAcceptedContact(requests: readonly MessageRequestNode[], senderDID: string, recipientDID: string): boolean;
+declare function evaluateFirstContactDecision({ senderDID, recipientDID, policy, existingRequests, isAuthenticated, isVerified, now }: FirstContactDecisionInput): FirstContactDecision;
+declare function createMessageRequestProperties(options: CreateMessageRequestOptions, decision: FirstContactDecision, policy?: PublicInteractionPolicySnapshot | null): MessageRequestProperties;
+declare function useMessageRequests({ recipientDID, senderDID, policy, isAuthenticated, isVerified, includeResolved }?: UseMessageRequestsOptions): UseMessageRequestsResult;
+
+/**
+ * Get the unresolved comment count for a Node.
+ *
+ * @param nodeId - The Node ID to get comment count for
+ * @returns The number of unresolved comment threads
+ */
+declare function useCommentCount(nodeId: string): number;
+/**
+ * Get detailed comment counts for a Node.
+ *
+ * @param nodeId - The Node ID to get comment counts for
+ * @returns Object with total and unresolved counts
+ */
+declare function useCommentCounts(nodeId: string): {
+    total: number;
+    unresolved: number;
+    resolved: number;
+};
+
+/**
+ * useHistory - React hook for node history / time travel
+ *
+ * Provides point-in-time reconstruction, timeline browsing,
+ * and state materialization for a node.
+ *
+ * @example
+ * ```tsx
+ * const { timeline, materializeAt, diff, changeCount, loading } = useHistory(nodeId)
+ *
+ * // Get timeline
+ * const entries = timeline
+ *
+ * // Materialize at a specific point
+ * const historical = await materializeAt({ type: 'index', index: 5 })
+ *
+ * // Diff two points
+ * const diffs = await diff({ type: 'index', index: 0 }, { type: 'latest' })
+ * ```
+ */
+
+interface UseHistoryResult {
+    /** Full timeline of changes for the node */
+    timeline: TimelineEntry[];
+    /** Total number of changes */
+    changeCount: number;
+    /** Reconstruct node state at a target point */
+    materializeAt: (target: HistoryTarget) => Promise<HistoricalState | null>;
+    /** Diff between two points */
+    diff: (from: HistoryTarget, to: HistoryTarget) => Promise<PropertyDiff[]>;
+    /** Create a revert payload to restore to a historical point */
+    createRevertPayload: (target: HistoryTarget) => Promise<Record<string, unknown> | null>;
+    /** Whether the timeline is loading */
+    loading: boolean;
+    /** Any error */
+    error: Error | null;
+    /** Reload the timeline */
+    reload: () => Promise<void>;
+}
+declare function useHistory(nodeId: NodeId | null): UseHistoryResult;
+
+/**
+ * useUndo - React hook for per-node undo/redo
+ *
+ * Wraps UndoManager to provide undo/redo actions, stack depth,
+ * and canUndo/canRedo state for a given node.
+ *
+ * @example
+ * ```tsx
+ * const { undo, redo, canUndo, canRedo, undoCount, redoCount } = useUndo(nodeId)
+ *
+ * // Wire to keyboard shortcuts
+ * <button onClick={undo} disabled={!canUndo}>Undo</button>
+ * <button onClick={redo} disabled={!canRedo}>Redo</button>
+ * ```
+ */
+
+interface UseUndoOptions {
+    /** The local user's DID (required for undo to work) */
+    localDID: DID | null;
+    /** UndoManager configuration overrides */
+    options?: Partial<UndoManagerOptions>;
+}
+interface UseUndoResult {
+    /** Undo the last change for this node */
+    undo: () => Promise<boolean>;
+    /** Redo the last undone change for this node */
+    redo: () => Promise<boolean>;
+    /** Undo all changes in a batch */
+    undoBatch: (batchId: string) => Promise<boolean>;
+    /** Whether undo is available */
+    canUndo: boolean;
+    /** Whether redo is available */
+    canRedo: boolean;
+    /** Number of undo entries */
+    undoCount: number;
+    /** Number of redo entries */
+    redoCount: number;
+    /** Clear undo/redo stacks for this node */
+    clear: () => void;
+}
+declare function useUndo(nodeId: NodeId | null, opts: UseUndoOptions): UseUndoResult;
+
+/**
+ * useAudit - React hook for querying the audit log
+ *
+ * Provides paginated, filterable access to change audit entries
+ * and activity summaries for nodes.
+ *
+ * @example
+ * ```tsx
+ * const { entries, activity, loading } = useAudit(nodeId)
+ * const { entries: filtered } = useAudit(nodeId, { operations: ['create', 'delete'] })
+ * ```
+ */
+
+interface UseAuditOptions {
+    /** Filter by operations */
+    operations?: ('create' | 'update' | 'delete' | 'restore')[];
+    /** Filter by author DID */
+    author?: string;
+    /** Time range filter [from, to] in wall clock ms */
+    timeRange?: [number, number];
+    /** Max entries to return */
+    limit?: number;
+    /** Sort order */
+    order?: 'asc' | 'desc';
+}
+interface UseAuditResult {
+    /** Audit entries matching the query */
+    entries: AuditEntry[];
+    /** Activity summary for the node */
+    activity: ActivitySummary | null;
+    /** Whether loading */
+    loading: boolean;
+    /** Any error */
+    error: Error | null;
+    /** Reload audit data */
+    reload: () => Promise<void>;
+}
+declare function useAudit(nodeId: NodeId | null, options?: UseAuditOptions): UseAuditResult;
+
+/**
+ * useDiff - React hook for comparing node state between two points
+ *
+ * Wraps DiffEngine to provide on-demand diffs between any two
+ * HistoryTarget points.
+ *
+ * @example
+ * ```tsx
+ * const { diff, result, loading } = useDiff(nodeId)
+ *
+ * // Compare creation to latest
+ * await diff({ type: 'index', index: 0 }, { type: 'latest' })
+ *
+ * // Show result
+ * result?.diffs.forEach(d => console.log(d.property, d.type))
+ * ```
+ */
+
+interface UseDiffResult {
+    /** Compute diff between two points */
+    diff: (from: HistoryTarget, to: HistoryTarget) => Promise<void>;
+    /** Diff N changes back from current */
+    diffFromCurrent: (changesAgo: number) => Promise<void>;
+    /** Latest diff result */
+    result: DiffResult | null;
+    /** Whether diffing */
+    loading: boolean;
+    /** Any error */
+    error: Error | null;
+}
+declare function useDiff(nodeId: NodeId | null): UseDiffResult;
+
+/**
+ * useBlame - React hook for per-property attribution
+ *
+ * Shows who last changed each property, how many times,
+ * and the full edit history.
+ *
+ * @example
+ * ```tsx
+ * const { blame, loading, reload } = useBlame(nodeId)
+ *
+ * blame.forEach(b => {
+ *   console.log(`${b.property}: last changed by ${b.lastChangedBy}, ${b.totalEdits} edits`)
+ * })
+ * ```
+ */
+
+interface UseBlameResult {
+    /** Blame info for all properties */
+    blame: BlameInfo[];
+    /** Whether loading */
+    loading: boolean;
+    /** Any error */
+    error: Error | null;
+    /** Reload blame data */
+    reload: () => Promise<void>;
+}
+declare function useBlame(nodeId: NodeId | null): UseBlameResult;
+
+/**
+ * useVerification - React hook for cryptographic chain verification
+ *
+ * Runs verification on a node's change history and reports
+ * validity, errors, and statistics.
+ *
+ * @example
+ * ```tsx
+ * const { verify, result, loading } = useVerification(nodeId)
+ *
+ * await verify()
+ * if (result?.valid) {
+ *   console.log('Chain is valid!', result.stats)
+ * } else {
+ *   console.log('Errors:', result?.errors)
+ * }
+ * ```
+ */
+
+interface UseVerificationResult {
+    /** Run full verification */
+    verify: (options?: VerificationOptions) => Promise<void>;
+    /** Run quick check (hash + chain only) */
+    quickCheck: () => Promise<{
+        valid: boolean;
+        errors: number;
+    } | null>;
+    /** Latest verification result */
+    result: VerificationResult | null;
+    /** Whether verification is running */
+    loading: boolean;
+    /** Verification progress (0-1) */
+    progress: number;
+    /** Any error */
+    error: Error | null;
+}
+declare function useVerification(nodeId: NodeId | null): UseVerificationResult;
+
+/**
+ * useHubStatus - Access hub connection status from context.
+ */
+
+declare function useHubStatus(): SyncStatus;
+
+/**
+ * useCan - Check current user's permissions for a node.
+ */
+interface UseCanResult {
+    canRead: boolean;
+    canWrite: boolean;
+    canDelete: boolean;
+    canShare: boolean;
+    loading: boolean;
+    error: Error | null;
+    isFresh: boolean;
+    evaluatedAt: number;
+}
+declare function useCan(nodeId: string): UseCanResult;
+
+/**
+ * useCanEdit - Resolve editor/viewer capabilities for a node.
+ */
+type UseCanEditResult = {
+    canEdit: boolean;
+    canView: boolean;
+    loading: boolean;
+    error: Error | null;
+    roles: string[];
+};
+declare function useCanEdit(nodeId: string): UseCanEditResult;
+
+/**
+ * useGrants - Read and mutate grants for a node.
+ */
+
+interface GrantInput {
+    to: DID;
+    actions: AuthAction[];
+    resource?: string;
+    expiresIn?: string | number;
+    parentGrantId?: string;
+}
+interface UseGrantsResult {
+    grants: AuthGrant[];
+    loading: boolean;
+    error: Error | null;
+    grant: (input: GrantInput) => Promise<AuthGrant>;
+    revoke: (grantId: string) => Promise<void>;
+}
+type GrantConsentSummary = {
+    grantee: DID;
+    resource: string;
+    actions: AuthAction[];
+    expiresAt: number;
+    what: string;
+    where: string;
+    howLong: string;
+};
+declare function describeGrantConsent(input: GrantInput, defaultResource: string, now?: number): GrantConsentSummary;
+declare function useGrants(nodeId: string): UseGrantsResult;
+
+/**
+ * useAuthTrace - Surface store.auth.explain traces for auth UX and debugging.
+ */
+
+type AuthTraceSummary = {
+    allowed: boolean;
+    action: AuthAction;
+    resource: string;
+    roles: string[];
+    grants: string[];
+    reasons: string[];
+    evaluatedAt: number;
+    duration: number;
+    steps: AuthTraceStep[];
+};
+type UseAuthTraceResult = {
+    trace: AuthTrace | null;
+    summary: AuthTraceSummary | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+};
+type UseAuthTraceOptions = {
+    nodeId: string;
+    action: AuthAction;
+    enabled?: boolean;
+};
+declare function summarizeAuthTrace(trace: AuthTrace): AuthTraceSummary;
+declare function useAuthTrace({ nodeId, action, enabled }: UseAuthTraceOptions): UseAuthTraceResult;
+
+interface UseBackupReturn {
+    upload: (docId: string, plaintext: Uint8Array) => Promise<void>;
+    download: (docId: string) => Promise<Uint8Array | null>;
+    uploading: boolean;
+}
+declare function useBackup(): UseBackupReturn;
+
+interface FileRef {
+    cid: string;
+    name: string;
+    mimeType: string;
+    size: number;
+}
+interface UseFileUploadReturn {
+    upload: (file: File) => Promise<FileRef>;
+    uploading: boolean;
+    progress: number;
+}
+declare function useFileUpload(): UseFileUploadReturn;
+
+interface HubSearchOptions {
+    schemaIri?: string;
+    limit?: number;
+    offset?: number;
+}
+interface HubSearchResult {
+    docId: string;
+    title: string;
+    schemaIri: string;
+    snippet: string;
+    rank: number;
+}
+interface HubSearchState {
+    search: (query: string, options?: HubSearchOptions) => Promise<HubSearchResult[]>;
+    results: HubSearchResult[];
+    loading: boolean;
+    error: Error | null;
+}
+declare function useHubSearch(): HubSearchState;
+
+/**
+ * useRemoteSchema - Hub schema registry fetch hook.
+ */
+interface RemoteSchemaDefinition {
+    iri: string;
+    version: number;
+    name: string;
+    description: string;
+    definition: Record<string, unknown>;
+    authorDid: string;
+    propertiesCount: number;
+    createdAt: number;
+}
+interface RemoteSchemaState {
+    schema: RemoteSchemaDefinition | null;
+    loading: boolean;
+    error: Error | null;
+}
+declare const useRemoteSchema: (iri: string | undefined) => RemoteSchemaState;
+
+/**
+ * usePeerDiscovery - hub peer discovery hook.
+ */
+interface DiscoveredPeer {
+    did: string;
+    displayName?: string;
+    endpoints: Array<{
+        type: string;
+        address: string;
+        priority?: number;
+    }>;
+    lastSeen: number;
+    isOnline: boolean;
+}
+declare const usePeerDiscovery: () => {
+    peers: DiscoveredPeer[];
+    resolve: (did: string) => Promise<DiscoveredPeer | null>;
+    refresh: () => Promise<void>;
+    loading: boolean;
+};
+
+declare function HubStatusIndicator(): JSX.Element;
+
+/**
+ * Skeleton loading placeholder.
+ *
+ * Shows a pulsing placeholder while content is loading. Supports
+ * different shapes (text lines, circles, rectangles).
+ */
+type SkeletonProps = {
+    /** Width (CSS value). Default: '100%'. */
+    width?: string | number;
+    /** Height (CSS value). Default: '1em'. */
+    height?: string | number;
+    /** Border radius. Use '50%' for circles. Default: '4px'. */
+    borderRadius?: string | number;
+    /** Additional inline styles. */
+    style?: React.CSSProperties;
+    /** Number of lines to render. Default: 1. */
+    lines?: number;
+    /** Gap between lines. Default: '0.5rem'. */
+    gap?: string;
+};
+declare function Skeleton({ width, height, borderRadius, style, lines, gap }: SkeletonProps): JSX.Element;
+/**
+ * Inject the skeleton keyframes into the document head.
+ * Call once at app startup, or include the CSS in your stylesheet:
+ *
+ * ```css
+ * @keyframes xnet-skeleton-pulse {
+ *   0% { background-position: 200% 0; }
+ *   100% { background-position: -200% 0; }
+ * }
+ * ```
+ */
+declare function injectSkeletonStyles(): void;
+
+interface DemoBannerProps {
+    /** How many hours until demo data expires */
+    evictionHours: number;
+    /** Called when banner is dismissed */
+    onDismiss?: () => void;
+}
+/**
+ * DemoBanner component
+ *
+ * @example
+ * ```tsx
+ * <DemoBanner evictionHours={24} />
+ * ```
+ */
+declare function DemoBanner({ evictionHours, onDismiss }: DemoBannerProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * DemoQuotaIndicator - Shows storage quota usage for demo mode
+ *
+ * Displays a progress bar with bytes used / limit.
+ * Colors change at warning (80%) and critical (95%) thresholds.
+ */
+interface DemoQuotaIndicatorProps {
+    /** Bytes currently used */
+    usedBytes: number;
+    /** Total quota limit in bytes */
+    limitBytes: number;
+}
+/**
+ * DemoQuotaIndicator component
+ *
+ * @example
+ * ```tsx
+ * <DemoQuotaIndicator usedBytes={5242880} limitBytes={10485760} />
+ * ```
+ */
+declare function DemoQuotaIndicator({ usedBytes, limitBytes }: DemoQuotaIndicatorProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * DemoDataExpiredScreen - Full-screen message when demo data is evicted
+ *
+ * Shown when the user's demo data has been cleaned up after inactivity.
+ * Provides options to start fresh or download the desktop app.
+ */
+/**
+ * DemoDataExpiredScreen component
+ *
+ * @example
+ * ```tsx
+ * if (dataExpired) {
+ *   return <DemoDataExpiredScreen />
+ * }
+ * ```
+ */
+declare function DemoDataExpiredScreen(): react_jsx_runtime.JSX.Element;
+
+/**
+ * Demo mode limits (from hub handshake)
+ */
+interface DemoLimits {
+    /** Storage quota in bytes */
+    quotaBytes: number;
+    /** Maximum number of documents */
+    maxDocs: number;
+    /** Eviction time in hours */
+    evictionHours: number;
+}
+/**
+ * Demo mode usage stats (future: populated from hub)
+ */
+interface DemoUsage {
+    /** Bytes currently used */
+    usedBytes: number;
+    /** Number of documents */
+    docCount: number;
+}
+/**
+ * Demo mode state
+ */
+interface DemoModeState {
+    /** Whether connected to a demo hub */
+    isDemo: boolean;
+    /** Demo mode limits (if in demo mode) */
+    limits?: DemoLimits;
+    /** Current usage (if in demo mode and available) */
+    usage?: DemoUsage;
+}
+/**
+ * Hook to detect and track demo mode from hub connection
+ *
+ * Listens for the handshake message from the hub which includes `isDemo`
+ * and `demoLimits` fields when connected to a demo hub.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const { isDemo, limits } = useDemoMode()
+ *
+ *   return (
+ *     <div>
+ *       {isDemo && limits && (
+ *         <DemoBanner evictionHours={limits.evictionHours} />
+ *       )}
+ *       <MainContent />
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useDemoMode(): DemoModeState;
+
+/**
+ * useSyncManager - Access the Background Sync Manager from context
+ *
+ * Returns null if SyncManager is not available (disabled, not initialized,
+ * or when running outside XNetProvider).
+ */
+
+declare function useSyncManager(): SyncManager | null;
+
+/**
+ * @xnetjs/react/onboarding - State machine for the onboarding flow
+ *
+ * States:
+ *   welcome → authenticating → connecting-hub → ready → complete
+ *                ↓                                ↑
+ *            auth-error ──────── (retry) ────────┘
+ *   welcome → unsupported-browser (terminal)
+ *   welcome → import-identity → qr-scan/recovery-phrase → connecting-hub
+ */
+
+type OnboardingState = 'welcome' | 'authenticating' | 'auth-error' | 'unsupported-browser' | 'import-identity' | 'qr-scan' | 'recovery-phrase' | 'guardian-recovery' | 'creating-recoverable' | 'show-recovery-phrase' | 'connecting-hub' | 'ready' | 'complete';
+type OnboardingEvent = {
+    type: 'AUTHENTICATE';
+} | {
+    type: 'CREATE_NEW';
+} | {
+    type: 'IMPORT_EXISTING';
+} | {
+    type: 'PASSKEY_SUCCESS';
+    identity: Identity;
+    keyBundle: KeyBundle;
+} | {
+    type: 'PASSKEY_FAILED';
+    error: Error;
+} | {
+    type: 'BROWSER_UNSUPPORTED';
+} | {
+    type: 'RETRY_AUTH';
+} | {
+    type: 'BACK_TO_WELCOME';
+} | {
+    type: 'SCAN_QR';
+} | {
+    type: 'ENTER_PHRASE';
+} | {
+    type: 'IDENTITY_IMPORTED';
+    identity: Identity;
+    keyBundle: KeyBundle;
+} | {
+    type: 'HUB_CONNECTED';
+} | {
+    type: 'HUB_FAILED';
+    error: Error;
+} | {
+    type: 'CREATE_FIRST_PAGE';
+} | {
+    type: 'CREATE_RECOVERABLE';
+} | {
+    type: 'USE_SYNCED_PASSKEY';
+} | {
+    type: 'ENTER_GUARDIAN_SHARES';
+} | {
+    type: 'SUBMIT_GUARDIAN_SHARES';
+    codes: string[];
+} | {
+    type: 'SUBMIT_PHRASE';
+    phrase: string;
+} | {
+    type: 'IMPORT_FAILED';
+    error: Error;
+} | {
+    type: 'RECOVERABLE_CREATED';
+    identity: Identity;
+    keyBundle: KeyBundle;
+    phrase: string;
+} | {
+    type: 'PHRASE_SAVED';
+};
+type OnboardingMachineContext = {
+    identity: Identity | null;
+    keyBundle: KeyBundle | null;
+    hubUrl: string | null;
+    error: Error | null;
+    isDemo: boolean;
+    /** The recovery phrase to show once, after creating a recoverable identity (0243). */
+    recoveryPhrase: string | null;
+};
+type OnboardingReducerState = {
+    state: OnboardingState;
+    context: OnboardingMachineContext;
+};
+declare function onboardingReducer(current: OnboardingReducerState, event: OnboardingEvent): OnboardingReducerState;
+declare function createInitialState(hubUrl?: string): OnboardingReducerState;
+
+/**
+ * @xnetjs/react/onboarding - React context provider for the onboarding flow
+ */
+
+type OnboardingContextValue = {
+    state: OnboardingState;
+    context: OnboardingMachineContext;
+    send: (event: OnboardingEvent) => void;
+};
+type OnboardingProviderProps = {
+    children: ReactNode;
+    /** Default hub URL for new users */
+    defaultHubUrl?: string;
+    /** Called when onboarding completes */
+    onComplete?: (identity: Identity, keyBundle: KeyBundle) => void;
+};
+declare function OnboardingProvider({ children, defaultHubUrl, onComplete }: OnboardingProviderProps): JSX.Element;
+/**
+ * Access the onboarding state machine from within an OnboardingProvider.
+ */
+declare function useOnboarding(): OnboardingContextValue;
+
+type HubConnectScreenProps = {
+    /** Optional: attempt hub connection. If not provided, auto-advances. */
+    connectToHub?: () => Promise<void>;
+};
+declare function HubConnectScreen({ connectToHub }: HubConnectScreenProps): JSX.Element;
+
+interface OnboardingFlowProps {
+    /** Optional hub connection function */
+    connectToHub?: HubConnectScreenProps['connectToHub'];
+    /** Render prop for the completed state (app content) */
+    children?: React.ReactNode;
+}
+/**
+ * Renders the correct onboarding screen based on state machine state.
+ *
+ * @example
+ * <OnboardingProvider onComplete={handleComplete}>
+ *   <OnboardingFlow>
+ *     <App />
+ *   </OnboardingFlow>
+ * </OnboardingProvider>
+ */
+declare function OnboardingFlow({ connectToHub, children }: OnboardingFlowProps): JSX.Element;
+
+declare function WelcomeScreen(): JSX.Element;
+
+declare function AuthenticatingScreen(): JSX.Element;
+
+declare function AuthErrorScreen(): JSX.Element;
+
+declare function UnsupportedBrowserScreen(): JSX.Element;
+
+declare function ImportIdentityScreen(): JSX.Element;
+
+declare function ReadyScreen(): JSX.Element;
+
+declare function SmartWelcome(): JSX.Element;
+
+/**
+ * Sync progress overlay — shown during initial sync on a new device.
+ */
+
+interface SyncProgressOverlayProps {
+    progress: SyncProgress;
+    onComplete: () => void;
+}
+declare function SyncProgressOverlay({ progress, onComplete }: SyncProgressOverlayProps): JSX.Element;
+
+/**
+ * @xnetjs/react/onboarding - Quick-start content templates
+ */
+interface QuickStartTemplate {
+    id: string;
+    name: string;
+    description: string;
+    icon: string;
+}
+declare const QUICK_START_TEMPLATES: QuickStartTemplate[];
+
+/**
+ * @xnetjs/react/onboarding - Helper utilities
+ */
+/**
+ * Get a human-friendly name for the platform's biometric authenticator.
+ */
+declare function getPlatformAuthName(): string;
+/**
+ * Truncate a DID for display, showing first and last segments.
+ * e.g. "did:key:z6MkhaXg...yz" → "did:key:z6Mkha...xyz"
+ */
+declare function truncateDid(did: string, headLen?: number, tailLen?: number): string;
+/**
+ * Copy text to clipboard, returns true on success.
+ * Returns false in SSR environments where navigator is unavailable.
+ */
+declare function copyToClipboard(text: string): Promise<boolean>;
+
+type PageTasksPanelProps = {
+    pageId: string;
+};
+declare function PageTasksPanel({ pageId }: PageTasksPanelProps): JSX$1.Element;
+
+/**
+ * @xnetjs/react - Embedded task collection renderer
+ */
+
+type TaskCollectionEmbedProps = {
+    currentPageId: string | null;
+    currentDid: string | null;
+    scope: 'current-page' | 'all';
+    assignee: 'any' | 'me';
+    dueDate: 'any' | 'overdue' | 'today' | 'next-7-days' | 'none';
+    status: 'open' | 'done' | 'all';
+    showHierarchy: boolean;
+};
+declare function TaskCollectionEmbed({ currentPageId, currentDid, scope, assignee, dueDate, status, showHierarchy }: TaskCollectionEmbedProps): JSX$1.Element;
+
+/**
+ * Security context for multi-level cryptography.
+ *
+ * Provides global security configuration and state management for:
+ * - Security level selection (0, 1, 2)
+ * - Verification policy configuration
+ * - PQ key registry access
+ * - Key bundle management
+ */
+
+/**
+ * Security context state.
+ */
+interface SecurityContextState {
+    /** Current security level for new signatures */
+    level: SecurityLevel;
+    /** Minimum level to accept during verification */
+    minVerificationLevel: SecurityLevel;
+    /** Verification policy */
+    verificationPolicy: 'strict' | 'permissive';
+    /** PQ key registry */
+    registry: PQKeyRegistry;
+    /** Current key bundle (if available) */
+    keyBundle?: HybridKeyBundle;
+}
+/**
+ * Security context actions.
+ */
+interface SecurityContextActions {
+    /** Set the signing security level */
+    setLevel: (level: SecurityLevel) => void;
+    /** Set the minimum verification level */
+    setMinVerificationLevel: (level: SecurityLevel) => void;
+    /** Set the verification policy */
+    setVerificationPolicy: (policy: 'strict' | 'permissive') => void;
+    /** Update the key bundle */
+    setKeyBundle: (bundle: HybridKeyBundle | undefined) => void;
+}
+/**
+ * Combined security context value.
+ */
+type SecurityContextValue = SecurityContextState & SecurityContextActions;
+/**
+ * Security provider props.
+ */
+interface SecurityProviderProps {
+    children: ReactNode;
+    /** Initial security level (default: 0 for Ed25519-only) */
+    level?: SecurityLevel;
+    /** Initial minimum verification level (default: 0) */
+    minVerificationLevel?: SecurityLevel;
+    /** Initial verification policy (default: 'strict') */
+    verificationPolicy?: 'strict' | 'permissive';
+    /** PQ key registry (default: MemoryPQKeyRegistry) */
+    registry?: PQKeyRegistry;
+    /** Initial key bundle */
+    keyBundle?: HybridKeyBundle;
+}
+/**
+ * Security provider component.
+ *
+ * Wraps the application with security configuration and state.
+ *
+ * @example
+ * ```tsx
+ * <SecurityProvider level={1} verificationPolicy="strict">
+ *   <App />
+ * </SecurityProvider>
+ * ```
+ */
+declare function SecurityProvider({ children, level: initialLevel, minVerificationLevel: initialMinLevel, verificationPolicy: initialPolicy, registry: providedRegistry, keyBundle: initialBundle }: SecurityProviderProps): JSX.Element;
+/**
+ * Hook to access security context.
+ *
+ * @throws Error if used outside of SecurityProvider
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { level, setLevel, registry } = useSecurityContext()
+ *   // ...
+ * }
+ * ```
+ */
+declare function useSecurityContext(): SecurityContextValue;
+/**
+ * Hook to optionally access security context.
+ *
+ * Returns null if used outside of SecurityProvider (no error thrown).
+ */
+declare function useSecurityContextOptional(): SecurityContextValue | null;
+
+/**
+ * useSecurity - Hook for security-aware operations.
+ *
+ * Provides signing and verification functions that use the current
+ * security level from the SecurityContext.
+ */
+
+/**
+ * Options for useSecurity hook.
+ */
+interface UseSecurityOptions {
+    /** Override default security level for this hook instance */
+    level?: SecurityLevel;
+}
+/**
+ * Return type for useSecurity hook.
+ */
+interface UseSecurityResult {
+    /** Current security level (from context or override) */
+    level: SecurityLevel;
+    /** Whether the current key bundle has PQ keys */
+    hasPQKeys: boolean;
+    /** Maximum level supported by current keys (0 if no PQ keys, 2 if PQ keys present) */
+    maxLevel: SecurityLevel;
+    /** Sign data at current security level */
+    sign: (data: Uint8Array) => UnifiedSignature;
+    /** Verify a signature against a DID */
+    verify: (data: Uint8Array, signature: UnifiedSignature, did: DID) => Promise<VerificationResult$1>;
+    /** Set the global security level */
+    setLevel: (level: SecurityLevel) => void;
+    /** Check if a level is supported by current keys */
+    canSignAt: (level: SecurityLevel) => boolean;
+    /** Check if key bundle is available */
+    hasKeyBundle: boolean;
+}
+/**
+ * Hook for security-aware operations.
+ *
+ * Provides signing and verification functions that use the current
+ * security level from the SecurityContext.
+ *
+ * @example
+ * ```tsx
+ * function SignedMessage() {
+ *   const { sign, verify, level, hasPQKeys } = useSecurity()
+ *
+ *   const handleSign = async () => {
+ *     const data = new TextEncoder().encode('Hello')
+ *     const sig = sign(data)
+ *     console.log(`Signed at Level ${sig.level}`)
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <p>Security Level: {level}</p>
+ *       <p>PQ Keys: {hasPQKeys ? 'Yes' : 'No'}</p>
+ *       <button onClick={handleSign}>Sign</button>
+ *     </div>
+ *   )
+ * }
+ * ```
+ *
+ * @example Per-operation level override
+ * ```tsx
+ * function HighSecurityOperation() {
+ *   const { sign } = useSecurity({ level: 2 }) // Force Level 2
+ *
+ *   const handleCritical = () => {
+ *     const data = new TextEncoder().encode('Critical operation')
+ *     const sig = sign(data) // Signs at Level 2
+ *     console.log(sig.level) // 2
+ *   }
+ *
+ *   return <button onClick={handleCritical}>Critical Action</button>
+ * }
+ * ```
+ *
+ * @example Fast mode for high-frequency operations
+ * ```tsx
+ * function CursorUpdates() {
+ *   const { sign } = useSecurity({ level: 0 }) // Fast Ed25519-only
+ *
+ *   const handleCursor = (position: number) => {
+ *     const data = new TextEncoder().encode(JSON.stringify({ position }))
+ *     const sig = sign(data) // Fast signing
+ *   }
+ *
+ *   return <canvas onMouseMove={(e) => handleCursor(e.clientX)} />
+ * }
+ * ```
+ */
+declare function useSecurity(options?: UseSecurityOptions): UseSecurityResult;
+
+/**
+ * Plugin registry context
+ */
+declare const PluginRegistryContext: react.Context<PluginRegistry | null>;
+/**
+ * Access the PluginRegistry instance
+ *
+ * @example
+ * ```tsx
+ * const registry = usePluginRegistry()
+ * const plugins = registry.getAll()
+ * ```
+ *
+ * @throws Error if used outside of XNetProvider with plugins enabled
+ */
+declare function usePluginRegistry(): PluginRegistry;
+/**
+ * Safely access the PluginRegistry instance, returns null if not available
+ *
+ * Use this when you need to optionally access the plugin system without throwing.
+ */
+declare function usePluginRegistryOptional(): PluginRegistry | null;
+/**
+ * Get all registered plugins with reactive updates
+ *
+ * @example
+ * ```tsx
+ * const plugins = usePlugins()
+ * // Re-renders when plugins change
+ * ```
+ */
+declare function usePlugins(): RegisteredPlugin[];
+/**
+ * Contribution type to interface mapping
+ */
+type ContributionTypeMap = {
+    views: ViewContribution;
+    commands: CommandContribution;
+    slashCommands: SlashCommandContribution;
+    sidebar: SidebarContribution;
+    editor: EditorContribution;
+    propertyHandlers: PropertyHandlerContribution;
+    blocks: BlockContribution;
+    settings: SettingContribution;
+    importers: ImporterContribution;
+};
+/**
+ * Get contributions of a specific type with reactive updates
+ *
+ * @example
+ * ```tsx
+ * // Get all registered views
+ * const views = useContributions('views')
+ *
+ * // Get all commands
+ * const commands = useContributions('commands')
+ * ```
+ */
+declare function useContributions<K extends keyof ContributionTypeMap>(type: K): ContributionTypeMap[K][];
+/**
+ * Get all registered views
+ */
+declare function useViews(): ViewContribution[];
+/**
+ * Get all registered commands
+ */
+declare function useCommands(): CommandContribution[];
+/**
+ * Get all registered slash commands
+ */
+declare function useSlashCommands(): SlashCommandContribution[];
+/**
+ * Get all registered sidebar items
+ */
+declare function useSidebarItems(): SidebarContribution[];
+/**
+ * Get all registered importer contributions (exploration 0189).
+ *
+ * Pair with `resolveImporters`/`importerAdapters` from `@xnetjs/plugins` to merge
+ * plugin-contributed importers with a built-in set (e.g. the social importers).
+ */
+declare function useImporters(): ImporterContribution[];
+/**
+ * Get all registered editor extensions
+ *
+ * @throws Error if plugin system is not enabled
+ */
+declare function useEditorExtensions(): EditorContribution[];
+/**
+ * Get all registered editor extensions, returns empty array if plugin system is not available
+ *
+ * Safe version that doesn't throw if plugins aren't enabled.
+ */
+declare function useEditorExtensionsSafe(): EditorContribution[];
+/**
+ * Get a specific view by type
+ */
+declare function useView(type: string): ViewContribution | undefined;
+/**
+ * Get a specific command by ID
+ */
+declare function useCommand(id: string): CommandContribution | undefined;
+
+export { summarizeReactionNode as $, type AddCommentOptions as A, selectPublicInteractionMode as B, type CommentThread as C, summarizeModerationLabel as D, summarizePublicInteractionPolicy as E, type CommentVisibility as F, type FirstContactMode as G, type ModeratedCommentThread as H, type InteractionPermission as I, type ModerationFilterOptions as J, type ModerationLabelSummary as K, type PublicInteractionMode as L, type ModeratedCommentNode as M, type PublicInteractionPolicySnapshot as N, type PublicInteractionSurface as O, type PageTaskInput as P, type PublicModerationMode as Q, type ReplyContext as R, type UseModeratedThreadOptions as S, type TaskProjectionInput as T, type UseTaskProjectionSyncResult as U, type UseVisibleCommentsOptions as V, type UseVisibleCommentsResult as W, usePolicyFilteredReactionCounters as X, createReactionCounterSnapshot as Y, dedupeReactions as Z, isReactionVisible as _, type TaskTreeItem as a, type RemoteSchemaDefinition as a$, type AddReactionOptions as a0, type ReactionCounterSnapshot as a1, type ReactionNode as a2, type ReactionType as a3, type UsePolicyFilteredReactionCountersOptions as a4, type UsePolicyFilteredReactionCountersResult as a5, useMessageRequests as a6, createConversationKey as a7, createMessageRequestProperties as a8, evaluateFirstContactDecision as a9, type UseBlameResult as aA, useVerification as aB, type UseVerificationResult as aC, useHubStatus as aD, useCan as aE, type UseCanResult as aF, useCanEdit as aG, type UseCanEditResult as aH, describeGrantConsent as aI, useGrants as aJ, type GrantConsentSummary as aK, type GrantInput as aL, type UseGrantsResult as aM, summarizeAuthTrace as aN, useAuthTrace as aO, type AuthTraceSummary as aP, type UseAuthTraceResult as aQ, useBackup as aR, type UseBackupReturn as aS, useFileUpload as aT, type FileRef as aU, type UseFileUploadReturn as aV, useHubSearch as aW, type HubSearchOptions as aX, type HubSearchResult as aY, type HubSearchState as aZ, useRemoteSchema as a_, findLatestMessageRequest as aa, hasAcceptedContact as ab, summarizeMessageRequest as ac, type CreateMessageRequestOptions as ad, type FirstContactAdmission as ae, type FirstContactDecision as af, type FirstContactDecisionInput as ag, type FirstContactVisibility as ah, type MessageRequestNode as ai, type MessageRequestProperties as aj, type MessageRequestStatus as ak, type UseMessageRequestsOptions as al, type UseMessageRequestsResult as am, useCommentCount as an, useCommentCounts as ao, useHistory as ap, type UseHistoryResult as aq, useUndo as ar, type UseUndoResult as as, type UseUndoOptions as at, useAudit as au, type UseAuditResult as av, type UseAuditOptions as aw, useDiff as ax, type UseDiffResult as ay, useBlame as az, type UseFindOptions as b, useViews as b$, type RemoteSchemaState as b0, usePeerDiscovery as b1, type DiscoveredPeer as b2, HubStatusIndicator as b3, Skeleton as b4, injectSkeletonStyles as b5, type SkeletonProps as b6, DemoBanner as b7, type DemoBannerProps as b8, DemoQuotaIndicator as b9, type OnboardingContextValue as bA, type OnboardingFlowProps as bB, type OnboardingState as bC, type OnboardingEvent as bD, type OnboardingMachineContext as bE, type OnboardingReducerState as bF, type QuickStartTemplate as bG, type SyncProgressOverlayProps as bH, PageTasksPanel as bI, type PageTasksPanelProps as bJ, TaskCollectionEmbed as bK, type TaskCollectionEmbedProps as bL, SecurityProvider as bM, useSecurityContext as bN, useSecurityContextOptional as bO, type SecurityContextState as bP, type SecurityContextActions as bQ, type SecurityContextValue as bR, type SecurityProviderProps as bS, useSecurity as bT, type UseSecurityOptions as bU, type UseSecurityResult as bV, PluginRegistryContext as bW, usePluginRegistry as bX, usePluginRegistryOptional as bY, usePlugins as bZ, useContributions as b_, type DemoQuotaIndicatorProps as ba, DemoDataExpiredScreen as bb, useDemoMode as bc, type DemoModeState as bd, type DemoLimits as be, type DemoUsage as bf, useSyncManager as bg, OnboardingProvider as bh, useOnboarding as bi, OnboardingFlow as bj, WelcomeScreen as bk, AuthenticatingScreen as bl, AuthErrorScreen as bm, UnsupportedBrowserScreen as bn, ImportIdentityScreen as bo, HubConnectScreen as bp, ReadyScreen as bq, SmartWelcome as br, SyncProgressOverlay as bs, onboardingReducer as bt, createInitialState as bu, QUICK_START_TEMPLATES as bv, getPlatformAuthName as bw, truncateDid as bx, copyToClipboard as by, type OnboardingProviderProps as bz, type UseFindResult as c, useCommands as c0, useSlashCommands as c1, useSidebarItems as c2, useImporters as c3, useEditorExtensions as c4, useEditorExtensionsSafe as c5, useView as c6, useCommand as c7, usePageTaskSync as d, type PageTaskReferenceInput as e, type UsePageTaskSyncOptions as f, type UsePageTaskSyncResult as g, useTaskProjectionSync as h, type TaskProjectionReferenceInput as i, type TaskProjectionHost as j, type UseTaskProjectionSyncOptions as k, useTasks as l, type UseTasksOptions as m, type UseTasksResult as n, useComments as o, type UseCommentsOptions as p, type UseCommentsResult as q, type CommentNode as r, useVisibleComments as s, useModeratedThread as t, useFind as u, createModerationLabelIndex as v, evaluateCommentModeration as w, evaluateInteractionPermission as x, moderateThread as y, selectActiveInteractionPolicy as z };