@xnetjs/react 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,2782 @@
+import { PropertyBuilder, SchemaIRI, MigrationInfo, InferCreateProps, NodeState, MigratedNodeState, DefinedSchema, ColumnDefinition, ViewConfig, FilterGroup, SortConfig, CellValue, Schema, DatabaseSchemaMetadata, NodeId, NodeStore, NodeStorageAdapter, AuthGrant, NodeChange, NodePayload } from '@xnetjs/data';
+export { ColumnConfig, ColumnDefinition, ColumnType, ViewConfig, ViewType } from '@xnetjs/data';
+import { DID, ContentId, AuthAction } from '@xnetjs/core';
+import { Awareness } from 'y-protocols/awareness';
+import * as Y from 'yjs';
+import { TimelineEntry, HistoryTarget, HistoricalState, PropertyDiff, UndoManagerOptions, AuditEntry, ActivitySummary, DiffResult, BlameInfo, VerificationOptions, VerificationResult } from '@xnetjs/history';
+import * as react from 'react';
+import { Component, ReactNode, ErrorInfo } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Identity, KeyBundle, PQKeyRegistry, HybridKeyBundle } from '@xnetjs/identity';
+import { SecurityLevel, UnifiedSignature, VerificationResult as VerificationResult$1 } from '@xnetjs/crypto';
+import { DataBridge } from '@xnetjs/data-bridge';
+import { Platform, PluginRegistry, RegisteredPlugin, ViewContribution, CommandContribution, SlashCommandContribution, SidebarContribution, EditorContribution, PropertyHandlerContribution, BlockContribution, SettingContribution } from '@xnetjs/plugins';
+export { I as InstrumentationContext, a as InstrumentationContextValue, Q as QueryTrackerLike, Y as YDocRegistryLike, u as useInstrumentation } from './instrumentation-Cn94kn8-.js';
+
+/**
+ * FlatNode utilities - Flatten NodeState properties to top level
+ *
+ * This module provides type-safe flattening of Node properties so developers
+ * can access `node.title` instead of `node.properties.title`.
+ */
+
+/**
+ * Base node fields (always present on any node)
+ */
+interface NodeBase {
+    /** Unique node identifier */
+    id: string;
+    /** Schema IRI this node conforms to */
+    schemaId: SchemaIRI;
+    /** Creation timestamp */
+    createdAt: number;
+    /** Creator's DID */
+    createdBy: DID;
+    /** Last update timestamp */
+    updatedAt: number;
+    /** Last updater's DID */
+    updatedBy: DID;
+    /** Whether node is soft-deleted */
+    deleted: boolean;
+    /**
+     * True if this node's schema is not registered/known to the current app version.
+     * The node data is still accessible but may not have proper type information.
+     * UI should render a generic "Unknown data type" component for these nodes.
+     */
+    _unknownSchema?: boolean;
+    /**
+     * Properties from future schema versions that aren't known to the current schema.
+     * Preserved for forward compatibility - can be displayed in a "raw data" view.
+     */
+    _unknown?: Record<string, unknown>;
+    /**
+     * The schema version that last wrote to this node.
+     * Useful for detecting when migrations might be needed.
+     */
+    _schemaVersion?: string;
+    /**
+     * The original schema IRI this node was migrated from.
+     * Only present if the node was automatically migrated on read.
+     */
+    _migratedFrom?: SchemaIRI;
+    /**
+     * Full migration info if the node was migrated.
+     * Includes lossless flag and any warnings about data loss.
+     */
+    _migrationInfo?: MigrationInfo;
+}
+/**
+ * A flattened node with properties at the top level.
+ *
+ * Instead of `node.properties.title`, access `node.title` directly.
+ * All property types are correctly inferred from the schema.
+ *
+ * @example
+ * ```tsx
+ * const { data } = useQuery(TaskSchema, id)
+ * // data is FlatNode<typeof TaskSchema._properties>
+ *
+ * console.log(data.title)   // string - correctly typed!
+ * console.log(data.status)  // 'todo' | 'done' - union type!
+ * ```
+ */
+type FlatNode<P extends Record<string, PropertyBuilder>> = NodeBase & InferCreateProps<P>;
+/**
+ * Options for flattenNode function
+ */
+interface FlattenNodeOptions {
+    /**
+     * Mark this node as having an unknown schema.
+     * This happens when the node's schemaId is not registered in the current app version.
+     */
+    unknownSchema?: boolean;
+    /**
+     * Migration info if the node was migrated from a different schema version.
+     */
+    migrationInfo?: MigrationInfo;
+}
+/**
+ * Flatten a NodeState by spreading properties to top level.
+ *
+ * @param node - The NodeState with nested properties
+ * @param options - Optional settings for handling unknown schemas
+ * @returns A new object with properties flattened to top level
+ *
+ * @example
+ * ```ts
+ * const nodeState = {
+ *   id: '123',
+ *   schemaId: 'xnet://xnet.fyi/Task',
+ *   properties: { title: 'My Task', status: 'todo' },
+ *   // ...
+ * }
+ *
+ * const flat = flattenNode(nodeState)
+ * // { id: '123', schemaId: '...', title: 'My Task', status: 'todo', ... }
+ * ```
+ */
+declare function flattenNode<P extends Record<string, PropertyBuilder>>(node: NodeState | MigratedNodeState, options?: FlattenNodeOptions): FlatNode<P>;
+/**
+ * Flatten an array of NodeState objects.
+ */
+declare function flattenNodes<P extends Record<string, PropertyBuilder>>(nodes: (NodeState | MigratedNodeState)[], options?: FlattenNodeOptions): FlatNode<P>[];
+/**
+ * Create a FlatNode with unknown schema flag.
+ * Use this when displaying nodes whose schema is not registered.
+ */
+declare function flattenUnknownSchemaNode(node: NodeState): FlatNode<Record<string, PropertyBuilder>>;
+/**
+ * Create FlatNodes from an array, marking those with unknown schemas.
+ *
+ * @param nodes - Array of NodeState objects
+ * @param isSchemaKnown - Function to check if a schema is registered
+ * @returns Array of FlatNodes with _unknownSchema set appropriately
+ */
+declare function flattenNodesWithSchemaCheck<P extends Record<string, PropertyBuilder>>(nodes: NodeState[], isSchemaKnown: (schemaId: string) => boolean): FlatNode<P>[];
+
+/**
+ * useQuery - Unified read hook for Nodes via DataBridge
+ *
+ * A single hook for all read operations:
+ * - List all nodes of a schema
+ * - Get a single node by ID
+ * - Query with filters
+ *
+ * Returns FlatNode with properties at top level for ergonomic access.
+ *
+ * Uses DataBridge for off-main-thread data access. The bridge handles
+ * caching and provides useSyncExternalStore-compatible subscriptions.
+ *
+ * @example
+ * ```tsx
+ * // List all tasks
+ * const { data: tasks } = useQuery(TaskSchema)
+ * tasks.forEach(task => console.log(task.title))  // Direct access!
+ *
+ * // Get single task by ID
+ * const { data: task } = useQuery(TaskSchema, taskId)
+ * console.log(task?.status)  // Typed correctly!
+ *
+ * // Query with filters
+ * const { data: urgent } = useQuery(TaskSchema, {
+ *   where: { status: 'urgent' },
+ *   orderBy: { createdAt: 'desc' }
+ * })
+ * ```
+ */
+
+/**
+ * Sort direction
+ */
+type SortDirection = 'asc' | 'desc';
+/**
+ * System fields that can be used for ordering
+ */
+type SystemOrderField = 'createdAt' | 'updatedAt';
+/**
+ * Query filter options
+ */
+interface QueryFilter<P extends Record<string, PropertyBuilder> = Record<string, PropertyBuilder>> {
+    /** Filter conditions (property: value) */
+    where?: Partial<InferCreateProps<P>>;
+    /** Include soft-deleted nodes */
+    includeDeleted?: boolean;
+    /** Sort by property or system field (createdAt, updatedAt) */
+    orderBy?: {
+        [K in keyof InferCreateProps<P> | SystemOrderField]?: SortDirection;
+    };
+    /** Limit results */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+}
+/**
+ * Migration warning info
+ */
+interface MigrationWarning {
+    /** The node ID that was migrated */
+    nodeId: string;
+    /** The original schema IRI */
+    from: string;
+    /** The target schema IRI */
+    to: string;
+    /** Warning messages about potential data loss */
+    warnings: string[];
+}
+/**
+ * Result when querying a list of nodes
+ */
+interface QueryListResult<P extends Record<string, PropertyBuilder>> {
+    /** The queried nodes (flattened - access properties directly) */
+    data: FlatNode<P>[];
+    /** Whether currently loading */
+    loading: boolean;
+    /** Any error that occurred */
+    error: Error | null;
+    /** Reload the query */
+    reload: () => void;
+    /**
+     * Migration warnings for nodes that were migrated from different schema versions.
+     * Only populated if nodes required migration and the migration was lossy.
+     */
+    migrationWarnings: MigrationWarning[];
+}
+/**
+ * Result when querying a single node
+ */
+interface QuerySingleResult<P extends Record<string, PropertyBuilder>> {
+    /** The queried node (flattened - access properties directly), null if not found */
+    data: FlatNode<P> | null;
+    /** Whether currently loading */
+    loading: boolean;
+    /** Any error that occurred */
+    error: Error | null;
+    /** Reload the query */
+    reload: () => void;
+    /**
+     * Migration warnings if the node was migrated from a different schema version.
+     * Only populated if the node required migration and the migration was lossy.
+     */
+    migrationWarnings: MigrationWarning[];
+}
+/**
+ * Query all nodes of a schema
+ */
+declare function useQuery<P extends Record<string, PropertyBuilder>>(schema: DefinedSchema<P>): QueryListResult<P>;
+/**
+ * Query a single node by ID
+ */
+declare function useQuery<P extends Record<string, PropertyBuilder>>(schema: DefinedSchema<P>, id: string): QuerySingleResult<P>;
+/**
+ * Query nodes with filters
+ */
+declare function useQuery<P extends Record<string, PropertyBuilder>>(schema: DefinedSchema<P>, filter: QueryFilter<P>): QueryListResult<P>;
+
+/**
+ * useMutate - Unified write hook for Nodes via DataBridge
+ *
+ * A single hook for all write operations:
+ * - Create nodes (requires schema)
+ * - Update nodes (requires schema for type safety)
+ * - Delete nodes (by ID)
+ * - Atomic transactions (multiple operations)
+ *
+ * Uses DataBridge for off-main-thread data access.
+ *
+ * Features:
+ * - Immediate local updates (bridge updates UI subscribers synchronously)
+ * - Type-safe schema-bound mutations
+ * - Transaction support for atomic multi-node operations
+ * - Pending state tracking
+ *
+ * @example
+ * ```tsx
+ * const { create, update, remove, mutate, isPending } = useMutate()
+ *
+ * // Simple operations
+ * await create(TaskSchema, { title: 'New Task', status: 'todo' })
+ * await update(TaskSchema, taskId, { status: 'done' })  // Type-safe!
+ * await remove(taskId)
+ *
+ * // Atomic transaction
+ * await mutate([
+ *   { type: 'create', schema: TaskSchema, data: { title: 'Task 1' } },
+ *   { type: 'update', id: taskId, data: { status: 'done' } },
+ *   { type: 'delete', id: oldTaskId }
+ * ])
+ * ```
+ */
+
+/**
+ * Create operation for mutate
+ */
+interface MutateCreate<P extends Record<string, PropertyBuilder> = Record<string, PropertyBuilder>> {
+    type: 'create';
+    schema: DefinedSchema<P>;
+    data: InferCreateProps<P>;
+    id?: string;
+}
+/**
+ * Update operation for mutate
+ */
+interface MutateUpdate {
+    type: 'update';
+    id: string;
+    data: Record<string, unknown>;
+}
+/**
+ * Delete operation for mutate
+ */
+interface MutateDelete {
+    type: 'delete';
+    id: string;
+}
+/**
+ * Restore operation for mutate
+ */
+interface MutateRestore {
+    type: 'restore';
+    id: string;
+}
+/**
+ * All possible mutate operations
+ */
+type MutateOp = MutateCreate<Record<string, PropertyBuilder>> | MutateUpdate | MutateDelete | MutateRestore;
+/**
+ * Result from a mutate transaction
+ */
+interface MutateResult {
+    /** Results for each operation (NodeState or null for delete) */
+    results: (NodeState | null)[];
+    /** Batch ID when transaction backend is available */
+    batchId?: string;
+    /** Temp ID mapping when transaction backend is available */
+    tempIds?: Record<string, string>;
+}
+/**
+ * Result from useMutate hook
+ */
+interface UseMutateResult {
+    /**
+     * Create a new node.
+     * Requires a schema to know what type to create.
+     * Optionally specify a custom ID (otherwise auto-generated).
+     *
+     * @returns The created node (flattened), or null if creation failed
+     */
+    create: <P extends Record<string, PropertyBuilder>>(schema: DefinedSchema<P>, data: InferCreateProps<P>, id?: string) => Promise<FlatNode<P> | null>;
+    /**
+     * Update an existing node by ID.
+     * Requires schema for type-safe property checking.
+     *
+     * @example
+     * ```tsx
+     * await update(TaskSchema, taskId, { status: 'done' })  // OK
+     * await update(TaskSchema, taskId, { typo: 'x' })       // Type error!
+     * ```
+     *
+     * @returns The updated node (flattened), or null if update failed
+     */
+    update: <P extends Record<string, PropertyBuilder>>(schema: DefinedSchema<P>, id: string, data: Partial<InferCreateProps<P>>) => Promise<FlatNode<P> | null>;
+    /**
+     * Delete a node by ID (soft delete).
+     */
+    remove: (id: string) => Promise<void>;
+    /**
+     * Restore a deleted node by ID.
+     *
+     * @returns The restored node (flattened), or null if restore failed
+     */
+    restore: (id: string) => Promise<FlatNode<Record<string, PropertyBuilder>> | null>;
+    /**
+     * Execute multiple operations atomically.
+     * All operations succeed or fail together.
+     *
+     * Note: Transaction support requires MainThreadBridge with direct NodeStore access.
+     * WorkerBridge executes operations sequentially (not truly atomic).
+     */
+    mutate: (ops: MutateOp[]) => Promise<MutateResult | null>;
+    /**
+     * Whether any mutation is currently in progress.
+     */
+    isPending: boolean;
+    /**
+     * Number of pending mutations.
+     */
+    pendingCount: number;
+}
+/**
+ * Hook for all write operations on Nodes via DataBridge.
+ *
+ * Provides both convenience methods (create, update, remove) and
+ * a full transaction API (mutate) for atomic multi-node operations.
+ *
+ * All operations update the local cache immediately, and subscribers
+ * see changes synchronously. Background sync handles persistence.
+ */
+declare function useMutate(): UseMutateResult;
+
+/**
+ * useNode - The unified hook for working with a single Node
+ *
+ * This is the primary hook for editing Nodes. It provides:
+ * - Node properties (flattened for ergonomic access)
+ * - Y.Doc for collaborative rich text (if schema specifies document: 'yjs')
+ * - Auto-sync via WebSocket
+ * - Type-safe mutations (update, remove)
+ * - Presence awareness (live + hub snapshot)
+ * - Auto-create with createIfMissing
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   data,           // FlatNode - access data.title directly!
+ *   doc,            // Y.Doc for rich text
+ *   update,         // Type-safe update function
+ *   remove,         // Soft delete
+ *   syncStatus,     // 'offline' | 'connecting' | 'connected'
+ *   peerCount,      // Number of connected peers
+ *   presence,       // Presence list (live + hub snapshot)
+ *   loading,
+ *   error
+ * } = useNode(PageSchema, pageId, {
+ *   createIfMissing: { title: 'Untitled' }
+ * })
+ *
+ * // Update is type-safe!
+ * update({ title: 'New Title' })  // OK
+ * update({ typo: 'x' })           // Type error!
+ * ```
+ */
+
+/**
+ * Sync connection status
+ */
+type SyncStatus$1 = 'offline' | 'connecting' | 'connected' | 'error';
+interface PresenceUser {
+    did: string;
+    name?: string;
+    color?: string;
+    lastSeen?: number;
+    isStale?: boolean;
+}
+/**
+ * Options for useNode
+ */
+interface UseNodeOptions<P extends Record<string, PropertyBuilder>> {
+    /** Signaling servers for y-webrtc (default: localhost for dev) */
+    signalingServers?: string[];
+    /** Disable auto-sync (default: false) */
+    disableSync?: boolean;
+    /** Debounce persistence delay in ms (default: 1000) */
+    persistDebounce?: number;
+    /**
+     * Auto-create the node if it doesn't exist.
+     * Provide the default properties to use for creation.
+     */
+    createIfMissing?: InferCreateProps<P>;
+    /**
+     * User's DID for presence/cursors. If provided, broadcasts awareness state.
+     */
+    did?: string;
+}
+/**
+ * Result from useNode hook
+ */
+interface UseNodeResult<P extends Record<string, PropertyBuilder>> {
+    /** Node properties (flattened - access directly: data.title) */
+    data: FlatNode<P> | null;
+    /** Yjs document instance (null if schema has no document type) */
+    doc: Y.Doc | null;
+    /**
+     * Update node properties (type-safe).
+     * Only properties defined in the schema are allowed.
+     */
+    update: (properties: Partial<InferCreateProps<P>>) => Promise<void>;
+    /**
+     * Soft-delete the node.
+     */
+    remove: () => Promise<void>;
+    /** Whether currently loading */
+    loading: boolean;
+    /** Any error that occurred */
+    error: Error | null;
+    /** Whether document has unsaved changes */
+    isDirty: boolean;
+    /** Last persistence timestamp */
+    lastSavedAt: number | null;
+    /** Whether the node was auto-created (via createIfMissing) */
+    wasCreated: boolean;
+    /** Sync connection status */
+    syncStatus: SyncStatus$1;
+    /** Sync error message (if syncStatus is 'error') */
+    syncError: string | null;
+    /** Connected peer count */
+    peerCount: number;
+    /** Presence list (live awareness + hub snapshot) */
+    presence: PresenceUser[];
+    /** Yjs Awareness instance (for TipTap CollaborationCursor) */
+    awareness: Awareness | null;
+    /** Manually trigger save */
+    save: () => Promise<void>;
+    /** Reload from storage */
+    reload: () => Promise<void>;
+}
+/**
+ * Load a Node with its CRDT document.
+ *
+ * This is the primary hook for editing content. It combines:
+ * - Data loading (with FlatNode for ergonomic access)
+ * - Y.Doc for collaborative rich text
+ * - Type-safe mutations
+ * - Real-time sync and presence
+ */
+declare function useNode<P extends Record<string, PropertyBuilder>>(schema: DefinedSchema<P>, id: string | null, options?: UseNodeOptions<P>): UseNodeResult<P>;
+
+/**
+ * useDatabaseDoc - Hook for database column and view operations
+ *
+ * Provides reactive access to the database's Y.Doc structure:
+ * - Column definitions (CRDT-ordered)
+ * - View configurations
+ * - Column and view CRUD operations
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   columns,
+ *   views,
+ *   createColumn,
+ *   updateColumn,
+ *   deleteColumn,
+ *   reorderColumn,
+ *   createView,
+ *   updateView,
+ *   deleteView
+ * } = useDatabaseDoc(databaseId)
+ * ```
+ */
+
+interface UseDatabaseDocResult {
+    /** All column definitions (CRDT-ordered) */
+    columns: ColumnDefinition[];
+    /** All view configurations */
+    views: ViewConfig[];
+    /** Y.Doc for direct access (if needed) */
+    doc: Y.Doc | null;
+    /** Whether the doc is loading */
+    loading: boolean;
+    /** Any error that occurred */
+    error: Error | null;
+    /** Create a new column */
+    createColumn: (definition: Omit<ColumnDefinition, 'id'>) => string | null;
+    /** Update a column's properties */
+    updateColumn: (columnId: string, updates: Partial<Omit<ColumnDefinition, 'id'>>) => void;
+    /** Delete a column */
+    deleteColumn: (columnId: string) => void;
+    /** Reorder a column to a new position */
+    reorderColumn: (columnId: string, newIndex: number) => void;
+    /** Duplicate a column */
+    duplicateColumn: (columnId: string, newName?: string) => string | null;
+    /** Get a single column by ID */
+    getColumn: (columnId: string) => ColumnDefinition | null;
+    /** Create a new view */
+    createView: (config: Omit<ViewConfig, 'id'>) => string | null;
+    /** Update a view's properties */
+    updateView: (viewId: string, updates: Partial<Omit<ViewConfig, 'id'>>) => void;
+    /** Delete a view */
+    deleteView: (viewId: string) => void;
+    /** Duplicate a view */
+    duplicateView: (viewId: string, newName?: string) => string | null;
+    /** Get a single view by ID */
+    getView: (viewId: string) => ViewConfig | null;
+}
+/**
+ * Hook for database column and view operations.
+ *
+ * Provides reactive access to the database's Y.Doc structure with
+ * CRDT-based column ordering and real-time schema sync.
+ */
+declare function useDatabaseDoc(databaseId: string): UseDatabaseDocResult;
+
+/**
+ * useDatabase - Hook for database row operations with pagination
+ *
+ * Provides:
+ * - Paginated row queries
+ * - Row CRUD operations
+ * - Integration with useDatabaseDoc for columns/views
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   rows,
+ *   columns,
+ *   views,
+ *   loading,
+ *   hasMore,
+ *   loadMore,
+ *   createRow,
+ *   updateRow,
+ *   deleteRow
+ * } = useDatabase(databaseId)
+ * ```
+ */
+
+interface UseDatabaseOptions {
+    /** Active view ID (uses first view if not specified) */
+    view?: string;
+    /** Override view filters */
+    filters?: FilterGroup;
+    /** Override view sorts */
+    sorts?: SortConfig[];
+    /** Search query (full-text search) - not yet implemented */
+    search?: string;
+    /** Page size (default: 50) */
+    pageSize?: number;
+}
+interface DatabaseRow {
+    /** Row ID */
+    id: string;
+    /** Sort key for ordering */
+    sortKey: string;
+    /** Cell values keyed by column ID */
+    cells: Record<string, CellValue>;
+    /** Creation timestamp */
+    createdAt: number;
+    /** Creator DID */
+    createdBy: string;
+}
+interface UseDatabaseResult {
+    /** Column definitions */
+    columns: ColumnDefinition[];
+    /** View configurations */
+    views: ViewConfig[];
+    /** Loaded rows */
+    rows: DatabaseRow[];
+    /** Total row count */
+    total: number;
+    /** Whether more rows are available */
+    hasMore: boolean;
+    /** Load more rows */
+    loadMore: () => Promise<void>;
+    /** Active view configuration */
+    activeView: ViewConfig | null;
+    /** Set the active view */
+    setActiveView: (viewId: string) => void;
+    /** Create a new row */
+    createRow: (values?: Record<string, CellValue>) => Promise<string>;
+    /** Update a row's cell values */
+    updateRow: (rowId: string, values: Record<string, CellValue>) => Promise<void>;
+    /** Delete a row */
+    deleteRow: (rowId: string) => Promise<void>;
+    /** Reorder a row */
+    reorderRow: (rowId: string, before?: string, after?: string) => Promise<void>;
+    /** Delete multiple rows */
+    deleteRows: (rowIds: string[]) => Promise<void>;
+    /** Whether initially loading */
+    loading: boolean;
+    /** Whether loading more rows */
+    loadingMore: boolean;
+    /** Any error that occurred */
+    error: Error | null;
+    /** Refetch all rows */
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for database row operations with pagination.
+ */
+declare function useDatabase(databaseId: string, options?: UseDatabaseOptions): UseDatabaseResult;
+
+/**
+ * useDatabaseRow - Hook for single row operations with optimistic updates
+ *
+ * Provides:
+ * - Row data with cell values
+ * - Y.Doc for rich text cells
+ * - Optimistic updates
+ * - Delete operation
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   row,
+ *   doc,
+ *   update,
+ *   delete: deleteRow,
+ *   loading
+ * } = useDatabaseRow(rowId)
+ * ```
+ */
+
+interface DatabaseRowData {
+    /** Row ID */
+    id: string;
+    /** Database ID this row belongs to */
+    databaseId: string;
+    /** Sort key for ordering */
+    sortKey: string;
+    /** Cell values keyed by column ID */
+    cells: Record<string, CellValue>;
+    /** Creation timestamp */
+    createdAt: number;
+    /** Creator DID */
+    createdBy: string;
+}
+interface UseDatabaseRowResult {
+    /** Row data */
+    row: DatabaseRowData | null;
+    /** Y.Doc for rich text cells (if any) */
+    doc: Y.Doc | null;
+    /** Update cell values (with optimistic UI) */
+    update: (values: Record<string, CellValue>) => Promise<void>;
+    /** Delete this row */
+    delete: () => Promise<void>;
+    /** Loading state */
+    loading: boolean;
+    /** Error state */
+    error: Error | null;
+}
+/**
+ * Hook for single row operations with optimistic updates.
+ */
+declare function useDatabaseRow(rowId: string): UseDatabaseRowResult;
+
+/**
+ * useCell - Hook for individual cell editing with debounced saves
+ *
+ * Provides:
+ * - Cell value with optimistic updates
+ * - Debounced persistence
+ * - Clear operation
+ *
+ * @example
+ * ```tsx
+ * const { value, setValue, saving } = useCell<string>(rowId, 'title')
+ *
+ * return (
+ *   <Input
+ *     value={value ?? ''}
+ *     onChange={(e) => setValue(e.target.value)}
+ *     className={saving ? 'opacity-50' : ''}
+ *   />
+ * )
+ * ```
+ */
+
+interface UseCellResult<T extends CellValue = CellValue> {
+    /** Cell value */
+    value: T | null;
+    /** Update cell value (debounced save) */
+    setValue: (value: T | null) => void;
+    /** Clear cell value */
+    clear: () => void;
+    /** Whether cell is being saved */
+    saving: boolean;
+    /** Error from last save */
+    error: Error | null;
+}
+interface UseCellOptions {
+    /** Debounce delay in ms (default: 300) */
+    debounce?: number;
+}
+/**
+ * Hook for individual cell editing with debounced saves.
+ */
+declare function useCell<T extends CellValue = CellValue>(rowId: string, columnId: string, options?: UseCellOptions): UseCellResult<T>;
+
+/**
+ * useRelatedRows - Hook for loading related row data for relation columns
+ *
+ * Fetches the row data for a list of row IDs, typically from a relation column.
+ *
+ * @example
+ * ```tsx
+ * const { rows, loading, error } = useRelatedRows(['row1', 'row2'])
+ * // rows contains the full row data for display
+ * ```
+ */
+
+interface UseRelatedRowsResult {
+    /** Loaded row data */
+    rows: DatabaseRow[];
+    /** Whether rows are loading */
+    loading: boolean;
+    /** Any error that occurred */
+    error: Error | null;
+}
+/**
+ * Hook for loading related row data.
+ *
+ * @param rowIds - Array of row IDs to load
+ * @returns Object containing rows, loading state, and error
+ */
+declare function useRelatedRows(rowIds: string[]): UseRelatedRowsResult;
+
+/**
+ * useReverseRelations - Hook for finding rows that link TO a given row
+ *
+ * Finds all rows in other databases that have relation columns pointing
+ * to the specified row. Useful for showing "backlinks" or "linked from" sections.
+ *
+ * @example
+ * ```tsx
+ * const { relations, loading, error } = useReverseRelations(taskId, tasksDatabaseId)
+ * // relations contains all rows that link to this task
+ * ```
+ */
+
+interface ReverseRelation {
+    /** The row that links to the target row */
+    row: DatabaseRow;
+    /** The relation column through which it links */
+    column: ColumnDefinition;
+    /** ID of the source database */
+    sourceDatabaseId: string;
+    /** Title of the source database */
+    sourceDatabaseTitle: string;
+}
+interface UseReverseRelationsResult {
+    /** Found reverse relations */
+    relations: ReverseRelation[];
+    /** Whether relations are loading */
+    loading: boolean;
+    /** Any error that occurred */
+    error: Error | null;
+    /** Refetch the relations */
+    refetch: () => void;
+}
+/**
+ * Hook for finding reverse relations (backlinks) to a row.
+ *
+ * @param rowId - The row ID to find links to
+ * @param databaseId - The database containing the row
+ * @returns Object containing relations, loading state, and error
+ */
+declare function useReverseRelations(rowId: string, databaseId: string): UseReverseRelationsResult;
+
+/**
+ * useDatabaseSchema - Hook for database-defined schema access
+ *
+ * Provides reactive access to a database's schema metadata and properties.
+ * Works with the schema registry to resolve database-defined schemas.
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   schema,
+ *   metadata,
+ *   loading,
+ *   error
+ * } = useDatabaseSchema(databaseId)
+ *
+ * // Access schema version
+ * console.log(metadata?.version) // "1.2.0"
+ *
+ * // Access schema properties
+ * schema?.properties.forEach(prop => console.log(prop.name))
+ * ```
+ */
+
+interface UseDatabaseSchemaResult {
+    /** The resolved Schema object, or null if not loaded */
+    schema: Schema | null;
+    /** The schema metadata from the database's Y.Doc */
+    metadata: DatabaseSchemaMetadata | null;
+    /** The schema IRI for this database */
+    schemaIRI: string | null;
+    /** Whether the schema is loading */
+    loading: boolean;
+    /** Any error that occurred */
+    error: Error | null;
+    /** Force refresh the schema */
+    refresh: () => void;
+}
+/**
+ * Hook for accessing a database's schema.
+ *
+ * Loads the database's Y.Doc, extracts schema metadata and columns,
+ * builds the Schema object, and registers it with the schema registry.
+ *
+ * @param databaseId - The database node ID
+ * @returns The schema, metadata, and loading state
+ */
+declare function useDatabaseSchema(databaseId: string | undefined): UseDatabaseSchemaResult;
+
+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;
+
+/**
+ * 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;
+    /** 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;
+
+/**
+ * Connection Manager - Multiplexed WebSocket connection for all tracked Nodes
+ *
+ * Instead of one WebSocket per Node (current WebSocketSyncProvider approach),
+ * the Connection Manager maintains a single WebSocket subscribed to multiple
+ * rooms. This reduces connection count from O(N) to O(1).
+ *
+ * The signaling protocol supports multi-room subscriptions:
+ *   { type: "subscribe", topics: ["xnet-doc-abc", "xnet-doc-def"] }
+ */
+type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
+interface ConnectionManagerConfig {
+    /** Signaling/hub WebSocket URL */
+    url: string;
+    /** Reconnect delay in ms (default: 2000) */
+    reconnectDelay?: number;
+    /** Max reconnect attempts (default: Infinity) */
+    maxReconnects?: number;
+    /** UCAN token for hub auth */
+    ucanToken?: string;
+    /** Async UCAN token provider (preferred for rotation) */
+    getUCANToken?: () => Promise<string>;
+}
+type RoomHandler = (data: Record<string, unknown>) => void;
+type StatusHandler = (status: ConnectionStatus) => void;
+interface RoomJoinResult {
+    /** Unsubscribe function */
+    unsubscribe: () => void;
+    /** Promise that resolves when server confirms subscription */
+    ready: Promise<void>;
+}
+interface ConnectionManager {
+    /** Current connection status */
+    readonly status: ConnectionStatus;
+    /** Connect to the signaling server */
+    connect(): void;
+    /** Disconnect and cleanup */
+    disconnect(): void;
+    /** Subscribe to a room (returns unsubscribe function) */
+    joinRoom(room: string, handler: RoomHandler): () => void;
+    /** Subscribe to a room with confirmation (returns cleanup and ready promise) */
+    joinRoomAsync(room: string, handler: RoomHandler): RoomJoinResult;
+    /** Leave a room */
+    leaveRoom(room: string): void;
+    /** Publish a message to a room */
+    publish(room: string, data: object): void;
+    /** Send a raw message on the WebSocket */
+    sendRaw(message: object): void;
+    /** Listen for non-room messages */
+    onMessage(handler: (message: Record<string, unknown>) => void): () => void;
+    /** Listen for status changes */
+    onStatus(handler: StatusHandler): () => void;
+    /** Number of active room subscriptions */
+    readonly roomCount: number;
+}
+declare function createConnectionManager(config: ConnectionManagerConfig): ConnectionManager;
+
+/**
+ * Blob Sync Provider - Handles blob synchronization between peers.
+ *
+ * Integrates with the Background Sync Manager's ConnectionManager to send
+ * blob have/want/data messages over the same multiplexed WebSocket connection
+ * used for Y.Doc sync. Uses a dedicated room for blob sync messages.
+ *
+ * Protocol:
+ *   blob-have: Announce available CIDs to peers
+ *   blob-want: Request missing blobs by CID
+ *   blob-data: Transfer blob bytes (base64 encoded)
+ *   blob-not-found: Signal unavailability
+ */
+
+/** Minimal blob store interface for sync (satisfied by BlobStore from @xnetjs/storage) */
+interface BlobStoreForSync {
+    get(cid: ContentId): Promise<Uint8Array | null>;
+    put(data: Uint8Array): Promise<ContentId>;
+    has(cid: ContentId): Promise<boolean>;
+}
+
+/**
+ * Sync Manager - Top-level orchestrator for Background Sync
+ *
+ * Wires together Node Pool, Registry, and Connection Manager into a cohesive
+ * sync service. Handles the Yjs sync protocol (state vectors, diffs, incremental
+ * updates) for each tracked Node.
+ *
+ * Components acquire Y.Docs via the SyncManager (through useNode). When released,
+ * docs stay alive in the pool and continue syncing in the background.
+ */
+
+type SyncStatus = ConnectionStatus;
+interface SyncManagerConfig {
+    /** NodeStore for meta bridge */
+    nodeStore: NodeStore;
+    /** Storage adapter for pool persistence (Y.Doc content) */
+    storage: NodeStorageAdapter;
+    /** Signaling/hub WebSocket URL */
+    signalingUrl: string;
+    /** Max Y.Docs in memory (default: 50) */
+    poolSize?: number;
+    /** TTL for tracked Nodes in ms (default: 7 days) */
+    trackTTL?: number;
+    /** Author DID for awareness */
+    authorDID?: string;
+    /** Blob store for P2P blob sync (optional — if omitted, blob sync is disabled) */
+    blobStore?: BlobStoreForSync;
+    /** Optional UCAN token for hub auth */
+    ucanToken?: string;
+    /** Optional UCAN token provider for hub auth */
+    getUCANToken?: () => Promise<string>;
+    /** Optional pool update callback */
+    onDocUpdate?: (nodeId: string, doc: Y.Doc) => void;
+    /** Optional pool eviction callback */
+    onDocEvict?: (nodeId: string, doc: Y.Doc) => void;
+    /** Optional room for node-change relay (enables NodeStore sync via hub) */
+    nodeSyncRoom?: string;
+}
+interface SyncManager {
+    /** Start the sync manager (connect, load registry, sync tracked Nodes) */
+    start(): Promise<void>;
+    /** Stop (disconnect, flush, save registry) */
+    stop(): Promise<void>;
+    /** Track a Node for background sync */
+    track(nodeId: string, schemaId: string): void;
+    /** Stop tracking a Node */
+    untrack(nodeId: string): void;
+    /** Acquire a Y.Doc (used by useNode) */
+    acquire(nodeId: string): Promise<Y.Doc>;
+    /** Release a Y.Doc (component unmounted) */
+    release(nodeId: string): void;
+    /** Get awareness for a Node (for cursor presence) */
+    getAwareness(nodeId: string): Awareness | null;
+    /** Listen for awareness snapshots from the hub */
+    onAwarenessSnapshot(nodeId: string, handler: (users: AwarenessSnapshotUser[]) => void): () => void;
+    /** Request blobs from peers by CID (no-op if blob sync is disabled) */
+    requestBlobs(cids: string[]): Promise<void>;
+    /** Announce blob CIDs to peers (no-op if blob sync is disabled) */
+    announceBlobs(cids: string[]): void;
+    /** Connection status */
+    readonly status: SyncStatus;
+    /** Pool stats */
+    readonly poolSize: number;
+    /** Tracked count */
+    readonly trackedCount: number;
+    /** Offline queue size */
+    readonly queueSize: number;
+    /** Pending blob requests */
+    readonly pendingBlobCount: number;
+    /** Listen for events */
+    on(event: 'status', handler: (status: SyncStatus) => void): () => void;
+    /** Underlying ConnectionManager (if available) */
+    readonly connection?: ConnectionManager;
+}
+type AwarenessSnapshotUser = {
+    did: string;
+    state: {
+        user?: {
+            name?: string;
+            color?: string;
+            avatar?: string;
+            did?: string;
+        };
+        cursor?: {
+            anchor: number;
+            head: number;
+        };
+        selection?: unknown;
+        online?: boolean;
+        [key: string]: unknown;
+    };
+    lastSeen: number;
+    isStale: boolean;
+};
+declare function createSyncManager(config: SyncManagerConfig): SyncManager;
+
+/**
+ * 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>;
+}
+declare function useGrants(nodeId: string): UseGrantsResult;
+
+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;
+
+/**
+ * Global error boundary for xNet React apps.
+ *
+ * Catches unhandled React render errors and displays a recovery UI
+ * instead of crashing the entire app tree.
+ */
+
+type ErrorBoundaryFallbackProps = {
+    error: Error;
+    reset: () => void;
+};
+type ErrorBoundaryProps = {
+    children: ReactNode;
+    /** Custom fallback UI. Receives error + reset function. If omitted, a default error screen is shown. */
+    fallback?: ReactNode | ((props: ErrorBoundaryFallbackProps) => ReactNode);
+    /** Callback fired when an error is caught. */
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+    /** Change this value to force a reset (e.g. after navigation). */
+    resetKey?: string | number;
+};
+type ErrorBoundaryState = {
+    hasError: boolean;
+    error: Error | null;
+};
+declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: ErrorBoundaryState;
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    private handleReset;
+    componentDidUpdate(prevProps: ErrorBoundaryProps): void;
+    render(): ReactNode;
+}
+
+/**
+ * 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;
+
+type OfflineIndicatorProps = {
+    /** Custom message. Default: 'You are offline. Changes will sync when reconnected.' */
+    message?: string;
+    /** Additional CSS class. */
+    className?: string;
+    /** Position. Default: 'bottom'. */
+    position?: 'top' | 'bottom';
+};
+/** Returns true when the browser is offline. */
+declare function useIsOffline(): boolean;
+declare function OfflineIndicator({ message, className, position }: OfflineIndicatorProps): JSX.Element | null;
+
+/**
+ * WebSocketSyncProvider - Syncs Y.Doc via WebSocket relay
+ *
+ * Unlike y-webrtc (which uses WebRTC DataChannels for P2P), this provider
+ * relays all Yjs updates through the signaling server. This works in all
+ * environments (same-machine, different networks, behind NATs) at the cost
+ * of server-relayed traffic.
+ *
+ * Protocol (extends the y-webrtc signaling protocol):
+ * - Uses the same subscribe/publish mechanism as y-webrtc signaling
+ * - Sync messages are published as JSON with base64-encoded binary data
+ * - Message types: 'sync-step1', 'sync-step2', 'sync-update', 'awareness'
+ *
+ * Sync flow:
+ * 1. On connect: subscribe to room, broadcast sync-step1 (state vector)
+ * 2. On receiving sync-step1: respond with sync-step2 (diff for their vector)
+ * 3. On local update: broadcast sync-update to room
+ * 4. On receiving sync-update: apply to local doc
+ *
+ * Awareness flow:
+ * 1. On connect: broadcast local awareness state
+ * 2. On awareness change: broadcast updated state
+ * 3. On receiving awareness: apply to local awareness instance
+ * 4. On disconnect: peers remove the disconnected client's state
+ */
+
+interface WebSocketSyncProviderOptions {
+    /** WebSocket URL of the signaling/relay server */
+    url: string;
+    /** Room name (peers in the same room sync together) */
+    room: string;
+    /** Reconnect delay in ms (default: 2000) */
+    reconnectDelay?: number;
+    /** Maximum reconnect attempts (default: Infinity) */
+    maxReconnectAttempts?: number;
+}
+type SyncEventType = 'status' | 'synced' | 'peers' | 'awareness-snapshot';
+type SyncEventHandler = (event: unknown) => void;
+declare class WebSocketSyncProvider {
+    readonly doc: Y.Doc;
+    readonly room: string;
+    readonly url: string;
+    readonly awareness: Awareness;
+    private ws;
+    private reconnectDelay;
+    private maxReconnectAttempts;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private destroyed;
+    private connected;
+    private synced;
+    private peerId;
+    private remotePeerIds;
+    private eventHandlers;
+    constructor(doc: Y.Doc, options: WebSocketSyncProviderOptions);
+    get isConnected(): boolean;
+    get isSynced(): boolean;
+    /** Helper to get XML fragment length for debug logging */
+    private _getFragmentLength;
+    on(event: SyncEventType, handler: SyncEventHandler): void;
+    off(event: SyncEventType, handler: SyncEventHandler): void;
+    private emit;
+    destroy(): void;
+    private _connect;
+    private _scheduleReconnect;
+    private _send;
+    private _publish;
+    /** Handle incoming sync messages from other peers */
+    private _handleSyncMessage;
+    /** Broadcast local doc updates to peers */
+    private _onDocUpdate;
+    /** Broadcast local awareness changes to peers */
+    private _onAwarenessUpdate;
+}
+
+/**
+ * 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;
+
+/**
+ * Meta Bridge - Unidirectional sync from NodeStore → Y.Doc meta map
+ *
+ * SECURITY: This bridge is intentionally ONE-WAY. The Y.Doc meta map is a
+ * read-only cache for the editor UI. Property changes MUST go through the
+ * signed NodeChange pipeline (via mutate()), never through Yjs.
+ *
+ * Before (VULNERABLE):
+ *   NodeStore ↔ MetaBridge ↔ Y.Doc meta
+ *   (Malicious Yjs updates could poison NodeStore!)
+ *
+ * After (SECURE):
+ *   NodeStore → MetaBridge → Y.Doc meta (write)
+ *   Y.Doc meta → Editor UI (read-only display)
+ *   Editor UI → mutate() → NodeStore (signed writes)
+ *
+ * See: docs/plans/plan03_4_1YjsSecurity/04-metabridge-isolation.md
+ */
+
+/** Transaction origin for MetaBridge writes (for debugging/monitoring) */
+declare const METABRIDGE_ORIGIN = "metabridge";
+declare const METABRIDGE_SEED_ORIGIN = "metabridge-seed";
+interface MetaBridge {
+    /**
+     * Start observing NodeStore changes for a Node and syncing to Y.Doc meta.
+     * Direction: NodeStore → Y.Doc meta map (ONE-WAY)
+     *
+     * @returns Unsubscribe function
+     */
+    observe(nodeId: string, doc: Y.Doc): () => void;
+    /**
+     * Seed the Y.Doc meta map with current NodeStore state.
+     * Called on document open to populate editor UI.
+     */
+    seed(nodeId: string, doc: Y.Doc): Promise<void>;
+    /**
+     * @deprecated Use seed() instead. applyNow() was the bidirectional API.
+     * This is kept for backward compatibility but now just calls seed().
+     */
+    applyNow(nodeId: string, doc: Y.Doc): Promise<void>;
+}
+/**
+ * Create a unidirectional MetaBridge.
+ *
+ * @param store - NodeStore to observe
+ * @param options - Configuration options
+ */
+declare function createMetaBridge(store: NodeStore, options?: {
+    /** Log warnings for non-MetaBridge meta map changes (default: true) */
+    warnOnExternalMetaChanges?: boolean;
+}): MetaBridge;
+
+/**
+ * Node Pool - LRU cache of Y.Doc instances with acquire/release semantics
+ *
+ * Components acquire a Y.Doc when they need it and release it when they unmount.
+ * Released Y.Docs stay in the pool (warm state) and continue receiving sync
+ * updates via the Connection Manager.
+ *
+ * States:
+ * - Active: refCount > 0, never evicted
+ * - Warm: refCount = 0, evictable (LRU)
+ * - Cold: evicted, serialized to storage (load on demand)
+ */
+
+type PoolEntryState = 'active' | 'warm' | 'cold';
+interface NodePoolConfig {
+    /** Storage adapter for persisting Y.Doc state */
+    storage: NodeStorageAdapter;
+    /** Meta bridge for syncing properties to NodeStore */
+    metaBridge: MetaBridge;
+    /** Max warm entries before LRU eviction (default: 50) */
+    maxWarm?: number;
+    /** Debounce delay for persisting dirty docs (default: 2000ms) */
+    persistDelay?: number;
+    /** Optional callback when a doc is updated */
+    onDocUpdate?: (nodeId: string, doc: Y.Doc) => void;
+    /** Optional callback before a doc is evicted */
+    onDocEvict?: (nodeId: string, doc: Y.Doc) => void;
+}
+interface NodePool {
+    /** Acquire a Y.Doc for a Node (load from storage or create new) */
+    acquire(nodeId: string): Promise<Y.Doc>;
+    /** Release a Y.Doc (component unmounted, doc stays warm) */
+    release(nodeId: string): void;
+    /** Check if a Node is in the pool */
+    has(nodeId: string): boolean;
+    /** Get pool entry state */
+    getState(nodeId: string): PoolEntryState | null;
+    /** Number of entries currently in memory */
+    readonly size: number;
+    /** Force-persist all dirty docs */
+    flushAll(): Promise<void>;
+    /** Destroy pool, persist all docs, cleanup */
+    destroy(): Promise<void>;
+}
+declare function createNodePool(config: NodePoolConfig): NodePool;
+
+/**
+ * NodeStoreSyncProvider - Sync NodeChange events via hub ConnectionManager.
+ */
+
+type SerializedNodeChange = {
+    id: string;
+    type: string;
+    hash: string;
+    room: string;
+    nodeId: string;
+    schemaId?: string;
+    lamportTime: number;
+    lamportAuthor: string;
+    authorDid: string;
+    wallTime: number;
+    parentHash: string | null;
+    payload: NodePayload;
+    signatureB64: string;
+    batchId?: string;
+    batchIndex?: number;
+    batchSize?: number;
+};
+type NodeSyncResponse = {
+    type: 'node-sync-response';
+    room: string;
+    changes: SerializedNodeChange[];
+    highWaterMark: number;
+};
+/**
+ * Listener for unknown change type events.
+ */
+type UnknownChangeTypeListener = (change: NodeChange, peerId: string) => void;
+declare class NodeStoreSyncProvider {
+    private store;
+    private room;
+    private lastSyncedLamport;
+    private connection;
+    private roomCleanup;
+    private statusCleanup;
+    private messageCleanup;
+    private storeCleanup;
+    private unknownChangeTypeListeners;
+    constructor(store: NodeStore, room: string);
+    /**
+     * Subscribe to unknown change type events.
+     * These are changes received from peers with types this version doesn't know how to process.
+     * The changes are still stored in the change log for forward compatibility.
+     *
+     * @param listener - Callback invoked when an unknown change type is received
+     * @returns Unsubscribe function
+     */
+    onUnknownChangeType(listener: UnknownChangeTypeListener): () => void;
+    private emitUnknownChangeType;
+    attach(connection: ConnectionManager): void;
+    detach(): void;
+    private handleRoomMessage;
+    private handleDirectMessage;
+    private requestSync;
+    private syncLocalChanges;
+    private broadcastChange;
+    private handleRemoteChange;
+    private handleSyncResponse;
+    private serializeChange;
+    private deserializeChange;
+}
+
+/**
+ * Registry - Persistent tracked-Node set that survives app restarts
+ *
+ * The Registry maintains the set of Nodes the BSM should keep synced.
+ * Nodes are added automatically when opened and expire after a configurable TTL.
+ * Pinned Nodes never expire.
+ */
+interface TrackedNode {
+    nodeId: string;
+    schemaId: string;
+    /** When the user last opened this Node */
+    lastOpened: number;
+    /** When sync last completed for this Node */
+    lastSynced: number;
+    /** Whether explicitly pinned (never expires) */
+    pinned: boolean;
+}
+interface RegistryStorage {
+    get(key: string): Promise<TrackedNode[] | null>;
+    set(key: string, entries: TrackedNode[]): Promise<void>;
+}
+interface RegistryConfig {
+    /** Storage adapter for persistence */
+    storage: RegistryStorage;
+    /** TTL for tracked Nodes in ms (default: 7 days) */
+    trackTTL?: number;
+    /** Storage key for the tracked set */
+    storageKey?: string;
+}
+interface Registry {
+    /** Add a Node to the tracked set */
+    track(nodeId: string, schemaId: string): void;
+    /** Remove a Node from the tracked set */
+    untrack(nodeId: string): void;
+    /** Pin a Node (never expires) */
+    pin(nodeId: string): void;
+    /** Unpin a Node (subject to TTL expiry) */
+    unpin(nodeId: string): void;
+    /** Mark a Node as recently opened (refreshes TTL) */
+    touch(nodeId: string): void;
+    /** Mark a Node as synced */
+    markSynced(nodeId: string): void;
+    /** Get all tracked Nodes (excluding expired) */
+    getTracked(): TrackedNode[];
+    /** Check if a Node is tracked */
+    isTracked(nodeId: string): boolean;
+    /** Load from storage */
+    load(): Promise<void>;
+    /** Persist to storage */
+    save(): Promise<void>;
+    /** Remove expired entries */
+    prune(): number;
+}
+declare function createRegistry(config: RegistryConfig): Registry;
+
+/**
+ * Offline Queue - Persistent queue for Y.Doc updates made while disconnected
+ *
+ * When the network is unavailable, local Y.Doc updates are queued in persistent
+ * storage. On reconnect, the queue is drained (replayed in order). This ensures
+ * no local changes are lost, even across app restarts.
+ */
+
+interface QueueEntry {
+    /** Node ID this update belongs to */
+    nodeId: string;
+    /** Serialized Y.Doc update (base64 encoded) */
+    update: string;
+    /** Timestamp when queued */
+    queuedAt: number;
+}
+interface OfflineQueueConfig {
+    /** Storage adapter for persistence */
+    storage: NodeStorageAdapter;
+    /** Storage key for the queue (default: '_xnet_offline_queue') */
+    storageKey?: string;
+    /** Max queue size before dropping oldest entries (default: 1000) */
+    maxSize?: number;
+}
+interface OfflineQueue {
+    /** Enqueue an update for later broadcast */
+    enqueue(nodeId: string, update: Uint8Array): Promise<void>;
+    /** Drain the queue, calling handler for each entry. Returns count drained. */
+    drain(handler: (entry: QueueEntry) => Promise<void>): Promise<number>;
+    /** Number of entries in the queue */
+    readonly size: number;
+    /** Load queue from storage */
+    load(): Promise<void>;
+    /** Persist queue to storage */
+    save(): Promise<void>;
+    /** Clear all entries */
+    clear(): Promise<void>;
+}
+declare function createOfflineQueue(config: OfflineQueueConfig): OfflineQueue;
+
+/**
+ * useIdentity hook for identity access
+ */
+
+/**
+ * Result from useIdentity hook
+ */
+interface UseIdentityResult {
+    identity: Identity | null;
+    isAuthenticated: boolean;
+    did: string | null;
+}
+/**
+ * Hook for accessing current identity
+ */
+declare function useIdentity(): UseIdentityResult;
+
+/**
+ * @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' | '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 OnboardingMachineContext = {
+    identity: Identity | null;
+    keyBundle: KeyBundle | null;
+    hubUrl: string | null;
+    error: Error | null;
+    isDemo: boolean;
+};
+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;
+
+/**
+ * @xnetjs/react/sync - Initial sync manager for new device onboarding
+ *
+ * Orchestrates the full state sync when a new device connects to the hub
+ * with an existing identity. Tracks progress and provides callbacks.
+ */
+type SyncPhase = 'connecting' | 'syncing' | 'complete' | 'error';
+type SyncProgress = {
+    /** Current phase of the sync process */
+    phase: SyncPhase;
+    /** Total rooms discovered on the hub */
+    roomsTotal: number;
+    /** Rooms that have been fully synced */
+    roomsSynced: number;
+    /** Total bytes received from hub */
+    bytesReceived: number;
+    /** Error if phase === 'error' */
+    error?: Error;
+};
+type InitialSyncMessage = {
+    type: 'initial-sync' | 'node-changes' | 'initial-sync-complete';
+    room?: string;
+    update?: Uint8Array;
+    changes?: unknown[];
+    roomCount?: number;
+};
+type ProgressListener = (progress: SyncProgress) => void;
+/**
+ * Manages the initial sync process for a new device.
+ *
+ * Usage:
+ * ```ts
+ * const manager = createInitialSyncManager()
+ * const unsub = manager.onProgress((p) => updateUI(p))
+ *
+ * // Feed messages from the hub WebSocket:
+ * manager.handleMessage({ type: 'initial-sync', room: 'r1', update: ... })
+ * manager.handleMessage({ type: 'initial-sync-complete', roomCount: 5 })
+ *
+ * unsub()
+ * ```
+ */
+type InitialSyncManager = {
+    /** Subscribe to progress updates */
+    onProgress(listener: ProgressListener): () => void;
+    /** Handle an incoming sync message from the hub */
+    handleMessage(msg: InitialSyncMessage): void;
+    /** Get current progress snapshot */
+    getProgress(): SyncProgress;
+    /** Mark sync as started (connecting phase) */
+    start(): void;
+    /** Mark sync as errored */
+    setError(error: Error): void;
+    /** Reset to initial state */
+    reset(): void;
+};
+declare function createInitialSyncManager(): InitialSyncManager;
+
+/**
+ * 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>;
+
+/**
+ * Telemetry context for @xnetjs/react
+ *
+ * Provides an optional duck-typed TelemetryReporter to the React tree.
+ * When present, hooks report performance timing, usage counts, and errors.
+ *
+ * Uses the same duck-typed interface pattern as other xNet packages to
+ * avoid circular dependencies with @xnetjs/telemetry.
+ */
+/**
+ * Duck-typed interface for telemetry reporting.
+ * Satisfied by @xnetjs/telemetry's TelemetryCollector or any compatible object.
+ *
+ * @example
+ * ```ts
+ * import { TelemetryCollector } from '@xnetjs/telemetry'
+ * const telemetry = new TelemetryCollector({ consent })
+ * // Pass to XNetProvider via config.telemetry
+ * ```
+ */
+interface TelemetryReporter {
+    reportPerformance(metricName: string, durationMs: number): void;
+    reportUsage(metricName: string, count: number): void;
+    reportCrash(error: Error, context?: Record<string, unknown>): void;
+}
+declare const TelemetryContext: react.Context<TelemetryReporter | null>;
+/**
+ * Hook to access the telemetry reporter (null if no telemetry configured).
+ * @internal Used by useQuery/useMutate - not part of public API.
+ */
+declare function useTelemetryReporter(): TelemetryReporter | null;
+
+/**
+ * XNet React context provider
+ *
+ * Provides NodeStore and optional identity to the React tree.
+ * All data access happens through useQuery/useMutate/useNode hooks.
+ */
+
+/**
+ * XNet configuration
+ */
+interface XNetConfig {
+    /** Node storage adapter for NodeStore (defaults to MemoryNodeStorageAdapter) */
+    nodeStorage?: NodeStorageAdapter;
+    /** Author's DID for signing changes */
+    authorDID?: DID;
+    /** Ed25519 signing key */
+    signingKey?: Uint8Array;
+    /** User identity */
+    identity?: Identity;
+    /** Signaling server URLs for sync (default: ['ws://localhost:4444']) */
+    signalingServers?: string[];
+    /** Hub WebSocket URL for always-on sync (overrides signalingServers[0]) */
+    hubUrl?: string;
+    /** Hub integration options */
+    hubOptions?: {
+        /** Auto-generate UCAN for hub auth (default: true) */
+        autoAuth?: boolean;
+        /** Static UCAN token override for pre-authorized share sessions */
+        authToken?: string;
+        /** Enable auto-backup on document updates (default: false) */
+        autoBackup?: boolean;
+        /** Backup debounce delay in ms (default: 5000) */
+        backupDebounceMs?: number;
+        /** Enable search indexing on NodeStore changes (default: false) */
+        enableSearchIndex?: boolean;
+        /** Room name for node-change relay (defaults to author DID) */
+        nodeSyncRoom?: string;
+    };
+    /** Encryption key for hub backups (XChaCha20-Poly1305) */
+    encryptionKey?: Uint8Array;
+    /** Disable Background Sync Manager (default: false) */
+    disableSyncManager?: boolean;
+    /** Provide an external SyncManager (e.g., IPC-based for Electron desktop).
+     *  When provided, the internal SyncManager creation is skipped. */
+    syncManager?: SyncManager;
+    /** Blob store for P2P blob sync (images, files). If provided, the SyncManager
+     *  will sync blobs alongside Y.Doc state. Typically a BlobStore from @xnetjs/storage. */
+    blobStore?: BlobStoreForSync;
+    /** Platform for plugin compatibility ('web' | 'electron' | 'mobile'). Defaults to 'web'. */
+    platform?: Platform;
+    /** Disable plugin system (default: false) */
+    disablePlugins?: boolean;
+    /**
+     * Custom DataBridge instance.
+     *
+     * When provided, this bridge is used for data access instead of creating
+     * a MainThreadBridge. This allows using WorkerBridge or other off-main-thread
+     * implementations.
+     *
+     * The bridge must already be initialized before passing to XNetProvider.
+     *
+     * Note: When using a custom bridge, NodeStore is still created on the main
+     * thread for SyncManager and other integrations. The custom bridge is used
+     * only for React hook data access (useQuery, useMutate).
+     *
+     * @example
+     * ```tsx
+     * // Using WorkerBridge
+     * const bridge = new WorkerBridge(workerUrl)
+     * await bridge.initialize({ authorDID, signingKey, dbName: 'xnet' })
+     *
+     * <XNetProvider config={{ dataBridge: bridge, ... }}>
+     *   <App />
+     * </XNetProvider>
+     * ```
+     */
+    dataBridge?: DataBridge;
+    /**
+     * Security configuration for multi-level cryptography.
+     */
+    security?: {
+        /** Default security level for new signatures (default: 0 for Ed25519-only) */
+        level?: SecurityLevel;
+        /** Minimum acceptable level for verification (default: 0) */
+        minVerificationLevel?: SecurityLevel;
+        /** Verification policy (default: 'strict') */
+        verificationPolicy?: 'strict' | 'permissive';
+        /** Custom PQ key registry */
+        registry?: PQKeyRegistry;
+    };
+    /**
+     * Hybrid key bundle for multi-level cryptography.
+     *
+     * When provided, enables signing at higher security levels (1, 2).
+     * The bundle includes Ed25519 keys and optionally ML-DSA (post-quantum) keys.
+     *
+     * @example
+     * ```tsx
+     * const bundle = createKeyBundle({ includePQ: true })
+     *
+     * <XNetProvider config={{ keyBundle: bundle, ... }}>
+     *   <App />
+     * </XNetProvider>
+     * ```
+     */
+    keyBundle?: HybridKeyBundle;
+    /**
+     * Optional telemetry reporter for hook instrumentation.
+     *
+     * When provided, useQuery and useMutate hooks will report:
+     * - Query timing (first-load latency)
+     * - Cache hit/miss rates
+     * - Mutation success/failure rates
+     * - Subscription churn (mount/unmount frequency)
+     *
+     * Uses a duck-typed interface to avoid circular dependencies with @xnetjs/telemetry.
+     *
+     * @example
+     * ```tsx
+     * import { TelemetryCollector, ConsentManager } from '@xnetjs/telemetry'
+     * const consent = new ConsentManager()
+     * const telemetry = new TelemetryCollector({ consent })
+     *
+     * <XNetProvider config={{ telemetry, ... }}>
+     *   <App />
+     * </XNetProvider>
+     * ```
+     */
+    telemetry?: TelemetryReporter;
+}
+/**
+ * XNet context value
+ */
+interface XNetContextValue {
+    /** NodeStore for Node operations */
+    nodeStore: NodeStore | null;
+    /** Whether NodeStore is initialized */
+    nodeStoreReady: boolean;
+    /** User identity (if provided) */
+    identity?: Identity;
+    /** Author DID (resolved from config.authorDID or config.identity.did) */
+    authorDID: string | null;
+    /** Background Sync Manager (null if disabled or not yet initialized) */
+    syncManager: SyncManager | null;
+    /** Hub URL (if configured) */
+    hubUrl: string | null;
+    /** Hub connection status */
+    hubStatus: SyncStatus;
+    /** Hub connection (shares SyncManager connection when available) */
+    hubConnection: ConnectionManager | null;
+    /** Hub auth token provider (for HTTP requests) */
+    getHubAuthToken?: () => Promise<string>;
+    /** Encryption key for hub backups */
+    encryptionKey: Uint8Array | null;
+    /** Blob store for content-addressed storage (null if not configured) */
+    blobStore: BlobStoreForSync | null;
+    /** Plugin Registry (null if disabled or not yet initialized) */
+    pluginRegistry: PluginRegistry | null;
+}
+/**
+ * XNet provider props
+ */
+interface XNetProviderProps {
+    config: XNetConfig;
+    children: ReactNode;
+}
+/**
+ * XNet provider component
+ *
+ * Initializes NodeStore and provides it to the React tree.
+ */
+declare function XNetProvider({ config, children }: XNetProviderProps): JSX.Element;
+/**
+ * Hook to access XNet context
+ *
+ * @internal Used by useIdentity. Not part of public API.
+ */
+declare function useXNet(): XNetContextValue;
+
+/**
+ * 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;
+};
+/**
+ * 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 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 { type AddCommentOptions, AuthErrorScreen, AuthenticatingScreen, type BlobStoreForSync, type CommentNode, type CommentThread, type ConnectionManager, type ConnectionManagerConfig, type ConnectionStatus, type DatabaseRow, type DatabaseRowData, DemoBanner, type DemoBannerProps, DemoDataExpiredScreen, type DemoLimits, type DemoModeState, DemoQuotaIndicator, type DemoQuotaIndicatorProps, type DemoUsage, type DiscoveredPeer, ErrorBoundary, type ErrorBoundaryProps, type FileRef, type FlatNode, type FlattenNodeOptions, type GrantInput, HubConnectScreen, type HubSearchOptions, type HubSearchResult, type HubSearchState, HubStatusIndicator, ImportIdentityScreen, type InitialSyncManager, type InitialSyncMessage, METABRIDGE_ORIGIN, METABRIDGE_SEED_ORIGIN, type MetaBridge, type MigrationWarning, type MutateCreate, type MutateDelete, type MutateOp, type MutateRestore, type MutateUpdate, type NodePool, type NodePoolConfig, NodeStoreSyncProvider, type NodeSyncResponse, OfflineIndicator, type OfflineIndicatorProps, type OfflineQueue, type OfflineQueueConfig, type OnboardingContextValue, type OnboardingEvent, OnboardingFlow, type OnboardingFlowProps, type OnboardingMachineContext, OnboardingProvider, type OnboardingProviderProps, type OnboardingReducerState, type OnboardingState, PluginRegistryContext, type PoolEntryState, type PresenceUser, type ProgressListener, QUICK_START_TEMPLATES, type QueryFilter, type QueryListResult, type QuerySingleResult, type QueueEntry, type QuickStartTemplate, ReadyScreen, type Registry, type RegistryConfig, type RegistryStorage, type RemoteSchemaDefinition, type RemoteSchemaState, type ReplyContext, type ReverseRelation, type SecurityContextActions, type SecurityContextState, type SecurityContextValue, SecurityProvider, type SecurityProviderProps, type SerializedNodeChange, Skeleton, type SkeletonProps, SmartWelcome, type SortDirection, type SyncManager, type SyncManagerConfig, type SyncStatus as SyncManagerStatus, type SyncPhase, type SyncProgress, SyncProgressOverlay, type SyncProgressOverlayProps, type SyncStatus$1 as SyncStatus, TelemetryContext, type TelemetryReporter, type TrackedNode, UnsupportedBrowserScreen, type UseAuditOptions, type UseAuditResult, type UseBackupReturn, type UseBlameResult, type UseCanEditResult, type UseCanResult, type UseCellOptions, type UseCellResult, type UseCommentsOptions, type UseCommentsResult, type UseDatabaseDocResult, type UseDatabaseOptions, type UseDatabaseResult, type UseDatabaseRowResult, type UseDatabaseSchemaResult, type UseDiffResult, type UseFileUploadReturn, type UseGrantsResult, type UseHistoryResult, type UseIdentityResult, type UseMutateResult, type UseNodeOptions, type UseNodeResult, type UseRelatedRowsResult, type UseReverseRelationsResult, type UseSecurityOptions, type UseSecurityResult, type UseUndoOptions, type UseUndoResult, type UseVerificationResult, WebSocketSyncProvider, type WebSocketSyncProviderOptions, WelcomeScreen, type XNetConfig, type XNetContextValue, XNetProvider, type XNetProviderProps, copyToClipboard, createConnectionManager, createInitialState, createInitialSyncManager, createMetaBridge, createNodePool, createOfflineQueue, createRegistry, createSyncManager, flattenNode, flattenNodes, flattenNodesWithSchemaCheck, flattenUnknownSchemaNode, getPlatformAuthName, injectSkeletonStyles, onboardingReducer, truncateDid, useAudit, useBackup, useBlame, useCan, useCanEdit, useCell, useCommand, useCommands, useCommentCount, useCommentCounts, useComments, useContributions, useDatabase, useDatabaseDoc, useDatabaseRow, useDatabaseSchema, useDemoMode, useDiff, useEditorExtensions, useEditorExtensionsSafe, useFileUpload, useGrants, useHistory, useHubSearch, useHubStatus, useIdentity, useIsOffline, useMutate, useNode, useOnboarding, usePeerDiscovery, usePluginRegistry, usePluginRegistryOptional, usePlugins, useQuery, useRelatedRows, useRemoteSchema, useReverseRelations, useSecurity, useSecurityContext, useSecurityContextOptional, useSidebarItems, useSlashCommands, useSyncManager, useTelemetryReporter, useUndo, useVerification, useView, useViews, useXNet };