@xnetjs/data 0.0.2 → 0.1.0

package/dist/index.d.ts

@@ -1,4598 +1,274 @@
-import { DID as DID$1, AuthAction, AuthDecision, AuthTrace, PolicyEvaluator, ContentId, AuthDenyReason, RoleResolver, AuthCheckInput, SerializedAuthorization, AuthorizationDefinition, VectorClock, SignedUpdate } from '@xnetjs/core';
+export { a5 as ApplyNodeBatchInput, a6 as ApplyNodeBatchResult, b1 as AuthGrant, av as ConflictResult, ay as ContentKeyCache, ae as CountNodesOptions, H as CreateNodeOptions, C as CreateNodeStoreOptions, aX as DEFAULT_OFFLINE_POLICY, y as DID, D as DefinedSchema, ab as DeterministicNodeBatchWriteInput, m as DeterministicNodeImportDraft, aV as GRANT_SCHEMA_IRI, G as GetWithMigrationOptions, w as GrantIndex, b0 as GrantInput, aU as GrantRateLimiter, n as ImportDeterministicNodesOptions, o as ImportDeterministicNodesResult, a3 as ImportNodesOptions, I as InferCreateProps, Q as InferNode, K as InferProperties, J as InferPropertyType, W as LensOperation, Z as LensRegistry, L as ListNodesOptions, s as MergeConflict, M as MigratedNodeState, Y as MigrationError, az as MigrationInfo, X as MigrationResult, x as Node, aw as NodeBatchChangeEvent, u as NodeBatchChangeListener, a7 as NodeBatchIndexMode, a8 as NodeBatchNotificationMode, aa as NodeBatchPreflightResult, a9 as NodeBatchSyncMode, p as NodeBatchWriteInput, ac as NodeBatchWritePolicy, q as NodeBatchWriteResult, ad as NodeBatchWriteTimings, r as NodeChange, v as NodeChangeEvent, t as NodeChangeListener, ax as NodeContentCipher, i as NodeId, a0 as NodePayload, ar as NodeQueryCursor, aq as NodeQueryCursorOrderEntry, j as NodeQueryDescriptor, ao as NodeQueryMaterializedViewOptions, as as NodeQueryOptions, N as NodeQueryPageCountMode, ap as NodeQueryPageOptions, au as NodeQueryParityCheckMetadata, at as NodeQueryPlanMetadata, k as NodeQueryResult, am as NodeQuerySearchField, an as NodeQuerySearchFilter, al as NodeQuerySpatialFilter, af as NodeQuerySpatialPoint, ah as NodeQuerySpatialPointFields, ak as NodeQuerySpatialRadius, ag as NodeQuerySpatialRect, ai as NodeQuerySpatialRectFields, aj as NodeQuerySpatialWindow, h as NodeState, g as NodeStorageAdapter, f as NodeStoreOptions, O as OfflineAuthPolicy, P as PropertyBuilder, E as PropertyDefinition, $ as PropertyKey, a1 as PropertyTimestamp, B as PropertyType, a4 as RebuildNodeIndexesOptions, a as Schema, S as SchemaIRI, R as SchemaLens, aR as SchemaLookup, a2 as SetNodeOptions, c as SortDirection, aT as StoreAuth, e as StoreAuthAPI, b2 as StoreAuthError, b3 as StoreAuthErrorCode, a$ as StoreAuthKeyManager, aZ as StoreAuthOptions, a_ as StoreAuthStore, d as SystemOrderField, aO as TEMP_ID_PREFIX, aS as TempIdResolution, T as TransactionOperation, l as TransactionResult, U as UpdateNodeOptions, F as ValidationError, V as ValidationResult, aI as applyNodeQueryDescriptor, A as createNodeId, aA as createNodeQueryDescriptor, aQ as createSchemaLookup, aC as decodeNodeQueryCursor, aB as encodeNodeQueryCursor, aG as filterNodeQueryResults, aJ as getNodeQuerySearchTokens, aW as isGrantActive, z as isNode, aN as isTempId, _ as lensRegistry, aF as matchesNodeQueryDescriptor, aY as mergeOfflinePolicy, aK as nodeQueryDescriptorNeedsBoundedReload, aD as nodeQueryDescriptorToOptions, aP as resolveTempIds, aE as serializeNodeQueryDescriptor, aH as sortNodeQueryResults, aM as withoutNodeQueryMaterializedView, aL as withoutNodeQueryPagination } from './types-S-BJAKyK.js';
+import { FileRef } from './schema/index.js';
+export { ACCOUNT_RECORD_SCHEMA_IRI, ACCOUNT_SCHEMA_IRI, ACHIEVEMENT_SCHEMA_IRI, ACTIVITY_KINDS, ACTIVITY_SCHEMA_IRI, AbuseReport, AbuseReportSchema, Account, AccountClassId, AccountRecord, AccountRecordSchema, AccountSchema, Achievement, AchievementSchema, Activity, ActivityKind, ActivitySchema, AnchorData, AnchorType, Appeal, AppealSchema, BUDGET_SCHEMA_IRI, Budget, BudgetPeriod, BudgetSchema, BuiltInSchemaIRI, CHANNEL_KINDS, CONTACT_LIFECYCLE, CONTACT_SCHEMA_IRI, CRM_NAMESPACE, Canvas, CanvasObjectAnchor, CanvasObjectAnchorPlacement, CanvasPositionAnchor, CanvasSchema, CellAnchor, Channel, ChannelKind, ChannelNotifyTier, ChannelSchema, ChatMessage, ChatMessageSchema, CheckboxOptions, ColumnAnchor, Comment, CommentSchema, CommunityNote, CommunityNoteSchema, Contact, ContactLifecycle, ContactSchema, ContentProvenance, ContentProvenanceSchema, CoreSchemaResolver, CreatedByOptions, CreatedOptions, CrmVisibility, DEAL_CONTACT_ROLES, DEAL_CONTACT_ROLE_SCHEMA_IRI, DEAL_SCHEMA_IRI, DEAL_SOURCES, DEFAULT_CHANNEL_TIER, DEVICE_RECORD_SCHEMA_IRI, Dashboard, DashboardBreakpointId, DashboardLayoutItem, DashboardLayouts, DashboardSchema, DashboardTimeRange, DashboardVariablesState, DashboardWidgetInstance, DashboardWidgetRefresh, Database, DatabaseField, DatabaseFieldSchema, DatabaseRow, DatabaseRowSchema, DatabaseSchema, DatabaseSelectOption, DatabaseSelectOptionSchema, DatabaseView, DatabaseViewSchema, DateOptions, DateRange, DateRangeOptions, Deal, DealContactRole, DealContactRoleKind, DealContactRoleSchema, DealSchema, DealSource, DefineSchemaOptions, DeviceLike, DeviceRecord, DeviceRecordSchema, EXTENSION_FIELD_SCHEMA_IRI, EXTERNAL_ITEM_SCHEMA_IRI, EXTERNAL_ITEM_SOURCES, EXT_PREFIX, EffectiveExtensionField, EmailOptions, Experiment, ExperimentDesign, ExperimentPhase, ExperimentSchema, ExperimentStatus, ExtensionField, ExtensionFieldRecord, ExtensionFieldSchema, ExtensionRecord, ExternalItem, ExternalItemSchema, ExternalReference, ExternalReferenceSchema, FEED_ITEM_SCHEMA_IRI, FEED_SCHEMA_IRI, FOLDER_SCHEMA_IRI, FORECAST_CATEGORIES, Feed, FeedItem, FeedItemSchema, FeedSchema, FileOptions, Folder, FolderLike, FolderSchema, FolderTreeNode, ForecastCategory, GAME_ASSET_FORMATS, GAME_ASSET_MIME_TYPES, GAME_ASSET_SCHEMA_IRI, GAME_ECONOMY_ENTRY_SCHEMA_IRI, GAME_ITEM_SCHEMA_IRI, GAME_NAMESPACE, GAME_SCHEMA_IRIS, GameAsset, GameAssetFormat, GameAssetSchema, GameEconomyEntry, GameEconomyEntrySchema, GameItem, GameItemSchema, GameVisibility, GeoFeature, GeoFeatureCollection, GeoGeometry, GeoPosition, Grant, GrantSchema, IMPORT_BATCH_SCHEMA_IRI, INVENTORY_SCHEMA_IRI, ITEM_RARITIES, ImportBatch, ImportBatchSchema, ImportSource, InboxItemTriage, InboxState, InboxStateSchema, InboxWatermark, Inventory, InventorySchema, ItemRarity, JsonOptions, LINE_ITEM_SCHEMA_IRI, LedgerNodeIntent, LineItem, LineItemSchema, MATCH_RESULTS, MATCH_SESSION_SCHEMA_IRI, MAX_MENTION_DIDS, MAX_TAG_NAME_LENGTH, MEMORY_ITEM_SCHEMA_IRI, MEMORY_KINDS, MILESTONE_SCHEMA_IRI, Map, MapBasemapId, MapLayerGeometry, MapLayerSource, MapLayerSpec, MapLayerStyle, MapSchema, MapViewport, MatchResult, MatchSession, MatchSessionSchema, MediaAsset, MediaAssetSchema, MemoryItem, MemoryItemSchema, MemoryKind, Mention, MessageMentions, MessageRequest, MessageRequestSchema, Metric, MetricKind, MetricPolarity, MetricScheduleId, MetricSchema, Milestone, MilestoneSchema, ModerationLabel, ModerationLabelSchema, MoneyOptions, MoneyValue, MultiSelectOptions, NODE_VISIBILITY, NodeAnchor, NodeVisibility, NoteRating, NoteRatingSchema, NotificationPrefs, NumberOptions, ORGANIZATION_SCHEMA_IRI, ORGANIZATION_SIZES, Observation, ObservationPhase, ObservationSchema, Organization, OrganizationSchema, OrganizationSize, OrphanReason, OrphanResolvers, OrphanStatus, PIPELINE_SCHEMA_IRI, PLAYER_IDENTITY_SCHEMA_IRI, POSTING_SCHEMA_IRI, PRODUCT_KINDS, PRODUCT_SCHEMA_IRI, Page, PageSchema, ParsedSystemNamespaceResource, ParsedTaskShortId, PersonOptions, PhoneOptions, Pipeline, PipelineSchema, PlayerIdentity, PlayerIdentitySchema, PolicyList, PolicyListSchema, PolicySubscription, PolicySubscriptionSchema, Posting, PostingSchema, PresenceAggregator, PresenceAggregatorOptions, PresenceAggregatorStore, PresenceCountBucket, PresenceSummary, PresenceSummaryDescriptor, PresenceSummarySchema, PresenceVisibility, PresenceVisibilityResolver, Product, ProductKind, ProductSchema, Profile, ProfileSchema, Project, ProjectSchema, PublicInteractionPolicy, PublicInteractionPolicySchema, QualitySignal, QualitySignalSchema, RECOVERY_RECORD_SCHEMA_IRI, RELATIONSHIP_KINDS, RELATIONSHIP_SCHEMA_IRI, REVOCATION_RECORD_SCHEMA_IRI, Reaction, ReactionSchema, RecoveryRecord, RecoveryRecordSchema, RelationOptions, Relationship, RelationshipKind, RelationshipSchema, ReviewTask, ReviewTaskSchema, RevocationLike, RevocationRecord, RevocationRecordSchema, RowAnchor, SCHEMA_EXTENSION_SCHEMA_IRI, SIDECAR_PREFIX, SPACE_KINDS, SPACE_MEMBERSHIP_SCHEMA_IRI, SPACE_ROLES, SPACE_SCHEMA_IRI, SPACE_VISIBILITY, STAGE_SCHEMA_IRI, SYSTEM_NAMESPACE_KINDS, SYSTEM_SCHEMA_BASE_IRIS, SYSTEM_SCHEMA_IRIS, SavedView, SavedViewSchema, SchemaAuthorityResolution, SchemaAuthorityResolutionKind, SchemaAuthorityResolutionOptions, SchemaCompatibility, SchemaCompatibilityMode, SchemaCompatibilitySchema, SchemaDefinition, SchemaDefinitionSchema, SchemaDefinitionSigningInput, SchemaDefinitionStatus, SchemaExtension, SchemaExtensionSchema, SelectOption, SelectOptions, SidecarOverlay, Space, SpaceKind, SpaceLike, SpaceMembership, SpaceMembershipSchema, SpaceRole, SpaceSchema, SpaceTreeNode, SpaceVisibility, Stage, StageSchema, SyncPolicy, SyncPolicySchema, SyncPolicyStatus, SystemFederationErrorCode, SystemNamespaceKind, SystemSchemaDefinitionRecord, SystemSchemaIndex, SystemSchemaIndexDiagnostic, SystemSchemaIndexOptions, SystemSchemaIndexStore, TAG_SCHEMA_IRI, TASK_SHORT_ID_PATTERN, TASK_STATUS_CATEGORIES, TRANSACTION_SCHEMA_IRI, TRANSCRIPTION_SCHEMA_IRI, Tag, TagSchema, Task, TaskSchema, TaskShortIdBlock, TaskStatusCategory, TaskStatusId, TaskView, TaskViewSchema, TextAnchor, TextOptions, Transaction, TransactionSchema, TransactionStatus, Transcription, TranscriptionSchema, TranscriptionSourceId, UpdatedOptions, UrlOptions, UserWidget, UserWidgetConfigField, UserWidgetSchema, UserWidgetSize, ValidateSchemaDefinitionNodeOptions, accountRecordId, accountState, addDefault, admitDeviceRecord, bucketPresenceCount, buildEffectiveSchema, buildFolderTree, buildSpaceTree, buildSystemNamespace, buildSystemNodeId, builtInSchemas, canManageSpace, canModifyColumn, checkOrphanStatus, checkbox, compareSpaceRoles, composeLens, computeSchemaDefinitionContentHash, convert, copy, createAccountRecord, createNodeGraphSchemaResolver, createOperations, createSchemaDefinitionSigningPayload, created, createdBy, crmSchemas, date, dateRange, decodeAnchor, defineSchema, deviceRecipientExpander, deviceRecordId, effectiveSpaceRole, email, encodeAnchor, extKey, extractMentions, file, filterOrphanedComments, findLockedColumns, flattenFolderTree, flattenSpaceTree, folderAncestorIds, folderPathIds, formatTaskShortId, gameSchemas, getMentionedUsers, getPresenceNoisePolicy, getTaskStatusCategory, identity, inboxStateNodeId, isCanvasObjectAnchor, isCanvasPositionAnchor, isCellAnchor, isColumnAnchor, isCompletedTaskStatus, isDeviceAuthorized, isExtKey, isMoneyValue, isNodeAnchor, isRowAnchor, isSchemaDefinitionNode, isSpaceRole, isSystemNamespaceResource, isSystemSchemaIri, isTextAnchor, isValidMentions, isValidTagName, json, loadExtensionFields, lockedPropertyKeys, mentionsInclude, merge, mergeSidecarsIntoRow, money, multiSelect, nextEpoch, normalizeMentions, normalizeTagName, number, parseExtKey, parseSystemNamespaceResource, parseTaskShortId, person, phone, promoteOverlay, recoveryRecordId, relation, remove, rename, resolveActiveDevices, resolveEffectiveSchema, resolveSchemaAuthority, revocationRecordId, revokeDeviceRecord, revokeSubjectRecord, revokedSubjects, schemaExtensionId, select, selectExtensionFields, shortIdsFromBlock, sidecarId, sidecarOverlayKeys, spaceAncestorIds, spaceMembershipId, spacePathIds, spaceRoleGrantActions, spaceRoleToShareRole, summarizePresenceNodes, taskBranchName, text, transform, updated, url, validateSchemaDefinitionNode, when, wouldCreateFolderCycle, wouldCreateSpaceCycle } from './schema/index.js';
+export { S as SchemaRegistry, s as schemaRegistry } from './registry-DunPv__d.js';
+export { SignUpdateOptions, applySignedUpdate, captureUpdate, getMissingUpdates, mergeDocuments, signUpdate, verifyUpdate } from './updates.js';
 import * as Y from 'yjs';
-import { Doc } from 'yjs';
-export { Array as YArray, Doc as YDoc, Map as YMap, Text as YText, XmlFragment as YXmlFragment } from 'yjs';
-import { Awareness } from 'y-protocols/awareness';
-import { PublicKeyResolver } from '@xnetjs/crypto';
-import { Change, LamportTimestamp } from '@xnetjs/sync';
-import { SQLiteAdapter } from '@xnetjs/sqlite';
+export { Array as YArray, Doc as YDoc, Map as YMap, Text as YText, XmlElement as YXmlElement, XmlFragment as YXmlFragment, XmlText as YXmlText } from 'yjs';
+export { CursorPosition, SelectionRange, UserPresence, clearLocalPresence, createAwareness, generateUserColor, getAllPresences, getLocalClientId, getRemotePresences, onPresenceChange, setLocalPresence } from './sync/awareness.js';
+export { G as QUERY_AST_VERSION, r as QueryAST, n as QueryASTAggregate, A as QueryASTAggregateExecution, m as QueryASTAggregateFunction, y as QueryASTAggregateGroup, x as QueryASTAggregatePlan, z as QueryASTAggregateResult, d as QueryASTComparisonPredicate, e as QueryASTCompoundPredicate, a as QueryASTField, l as QueryASTIncludes, p as QueryASTNodeQuery, s as QueryASTNodeQueryOptions, f as QueryASTNotPredicate, c as QueryASTOperator, h as QueryASTOrderBy, i as QueryASTPage, B as QueryASTPlannerGate, g as QueryASTPredicate, q as QueryASTQuerySet, o as QueryASTQuerySetAggregate, j as QueryASTRelationDirection, k as QueryASTRelationInclude, t as QueryASTRelationIncludeOptions, w as QueryASTRelationIndexRequirement, b as QueryASTSchemaInput, u as QueryASTValidationError, v as QueryASTValidationResult, Q as QueryASTVersion, S as SavedViewDescriptor, F as SavedViewFeedDensity, E as SavedViewFeedLayout, C as SavedViewPresentationHint, D as SavedViewPresentationHintMode, V as and, a3 as avg, N as between, P as contains, a0 as count, a1 as countDistinct, a9 as dashboardQuerySet, Z as defineNodeQueryAST, a8 as defineQuerySetAST, ab as defineSavedViewDescriptor, H as eq, aj as evaluateQueryASTPlannerGate, af as executeQueryASTLoadedAggregates, ag as filterQueryASTLoadedRows, _ as follow, $ as from, ah as getQueryASTRelationIndexRequirements, a6 as groupBy, J as gt, K as gte, a7 as having, O as includesAny, U as isNotNull, T as isNull, L as lt, M as lte, ai as matchesQueryASTLoadedRow, a5 as max, a4 as min, I as neq, X as not, W as or, ae as planQueryASTAggregates, Y as queryOperators, aa as querySetCount, R as startsWith, a2 as sum, ac as validateQueryAST, ad as validateSavedViewDescriptor } from './query-ast-C3m6kZYv.js';
+export { N as NodeStore } from './store-DtIDjk7c.js';
+export { MemoryNodeStorageAdapter, PermissionError, SQLiteAdaptiveIndexingOptions, SQLiteNodeStorageAdapter, SQLiteNodeStorageAdapterOptions, SQLiteQueryVerificationOptions, createNodeStorageAdapter } from './store/index.js';
+export { A as ActionPermission, b as DecisionCache, D as DefaultPolicyEvaluator, a as DefaultRoleResolver, G as GrantExpirationCleaner, H as HubPolicy, P as PermissionMatrix, R as RoleSummary, c as buildPermissionMatrix, d as describeRoleResolver, h as hubActionsForSpaceRole, s as schemaToHubPolicy } from './grant-expiration-cleaner-CY6BcmlR.js';
+import { ContentId } from '@xnetjs/core';
 import { ChunkManager } from '@xnetjs/storage';
-
-/**
- * Node - The universal container type for all data in xNet.
- *
- * A Node has only 4 universal fields. Everything else is defined by its schema.
- */
-/**
- * Schema IRI - globally unique identifier for a schema.
- * Format: xnet://<authority>/<name> or xnet://<authority>/<name>@<version>
- *
- * Examples:
- * - xnet://xnet.fyi/Page (unversioned, treated as @1.0.0)
- * - xnet://xnet.fyi/Task@1.0.0 (explicit version)
- * - xnet://xnet.fyi/Task@2.0.0 (newer version)
- * - xnet://acme-corp.com/Project@1.0.0 (organization schema)
- * - xnet://did:key:z6Mk.../Recipe@1.0.0 (personal schema)
- */
-type SchemaIRI = `xnet://${string}/${string}`;
-/**
- * Parsed schema IRI components.
- */
-interface ParsedSchemaIRI {
-    /** Full IRI including version */
-    iri: SchemaIRI;
-    /** Base IRI without version (e.g., xnet://xnet.fyi/Task) */
-    baseIRI: SchemaIRI;
-    /** Namespace (e.g., xnet://xnet.fyi/) */
-    namespace: string;
-    /** Schema name (e.g., Task) */
-    name: string;
-    /** Version (e.g., 1.0.0) - defaults to 1.0.0 if not present */
-    version: string;
-    /** Whether version was explicitly specified */
-    hasExplicitVersion: boolean;
-}
-/**
- * DID - Decentralized Identifier for user identity.
- */
-type DID = `did:key:${string}`;
-/**
- * The minimal universal Node interface.
- *
- * Only 4 fields are universal - everything else is schema-defined:
- * - id: Unique identifier
- * - schemaId: What type of node (IRI)
- * - createdAt: When created (for sync/attribution)
- * - createdBy: Who created it (for sync/attribution)
- */
-interface Node {
-    /** Unique identifier for this node */
+export { a as CELL_PREFIX, D as CellDateRange, F as CellFileRef, C as CellValue, d2 as CloneSchemaOptions, d3 as CloneSchemaResult, d4 as CloneSourceData, aY as ConvertContext, aZ as ConvertedCell, cY as CreateDatabaseSchemaResolverOptions, ag as CreateExtensionFieldOptions, a0 as CreateFieldOptions, h as CreateRowOptions, a2 as CreateSelectOptionOptions, ao as CreateViewOptions, bz as CsvExportOptions, bk as CsvParseOptions, cN as DATABASE_SCHEMA_NAMESPACE, cO as DATABASE_SCHEMA_PREFIX, aH as DEFAULT_DATABASE_SCHEMA_VERSION, aV as DatabaseDocumentModel, k as DatabaseRowNode, cQ as DatabaseSchemaMetadata, cX as DocFetcher, af as EnsureExtensionOptions, by as ExportRow, bC as ExportedColumn, bB as ExportedJSON, O as FIELD_TYPES, L as FieldConfig, N as FieldNode, K as FieldType, cf as FilterableRow, b6 as FormulaRow, b4 as FormulaService, b7 as FormulaValidationResult, ct as GroupAggregates, cr as GroupConfig, cq as GroupableRow, bm as InferredColumn, bA as JsonExportOptions, bn as JsonParseOptions, M as MAX_KEY_LENGTH, cP as MAX_VERSION_HISTORY, c4 as OPERATORS_BY_TYPE, c5 as OPERATOR_LABELS, bj as ParsedCSV, bl as ParsedJSON, cB as QueryOptions, cC as QueryResult, Q as QueryRowsOptions, j as QueryRowsResult, cA as QueryableRow, R as RICHTEXT_PREFIX, b3 as RollupContext, b2 as RollupRow, cs as RowGroup, P as SELECT_COLORS, cS as SchemaVersionEntry, S as SelectOptionNode, aG as SetupDatabaseResult, cl as SortableRow, cR as StoredColumn, a1 as UpdateFieldOptions, ap as UpdateViewOptions, cT as VersionBumpType, an as ViewNode, aP as addDefaultTableView, aO as addDefaultTitleColumn, cj as addOrToggleSort, bW as addViewSort, a_ as aggregate, V as autoColor, b0 as batchComputeRollups, cJ as buildDatabaseSchema, aJ as buildSchemaFromFields, cD as buildSchemaIRI, cH as bumpSchemaVersion, c as cellKey, aX as cellValueToText, s as checkNeedsRebalancing, bU as clearViewFilters, bY as clearViewSorts, c_ as cloneColumns, c$ as cloneSampleRows, cZ as cloneSchema, cp as collapseAllGroups, b as columnIdFromKey, cd as combineFiltersAnd, ce as combineFiltersOr, y as compareSortKeys, a$ as computeRollup, aW as convertCellValue, cc as createAnyOfFilter, bH as createColumn, br as createCsvBlob, cU as createDatabaseSchemaResolver, cb as createEqualsFilter, ac as createExtensionField, a6 as createField, cv as createFilterQuery, b5 as createFormulaService, cI as createInitialSchemaMetadata, bw as createJsonBlob, aL as createNodeDatabaseSchemaResolver, cx as createPaginatedQuery, l as createRow, aj as createSelectOption, ch as createSort, cw as createSortQuery, cK as createVersionEntry, bP as createView, as as createViewNode, bJ as deleteColumn, ae as deleteExtensionField, a8 as deleteField, aT as deleteMeta, I as deleteRichTextCell, n as deleteRow, al as deleteSelectOption, bR as deleteView, au as deleteViewNode, bs as downloadCsv, bx as downloadJson, bL as duplicateColumn, aa as duplicateField, bS as duplicateView, av as duplicateViewNode, aE as effectiveFieldSortKey, ab as ensureSchemaExtension, bp as escapeCSV, cu as executeQuery, co as expandAllGroups, bo as exportToCsv, bt as exportToJson, bu as exportToJsonArray, bv as exportToNdjson, cV as extractSchemaFromDoc, aI as fieldsToStoredColumns, ca as filterRows, cy as flattenGroups, bq as formatValue, f as fromCellProperties, d0 as generateColumnIdMap, v as generateSortKey, w as generateSortKeyWithJitter, bE as getColumn, bF as getColumnIndex, bD as getColumns, aU as getDatabaseDocumentModel, aK as getDatabaseSchemaIRI, ai as getDatabaseSelectOptions, a4 as getField, a3 as getFields, aR as getMeta, c8 as getOperatorLabel, c6 as getOperatorsForType, B as getRichTextCell, H as getRichTextColumnIds, J as getRichTextPlainText, o as getRow, cW as getSchemaIRIFromDoc, ah as getSelectOptions, bG as getTitleColumn, a5 as getTitleField, cz as getTotalFromGroups, cM as getVersionBumpType, bN as getView, bO as getViewByType, ar as getViewNode, aq as getViewNodes, bM as getViews, cm as groupRows, ba as guessColumnType, G as hasRichTextColumns, E as hasRichTextContent, c1 as hideColumn, bd as inferColumnTypes, bf as inferColumnsFromRows, bg as inferTypeFromValues, aM as initializeDatabaseDoc, Y as isAutoFieldType, d as isCellDateRange, e as isCellFileRef, i as isCellKey, g as isCellValue, X as isComputedFieldType, aN as isDatabaseDocInitialized, cF as isDatabaseSchemaIRI, T as isFieldType, W as isNodeStoreFieldType, U as isSelectColor, c7 as isValidOperator, x as isValidSortKey, Z as isYDocFieldType, a9 as moveField, p as moveRow, am as moveSelectOption, aw as moveView, A as needsRebalancing, c9 as operatorRequiresValue, b8 as parseCSV, b9 as parseCSVLine, cE as parseDatabaseSchemaIRI, be as parseJSON, bc as parseRow, bb as parseValue, cG as parseVersion, cL as pruneVersionHistory, q as queryRows, r as rebalanceDatabase, z as rebalanceSortKeys, d1 as remapViewColumnIds, ck as removeSort, bX as removeViewSort, ad as renameExtensionField, bK as reorderColumn, c2 as reorderViewColumns, c3 as setColumnWidth, aB as setFieldHidden, aS as setMeta, aD as setViewFieldOrder, aC as setViewFieldWidth, bT as setViewFilters, bZ as setViewGroupBy, ax as setViewNodeFilters, az as setViewNodeGroupBy, ay as setViewNodeSorts, bV as setViewSorts, b$ as setVisibleColumns, aF as setupDatabase, aQ as setupNewDatabase, c0 as showColumn, cg as sortRows, t as toCellProperties, bh as toColumnDefinitions, _ as toFieldNode, $ as toSelectOptionNode, b_ as toggleGroupCollapsed, cn as toggleGroupCollapsedState, ci as toggleSortDirection, aA as toggleViewGroupCollapsed, u as updateCell, m as updateCells, bI as updateColumn, a7 as updateField, ak as updateSelectOption, bQ as updateView, at as updateViewNode, bi as validateJsonData, b1 as validateRollupConfig } from './clone-C0Jhk2UN.js';
+export { d as ColumnConfig, c as ColumnDefinition, e as ColumnSelectOption, B as ColumnSummaryResult, C as ColumnType, I as DEFAULT_ROW_HEIGHT, D as DateColumnConfig, D as DateFieldConfig, E as EmptyConfig, b as FileColumnConfig, b as FileFieldConfig, n as FilterCondition, m as FilterGroup, o as FilterOperator, F as FormulaColumnConfig, F as FormulaFieldConfig, N as NumberColumnConfig, N as NumberFieldConfig, H as ROW_HEIGHTS, G as ROW_HEIGHT_PX, R as RelationColumnConfig, R as RelationFieldConfig, g as RollupAggregation, a as RollupColumnConfig, a as RollupFieldConfig, M as RowHeight, u as SUMMARY_FUNCTIONS_BY_TYPE, f as SelectColor, S as SelectColumnConfig, p as SortConfig, A as SummaryColumnLike, y as SummaryFunction, z as SummaryRow, T as TextColumnConfig, T as TextFieldConfig, l as ViewConfig, V as ViewType, L as asRowHeight, x as computeColumnSummary, j as isAutoColumnType, h as isComputedColumnType, w as isFilledValue, r as isFilterCondition, q as isFilterGroup, i as isNodeStoreColumnType, k as isYDocColumnType, t as requiresDateColumn, K as resolveRowHeightPx, J as rowHeightLabel, v as summaryFunctionLabel, s as supportsGrouping } from './view-types-DSde-uT_.js';
+import '@xnetjs/crypto';
+import '@xnetjs/sqlite';
+import '@xnetjs/sync';
+import 'y-protocols/awareness';
+
+/**
+ * Shared external-reference and embed parsing utilities.
+ *
+ * These helpers normalize URLs into source-backed external references so
+ * editor surfaces, task chips, and canvas drops all resolve the same
+ * provider, kind, metadata, and embed targets.
+ */
+type ExternalReferenceProvider = 'github' | 'figma' | 'youtube' | 'loom' | 'vimeo' | 'codesandbox' | 'spotify' | 'twitter' | 'instagram' | 'tiktok' | 'generic';
+type ExternalReferenceKind = 'issue' | 'pull-request' | 'design' | 'video' | 'sandbox' | 'social' | 'audio' | 'link';
+interface EmbedProvider {
+    name: ExternalReferenceProvider;
+    displayName: string;
+    icon: string;
+    patterns: RegExp[];
+    extractId: (url: string) => string | null;
+    getEmbedUrl: (id: string) => string;
+    aspectRatio?: number;
+}
+type ExternalReferenceDescriptor = {
+    normalizedUrl: string;
+    provider: ExternalReferenceProvider;
+    kind: ExternalReferenceKind;
+    refId?: string;
+    title: string;
+    subtitle?: string;
+    icon?: string;
+    embedUrl?: string;
+    metadata: Record<string, string>;
+};
+declare const EMBED_PROVIDERS: EmbedProvider[];
+declare function normalizeExternalReferenceUrl(input: string): string | null;
+declare function detectEmbedProvider(url: string): EmbedProvider | null;
+declare function parseEmbedUrl(url: string): {
+    provider: EmbedProvider;
     id: string;
-    /** Schema IRI defining what type this node is */
-    schemaId: SchemaIRI;
-    /** Unix timestamp (ms) when this node was created */
-    createdAt: number;
-    /** DID of the user who created this node */
-    createdBy: DID;
-    /** All other fields are schema-defined */
-    [key: string]: unknown;
-}
-/**
- * Type guard to check if a value is a valid Node.
- */
-declare function isNode(value: unknown): value is Node;
-/**
- * Create a new node ID using nanoid.
- *
- * Node IDs are just unique identifiers - they don't need to be sortable
- * (sorting is done by Lamport timestamps in the Change log).
- *
- * Default length is 21 characters, providing ~126 bits of randomness.
- * URL-safe characters: A-Za-z0-9_-
- *
- * @param length - Optional length (default 21)
- * @returns A unique node ID
- */
-declare function createNodeId(length?: number): string;
+    embedUrl: string;
+} | null;
+declare function parseExternalReferenceUrl(input: string): ExternalReferenceDescriptor | null;
+
+/**
+ * External-reference metadata resolution pipeline.
+ */
+type ExternalReferenceMetadataSource = 'oembed' | 'open-graph';
+type ExternalReferenceMetadataStatus = 'resolved' | 'unavailable' | 'blocked' | 'error';
+type ExternalReferenceResolvedMetadata = {
+    title: string | null;
+    subtitle: string | null;
+    description: string | null;
+    imageUrl: string | null;
+    providerName: string | null;
+    authorName: string | null;
+    source: ExternalReferenceMetadataSource;
+    sourceUrl: string;
+};
+type ExternalReferenceMetadataResult = {
+    status: 'resolved';
+    metadata: ExternalReferenceResolvedMetadata;
+} | {
+    status: Exclude<ExternalReferenceMetadataStatus, 'resolved'>;
+    metadata: null;
+    reason: string;
+    source?: ExternalReferenceMetadataSource;
+    sourceUrl?: string;
+    error?: string;
+};
+type ExternalReferenceMetadataFetcher = (url: string, init?: RequestInit) => Promise<Response>;
+type ResolveExternalReferenceMetadataInput = {
+    url: string;
+    provider?: string | null;
+    fallbackTitle?: string | null;
+    fallbackSubtitle?: string | null;
+    fetcher?: ExternalReferenceMetadataFetcher;
+    signal?: AbortSignal;
+    allowOEmbed?: boolean;
+    allowOpenGraph?: boolean;
+    openGraphProxyUrl?: string | ((url: string) => string | null);
+};
+type OpenGraphMetadata = {
+    title: string | null;
+    description: string | null;
+    imageUrl: string | null;
+    siteName: string | null;
+};
+declare function getExternalReferenceOEmbedEndpoint(input: {
+    url: string;
+    provider?: string | null;
+}): string | null;
+declare function parseOpenGraphMetadata(html: string): OpenGraphMetadata;
+declare function resolveExternalReferenceMetadata(input: ResolveExternalReferenceMetadataInput): Promise<ExternalReferenceMetadataResult>;
 
 /**
- * Temp ID resolution for transactional node creation.
- *
- * Temp IDs are `~`-prefixed strings (e.g., `~parent`, `~comment`) that act as
- * placeholders for node IDs in a transaction. The same temp ID used in multiple
- * places within a transaction resolves to the same real nanoid.
- *
- * Resolution happens in two places:
- * 1. **Operation IDs** — `create.options.id` and `update/delete/restore.nodeId`
- * 2. **Relation properties** — any property with `definition.type === 'relation'`
- *    in the schema (requires SchemaRegistry access)
- *
- * @example
- * ```typescript
- * await store.transaction([
- *   { type: 'create', options: { id: '~parent', schemaId: 'Task', properties: { title: 'P' } } },
- *   { type: 'create', options: { id: '~child', schemaId: 'Task', properties: { title: 'C', parent: '~parent' } } },
- * ])
- * // Returns: { tempIds: { '~parent': 'xK9mQ2...', '~child': 'pL3nR7...' }, ... }
- * ```
+ * Workspace policy helpers for external-reference iframe embeds.
  */
 
-/** Prefix that identifies a temp ID. nanoid never produces `~`. */
-declare const TEMP_ID_PREFIX = "~";
-/**
- * Check whether a string is a temp ID (starts with `~`).
- */
-declare function isTempId(value: unknown): value is string;
-/**
- * Callback to look up a schema's relation property names by schema IRI.
- * Returns the set of property keys that have `type === 'relation'`,
- * or undefined if the schema is not available.
- */
-type SchemaLookup = (schemaId: SchemaIRI) => Set<string> | undefined;
-/**
- * Build a SchemaLookup from a map of DefinedSchema objects.
- * Caches the relation property sets for each schema IRI.
- */
-declare function createSchemaLookup(getSchema: (iri: SchemaIRI) => DefinedSchema<Record<string, PropertyBuilder>> | undefined): SchemaLookup;
-/**
- * Result of resolving temp IDs in a list of transaction operations.
- */
-interface TempIdResolution {
-    /** The operations with all temp IDs replaced by real IDs */
-    operations: TransactionOperation[];
-    /** Map from temp ID → generated real ID (empty if no temp IDs were found) */
-    tempIds: Record<string, NodeId>;
-}
+type ExternalReferenceIframeSandboxToken = 'allow-downloads' | 'allow-forms' | 'allow-modals' | 'allow-orientation-lock' | 'allow-pointer-lock' | 'allow-popups' | 'allow-popups-to-escape-sandbox' | 'allow-presentation' | 'allow-same-origin' | 'allow-scripts' | 'allow-storage-access-by-user-activation' | 'allow-top-navigation-by-user-activation';
+type ExternalReferenceEmbedBlockReason = 'missing-embed-url' | 'invalid-embed-url' | 'provider-blocked' | 'origin-blocked' | 'arbitrary-iframe-blocked';
+type ExternalReferenceEmbedPolicy = {
+    allowedProviders?: readonly ExternalReferenceProvider[];
+    allowedOrigins?: readonly string[];
+    allowArbitraryIframes?: boolean;
+    sandbox?: readonly ExternalReferenceIframeSandboxToken[];
+    allow?: string;
+    referrerPolicy?: ReferrerPolicy;
+};
+type ExternalReferenceEmbedPolicyDecision = {
+    allowed: true;
+    provider: ExternalReferenceProvider;
+    embedUrl: string;
+    origin: string;
+    sandbox: string;
+    allow: string;
+    referrerPolicy: ReferrerPolicy;
+} | {
+    allowed: false;
+    provider: ExternalReferenceProvider;
+    embedUrl: string | null;
+    origin: string | null;
+    reason: ExternalReferenceEmbedBlockReason;
+};
+type EvaluateExternalReferenceEmbedPolicyInput = {
+    sourceUrl: string;
+    embedUrl?: string | null;
+    provider?: string | null;
+    policy?: ExternalReferenceEmbedPolicy | null;
+};
+declare const DEFAULT_EXTERNAL_REFERENCE_IFRAME_ALLOW = "accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share";
+declare function evaluateExternalReferenceEmbedPolicy(input: EvaluateExternalReferenceEmbedPolicyInput): ExternalReferenceEmbedPolicyDecision;
+
 /**
- * Resolve all `~`-prefixed temp IDs in a list of transaction operations.
- *
- * Resolution order:
- * 1. Scan all operations to collect temp IDs and generate real IDs
- * 2. Replace temp IDs in operation `id` fields (create) and `nodeId` fields (update/delete/restore)
- * 3. If a SchemaLookup is provided, replace temp IDs in `relation`-typed property values
- *
- * @param operations - The original transaction operations (not mutated)
- * @param schemaLookup - Optional callback to get relation property names for a schema
- * @returns Resolved operations and the temp ID → real ID mapping
+ * Shared embed provider registry and iframe policy facade.
  */
-declare function resolveTempIds(operations: TransactionOperation[], schemaLookup?: SchemaLookup): TempIdResolution;
+type EmbedRegistryProvider = 'youtube' | 'spotify' | 'vimeo' | 'loom' | 'figma' | 'codesandbox' | 'generic';
+type EmbedRegistryIframeSecurityAttributes = {
+    sandbox: string;
+    allow: string;
+    referrerPolicy: 'no-referrer' | 'strict-origin-when-cross-origin';
+    loading: 'lazy';
+};
+type EmbedRegistryProviderPolicy = {
+    provider: EmbedRegistryProvider;
+    allowedHostnames: readonly string[];
+    iframeAttributes: EmbedRegistryIframeSecurityAttributes;
+    metadataFetchingDefault: boolean;
+};
+type EmbedRegistryPolicyDecision = {
+    allowed: boolean;
+    provider: EmbedRegistryProvider;
+    reason?: string;
+    policy: EmbedRegistryProviderPolicy;
+    iframeAttributes: EmbedRegistryIframeSecurityAttributes;
+};
+type EvaluateEmbedRegistryPolicyInput = {
+    provider?: string | null;
+    embedUrl?: string | null;
+    allowArbitraryEmbeds?: boolean;
+};
+declare function getEmbedRegistryProviderPolicies(): EmbedRegistryProviderPolicy[];
+declare function getEmbedRegistryProviderPolicy(provider: string | null | undefined): EmbedRegistryProviderPolicy;
+declare function evaluateEmbedRegistryPolicy(input: EvaluateEmbedRegistryPolicyInput): EmbedRegistryPolicyDecision;
 
-interface GrantRateLimiterOptions {
-    limitPerMinute?: number;
-    windowMs?: number;
-    now?: () => number;
-}
 /**
- * Per-peer rate limiter for grant operations.
- *
- * Default policy: max 10 grant attempts per peer per minute.
+ * Block type registry for document content
  */
-declare class GrantRateLimiter {
-    private readonly limitPerMinute;
-    private readonly windowMs;
-    private readonly now;
-    private readonly attemptsByPeer;
-    constructor(options?: GrantRateLimiterOptions);
-    allow(peerDid: DID$1): boolean;
-    reset(peerDid?: DID$1): void;
-}
 
-declare const GRANT_SCHEMA_IRI: "xnet://xnet.fyi/Grant";
-interface GrantNode {
+type BlockType = 'paragraph' | 'heading' | 'list' | 'todo' | 'code' | 'quote' | 'divider' | 'image' | 'embed' | 'table' | 'callout' | 'toggle';
+type Block = {
     id: string;
+    type: BlockType;
+    parent: string;
+    content: Y.XmlFragment | Y.Map<unknown>;
+    children: string[];
     properties: Record<string, unknown>;
-    deleted: boolean;
-}
-interface GrantIndexStore {
-    list(options?: {
-        schemaId?: string;
-        includeDeleted?: boolean;
-    }): Promise<NodeState[]>;
-    subscribe(listener: (event: NodeChangeEvent) => void): () => void;
-}
-interface GrantIndexOptions {
-    schemaId?: string;
-    clock?: () => number;
-}
-declare function isGrantActive(grant: GrantNode, now?: number): boolean;
-declare class GrantIndex {
-    private readonly store;
-    private byResourceAndGrantee;
-    private byResource;
-    private grantsById;
-    private unsubscribe;
-    private readonly schemaId;
-    private readonly clock;
-    constructor(store: GrantIndexStore, options?: GrantIndexOptions);
-    initialize(): Promise<void>;
-    findGrants(resource: string, grantee: DID$1): GrantNode[];
-    findGrantsForResource(resource: string): GrantNode[];
-    findAllGrantsForResource(resource: string): GrantNode[];
-    findGrantsForGrantee(grantee: DID$1): GrantNode[];
-    dispose(): void;
-    private loadGrantNodes;
-    private isGrantSchema;
-    private indexGrant;
-    private removeGrant;
-}
-
-interface OfflineAuthPolicy {
-    /** Cache TTL for can() decisions in eventual mode. Default: 5 minutes. */
-    decisionCacheTTL: number;
-    /** Max staleness before operations must revalidate. Default: 1 hour. */
-    maxStaleness: number;
-    /** Re-validation strategy used on reconnect. */
-    revalidation: 'eager' | 'lazy' | 'hybrid';
-    /** Allow grant/revoke writes while offline. */
-    allowOfflineGrants: boolean;
-}
-declare const DEFAULT_OFFLINE_POLICY: OfflineAuthPolicy;
-declare function mergeOfflinePolicy(current: OfflineAuthPolicy, patch: Partial<OfflineAuthPolicy>): OfflineAuthPolicy;
-
-type GrantStatus = 'active' | 'expired' | 'revoked' | 'all';
-interface StoreAuthAPI {
-    can(input: {
-        action: AuthAction;
-        nodeId: string;
-        patch?: Record<string, unknown>;
-    }): Promise<AuthDecision>;
-    explain(input: {
-        action: AuthAction;
-        nodeId: string;
-    }): Promise<AuthTrace>;
-    grant(input: GrantInput): Promise<Grant$1>;
-    revoke(input: {
-        grantId: string;
-    }): Promise<void>;
-    listGrants(input: {
-        nodeId: string;
-        status?: GrantStatus;
-    }): Promise<Grant$1[]>;
-    listIssuedGrants(): Promise<Grant$1[]>;
-    listReceivedGrants(): Promise<Grant$1[]>;
-    getOfflinePolicy(): OfflineAuthPolicy;
-    setOfflinePolicy(policy: Partial<OfflineAuthPolicy>): void;
-}
-interface GrantInput {
-    to: DID$1;
-    actions: AuthAction[];
-    resource: string;
-    expiresIn?: string | number;
-    parentGrantId?: string;
-}
-interface Grant$1 {
-    id: string;
-    issuer: DID$1;
-    grantee: DID$1;
-    resource: string;
-    resourceSchema: string;
-    actions: AuthAction[];
-    expiresAt: number;
-    revokedAt: number;
-    revokedBy?: DID$1;
-    ucanToken?: string;
-    proofDepth: number;
-    parentGrantId?: string;
-}
-interface StoreAuthStore {
-    create(options: {
-        schemaId: string;
-        properties: Record<string, unknown>;
-    }): Promise<{
-        id: string;
-    }>;
-    update(nodeId: string, options: {
-        properties: Record<string, unknown>;
-    }): Promise<unknown>;
-    get(nodeId: string): Promise<{
-        id: string;
-        createdBy: DID$1;
-        schemaId: string;
-        properties: Record<string, unknown>;
-    } | null>;
-    list(options?: {
-        schemaId?: string;
-        includeDeleted?: boolean;
-    }): Promise<Array<{
-        id: string;
-        schemaId: string;
-        properties: Record<string, unknown>;
-    }>>;
-}
-interface StoreAuthKeyManager {
-    getContentKey(resourceId: string): Promise<Uint8Array>;
-    addRecipient(input: {
-        resourceId: string;
-        recipient: DID$1;
-        contentKey: Uint8Array;
-        recipientPublicKey: Uint8Array;
-    }): Promise<void>;
-    rotateContentKey(resourceId: string, revokedRecipient: DID$1): Promise<void>;
-}
-interface StoreAuthOptions {
-    store: StoreAuthStore;
-    actorDid: DID$1;
-    signingKey: Uint8Array;
-    evaluator: PolicyEvaluator;
-    grantIndex?: GrantIndex;
-    publicKeyResolver?: PublicKeyResolver;
-    keyManager?: StoreAuthKeyManager;
-    rateLimiter?: GrantRateLimiter;
-    now?: () => number;
-    maxProofDepth?: number;
-}
-type StoreAuthErrorCode = 'AUTH_PERMISSION_DENIED' | 'AUTH_RATE_LIMIT_EXCEEDED' | 'AUTH_DELEGATION_DEPTH_EXCEEDED' | 'AUTH_DELEGATION_ESCALATION';
-declare class StoreAuthError extends Error {
-    readonly code: StoreAuthErrorCode;
-    constructor(code: StoreAuthErrorCode, message: string);
-}
-declare class StoreAuth implements StoreAuthAPI {
-    private readonly options;
-    private readonly rateLimiter;
-    private readonly now;
-    private readonly maxProofDepth;
-    private offlinePolicy;
-    constructor(options: StoreAuthOptions);
-    can(input: {
-        action: AuthAction;
-        nodeId: string;
-        patch?: Record<string, unknown>;
-    }): Promise<AuthDecision>;
-    explain(input: {
-        action: AuthAction;
-        nodeId: string;
-    }): Promise<AuthTrace>;
-    grant(input: GrantInput): Promise<Grant$1>;
-    revoke(input: {
-        grantId: string;
-    }): Promise<void>;
-    listGrants(input: {
-        nodeId: string;
-        status?: GrantStatus;
-    }): Promise<Grant$1[]>;
-    listIssuedGrants(): Promise<Grant$1[]>;
-    listReceivedGrants(): Promise<Grant$1[]>;
-    getOfflinePolicy(): OfflineAuthPolicy;
-    setOfflinePolicy(policy: Partial<OfflineAuthPolicy>): void;
-    private matchesStatus;
-    private validateRevocation;
-    private assertDelegationAttenuation;
-    private computeProofDepth;
-    private cascadeRevocation;
-    private getGrantNodeOrThrow;
-    private loadGrantNodes;
-    private createDelegationUCAN;
-    private computeExpiration;
-}
-
-/**
- * Schema Lens System - Bidirectional transformations between schema versions.
- *
- * A lens defines how to transform data from one schema version to another,
- * enabling automatic migrations during read operations.
- *
- * @example
- * ```typescript
- * const taskV1toV2: SchemaLens = {
- *   source: 'xnet://xnet.fyi/Task@1.0.0',
- *   target: 'xnet://xnet.fyi/Task@2.0.0',
- *   forward: (data) => ({
- *     ...data,
- *     status: data.complete ? 'done' : 'todo',
- *     priority: data.priority ?? 'medium'
- *   }),
- *   backward: (data) => ({
- *     ...data,
- *     complete: data.status === 'done'
- *   }),
- *   lossless: false // priority is lost in backward transform
- * }
- *
- * registry.register(taskV1toV2)
- * const migrated = registry.transform(oldData, 'Task@1.0.0', 'Task@2.0.0')
- * ```
- */
-
-/**
- * A bidirectional transformation between two schema versions.
- */
-interface SchemaLens {
-    /** Source schema IRI (versioned) */
-    source: SchemaIRI;
-    /** Target schema IRI (versioned) */
-    target: SchemaIRI;
-    /** Transform data from source to target schema */
-    forward: (data: Record<string, unknown>) => Record<string, unknown>;
-    /** Transform data from target back to source schema */
-    backward: (data: Record<string, unknown>) => Record<string, unknown>;
-    /** Whether the transformation preserves all data (can round-trip without loss) */
-    lossless: boolean;
-}
+};
 /**
- * A single lens operation (used by lens builders).
- * Can be composed into a full SchemaLens.
+ * Block definition for registering new block types
  */
-interface LensOperation {
-    /** Transform data forward */
-    forward: (data: Record<string, unknown>) => Record<string, unknown>;
-    /** Transform data backward */
-    backward: (data: Record<string, unknown>) => Record<string, unknown>;
-    /** Whether this operation is lossless (defaults to true) */
-    lossless?: boolean;
+interface BlockDefinition {
+    type: BlockType;
+    create: (id: string, parent: string) => Block;
+    validate: (block: Block) => boolean;
 }
 /**
- * Result of a migration transformation.
+ * Register a new block type
  */
-interface MigrationResult {
-    /** The transformed data */
-    data: Record<string, unknown>;
-    /** The path of lenses applied */
-    path: SchemaLens[];
-    /** Whether all transformations were lossless */
-    lossless: boolean;
-    /** Warnings about potential data loss */
-    warnings: string[];
-}
+declare function registerBlockType(definition: BlockDefinition): void;
 /**
- * Error thrown when migration fails.
+ * Create a block of a specific type
  */
-declare class MigrationError extends Error {
-    readonly source?: SchemaIRI | undefined;
-    readonly target?: SchemaIRI | undefined;
-    constructor(message: string, source?: SchemaIRI | undefined, target?: SchemaIRI | undefined);
-}
+declare function createBlock(type: BlockType, id: string, parent: string): Block;
 /**
- * Registry for schema lenses with pathfinding for multi-step migrations.
- *
- * The registry finds the shortest path between schema versions using BFS,
- * allowing automatic migrations through intermediate versions.
- *
- * @example
- * ```typescript
- * const registry = new LensRegistry()
- *
- * // Register direct migrations
- * registry.register(taskV1toV2)
- * registry.register(taskV2toV3)
- *
- * // Can now migrate from v1 to v3 through v2
- * const migrated = registry.transform(v1Data, 'Task@1.0.0', 'Task@3.0.0')
- * ```
+ * Validate a block
  */
-declare class LensRegistry {
-    private lenses;
-    private pathCache;
-    /**
-     * Register a lens for transforming between two schema versions.
-     * Also registers the reverse transformation automatically.
-     */
-    register(lens: SchemaLens): void;
-    /**
-     * Unregister a lens (and its reverse).
-     */
-    unregister(source: SchemaIRI, target: SchemaIRI): boolean;
-    /**
-     * Get a direct lens between two schemas (if registered).
-     */
-    get(source: SchemaIRI, target: SchemaIRI): SchemaLens | undefined;
-    /**
-     * Check if a direct lens exists between two schemas.
-     */
-    has(source: SchemaIRI, target: SchemaIRI): boolean;
-    /**
-     * Find the shortest path of lenses between two schema versions.
-     * Uses BFS to find the optimal path through intermediate versions.
-     *
-     * @returns Array of lenses to apply in order, or null if no path exists
-     */
-    findPath(from: SchemaIRI, to: SchemaIRI): SchemaLens[] | null;
-    /**
-     * Transform data from one schema version to another.
-     *
-     * @throws MigrationError if no path exists between schemas
-     */
-    transform(data: Record<string, unknown>, from: SchemaIRI, to: SchemaIRI): Record<string, unknown>;
-    /**
-     * Transform data with detailed migration result.
-     */
-    transformWithDetails(data: Record<string, unknown>, from: SchemaIRI, to: SchemaIRI): MigrationResult;
-    /**
-     * Check if a migration path exists between two schemas.
-     */
-    canMigrate(from: SchemaIRI, to: SchemaIRI): boolean;
-    /**
-     * Check if a migration path is lossless (all transformations preserve data).
-     */
-    isLossless(from: SchemaIRI, to: SchemaIRI): boolean;
-    /**
-     * Get all registered schema IRIs.
-     */
-    getSchemas(): SchemaIRI[];
-    /**
-     * Clear all registered lenses and cached paths.
-     */
-    clear(): void;
-    /**
-     * BFS pathfinding to find shortest lens path between schemas.
-     */
-    private bfsPath;
-}
+declare function validateBlock(block: Block): boolean;
 /**
- * Default global lens registry instance.
+ * Get all registered block types
  */
-declare const lensRegistry: LensRegistry;
+declare function getRegisteredBlockTypes(): BlockType[];
 
 /**
- * NodeStore types - Event-sourced storage for Nodes
- *
- * The NodeStore manages Nodes using Change<T> from @xnetjs/sync.
- * Each Node change is a Change with a NodePayload.
+ * BlobService - High-level file upload and retrieval.
  *
- * Key design decisions:
- * - No operation types (create-item, update-item, etc.) - just Changes
- * - LWW conflict resolution using Lamport timestamps
- * - Changes store sparse updates (only changed properties)
- * - Materialized state computed by replaying Changes
+ * Provides a simple API for storing and retrieving files,
+ * handling chunking, URL generation, and cleanup.
  */
 
-/** Unique identifier for a Node */
-type NodeId = string;
-/** Identifier for a property within a Node */
-type PropertyKey = string;
-/**
- * Payload for a Node change.
- *
- * Contains the sparse set of properties that changed.
- * First change for a nodeId implicitly creates the Node.
- * Setting a property to `undefined` deletes it.
- */
-interface NodePayload {
-    /** The Node being changed */
-    nodeId: NodeId;
-    /** Schema IRI (required on first change, optional on updates) */
-    schemaId?: SchemaIRI;
-    /** Changed properties (sparse - only what changed) */
-    properties: Record<PropertyKey, unknown>;
-    /** Soft delete flag (optional) */
-    deleted?: boolean;
-}
-/** A Change containing a NodePayload */
-type NodeChange = Change<NodePayload>;
-/**
- * Timestamp metadata for a property value (for LWW resolution).
- */
-interface PropertyTimestamp {
-    /** The Lamport timestamp when this value was set */
-    lamport: LamportTimestamp;
-    /** Wall clock time (for display) */
-    wallTime: number;
-}
-/**
- * Materialized Node state with LWW metadata.
- *
- * This is computed by replaying all Changes for a nodeId.
- */
-interface NodeState {
-    /** Node ID */
-    id: NodeId;
-    /** Schema IRI */
-    schemaId: SchemaIRI;
-    /** Current property values (after LWW resolution) */
-    properties: Record<PropertyKey, unknown>;
-    /** LWW timestamps per property (for conflict resolution) */
-    timestamps: Record<PropertyKey, PropertyTimestamp>;
-    /** Soft delete flag */
-    deleted: boolean;
-    /** When deleted (if deleted) */
-    deletedAt?: PropertyTimestamp;
-    /** Creation metadata */
-    createdAt: number;
-    createdBy: DID$1;
-    /** Last update metadata */
-    updatedAt: number;
-    updatedBy: DID$1;
-    /**
-     * Serialized CRDT document content (for nodes with document type).
-     * For Yjs: Uint8Array from Y.encodeStateAsUpdate()
-     * Use Y.applyUpdate(ydoc, documentContent) to hydrate.
-     */
-    documentContent?: Uint8Array;
-    /**
-     * Unknown properties from future schema versions.
-     * Preserved on read and passed through on write for forward compatibility.
-     * These properties exist in the change log but aren't known to the current schema.
-     */
-    _unknown?: Record<PropertyKey, unknown>;
-    /**
-     * The schema version that last wrote to this node.
-     * Used to detect when migrations might be needed.
-     */
-    _schemaVersion?: string;
-}
-/**
- * Storage adapter interface for NodeStore.
- *
- * Implementations can use SQLite or memory.
- * The adapter stores Changes and materialized NodeState.
- */
-interface NodeStorageAdapter {
-    /** Open/initialize the storage connection */
-    open?(): Promise<void>;
-    /** Close the storage connection */
-    close?(): Promise<void>;
-    appendChange(change: NodeChange): Promise<void>;
-    getChanges(nodeId: NodeId): Promise<NodeChange[]>;
-    getAllChanges(): Promise<NodeChange[]>;
-    /** Get changes with Lamport time greater than `since` */
-    getChangesSince(sinceLamport: number): Promise<NodeChange[]>;
-    getChangeByHash(hash: ContentId): Promise<NodeChange | null>;
-    getLastChange(nodeId: NodeId): Promise<NodeChange | null>;
-    getNode(id: NodeId): Promise<NodeState | null>;
-    setNode(node: NodeState): Promise<void>;
-    deleteNode(id: NodeId): Promise<void>;
-    listNodes(options?: ListNodesOptions): Promise<NodeState[]>;
-    countNodes(options?: CountNodesOptions): Promise<number>;
-    getLastLamportTime(): Promise<number>;
-    setLastLamportTime(time: number): Promise<void>;
-    getDocumentContent(nodeId: NodeId): Promise<Uint8Array | null>;
-    setDocumentContent(nodeId: NodeId, content: Uint8Array): Promise<void>;
-}
-interface ListNodesOptions {
-    /** Filter by schema IRI */
-    schemaId?: SchemaIRI;
-    /** Include soft-deleted nodes */
-    includeDeleted?: boolean;
-    /** Limit results */
-    limit?: number;
-    /** Offset for pagination */
-    offset?: number;
-}
-interface CountNodesOptions {
-    /** Filter by schema IRI */
-    schemaId?: SchemaIRI;
-    /** Include soft-deleted nodes */
-    includeDeleted?: boolean;
-}
-/**
- * Result of LWW conflict resolution for a property.
- */
-interface ConflictResult {
-    /** Which value won */
-    winner: 'local' | 'remote';
-    /** The property key */
-    key: PropertyKey;
-    /** The winning value */
-    value: unknown;
-    /** The winning timestamp */
-    timestamp: PropertyTimestamp;
-}
-/**
- * Conflict detected during merge (for debugging/UI).
- */
-interface MergeConflict {
-    nodeId: NodeId;
-    key: PropertyKey;
-    localValue: unknown;
-    localTimestamp: PropertyTimestamp;
-    remoteValue: unknown;
-    remoteTimestamp: PropertyTimestamp;
-    resolved: 'local' | 'remote';
+interface BlobServiceOptions {
+    /** Maximum file size in bytes (default: 100MB) */
+    maxSize?: number;
 }
-/**
- * Callback to get the known property names for a schema.
- * Used for unknown property preservation during version compatibility.
- * Returns the set of property names defined in the schema,
- * or undefined if the schema is not available (all properties treated as known).
- */
-type PropertyLookup = (schemaId: SchemaIRI) => Set<string> | undefined;
-/**
- * Options for creating a NodeStore.
- */
-interface NodeStoreOptions {
-    /** Storage adapter */
-    storage: NodeStorageAdapter;
-    /** Author's DID */
-    authorDID: DID$1;
-    /** Ed25519 signing key */
-    signingKey: Uint8Array;
-    /**
-     * Optional schema lookup for temp ID resolution in relation properties.
-     * When provided, `transaction()` will resolve `~`-prefixed temp IDs in
-     * properties whose schema type is `'relation'`.
-     * Without this, temp IDs are only resolved in operation ID fields.
-     */
-    schemaLookup?: SchemaLookup;
-    /**
-     * Optional property lookup for unknown property preservation.
-     * When provided, properties not in the schema are stored in `_unknown`.
-     * Without this, all properties are stored as known properties.
-     */
-    propertyLookup?: PropertyLookup;
+declare class BlobService {
+    private chunkManager;
+    private options;
+    private urlCache;
+    constructor(chunkManager: ChunkManager, options?: BlobServiceOptions);
     /**
-     * Optional lens registry for automatic schema migrations.
-     * When provided, nodes are automatically migrated to the target schema
-     * version on read (getWithMigration). Without this, nodes are returned as-is.
+     * Upload a File and return a FileRef for storage in node properties.
      */
-    lensRegistry?: LensRegistry;
-    /** Optional authorization evaluator used for mutation gating. */
-    authEvaluator?: PolicyEvaluator;
+    upload(file: File): Promise<FileRef>;
     /**
-     * Optional transparent node content cipher.
-     *
-     * When provided, NodeStore writes encrypted node payload snapshots via
-     * `setDocumentContent()` and decrypts them on read paths.
+     * Upload from Uint8Array (for programmatic use).
      */
-    nodeContentCipher?: NodeContentCipher;
+    uploadData(data: Uint8Array, metadata: {
+        filename: string;
+        mimeType: string;
+    }): Promise<FileRef>;
     /**
-     * Optional cache for per-node content keys used by `nodeContentCipher`.
-     *
-     * This avoids expensive key unwraps on repeated reads.
+     * Get a URL for displaying/downloading a file.
+     * Creates a blob URL that should be revoked when no longer needed.
      */
-    contentKeyCache?: ContentKeyCache;
+    getUrl(ref: FileRef): Promise<string>;
     /**
-     * Optional lookup for properties that can change node recipients.
-     * When provided, update paths only trigger recipient recomputation hooks
-     * if one of these properties is changed.
+     * Get raw data for a file.
      */
-    authRelevantPropertyLookup?: (schemaId: SchemaIRI) => Set<string> | undefined;
+    getData(ref: FileRef): Promise<Uint8Array | null>;
     /**
-     * Optional callback triggered when an update touches auth-relevant properties.
-     * Integrators can use this to recompute recipients and rotate keys.
+     * Check if a file exists locally.
      */
-    onRecipientsMayNeedRecompute?: (context: {
-        nodeId: NodeId;
-        schemaId: SchemaIRI;
-        changedProperties: string[];
-    }) => Promise<void> | void;
+    has(ref: FileRef): Promise<boolean>;
     /**
-     * Optional callback for rejected unauthorized remote changes.
-     * Remote unauthorized changes are rejected silently and never applied.
+     * Get list of missing chunk CIDs (for sync).
      */
-    onUnauthorizedRemoteChange?: (context: {
-        change: NodeChange;
-        action: AuthAction;
-        decision: AuthDecision;
-    }) => void;
-    /** Optional high-level authorization API attached as `store.auth`. */
-    auth?: StoreAuthAPI;
+    getMissingChunks(ref: FileRef): Promise<ContentId[]>;
     /**
-     * Optional telemetry collector for tracking CRUD operations, errors, and performance.
-     * When provided, NodeStore will report:
-     * - Performance metrics for create/update/delete/list operations
-     * - Usage metrics for operation counts
-     * - Crash reports for errors
-     *
-     * Compatible with @xnetjs/telemetry TelemetryCollector.
+     * Revoke a blob URL to free memory.
      */
-    telemetry?: {
-        reportPerformance(metricName: string, durationMs: number, codeNamespace?: string): void;
-        reportUsage(metricName: string, value: number): void;
-        reportCrash(error: Error, context?: {
-            codeNamespace?: string;
-        }): void;
-        reportSecurityEvent(eventName: string, severity: 'low' | 'medium' | 'high' | 'critical'): void;
-    };
-}
-/**
- * Cache for per-node content keys used during transparent decrypt/encrypt flows.
- */
-interface ContentKeyCache {
-    get(nodeId: NodeId): Uint8Array | undefined;
-    set(nodeId: NodeId, key: Uint8Array): void;
-    delete(nodeId: NodeId): void;
-    clear?(): void;
-}
-/**
- * Pluggable cipher for transparent node payload encryption.
- */
-interface NodeContentCipher {
-    encrypt(input: {
-        nodeId: NodeId;
-        schemaId: SchemaIRI;
-        content: Uint8Array;
-        cachedContentKey?: Uint8Array;
-    }): Promise<{
-        encryptedContent: Uint8Array;
-        contentKey?: Uint8Array;
-    }>;
-    decrypt(input: {
-        nodeId: NodeId;
-        schemaId: SchemaIRI;
-        encryptedContent: Uint8Array;
-        cachedContentKey?: Uint8Array;
-    }): Promise<{
-        content: Uint8Array;
-        contentKey?: Uint8Array;
-    }>;
-}
-/**
- * Options for creating a Node.
- */
-interface CreateNodeOptions$1 {
-    /** Optional ID (generated if not provided) */
-    id?: NodeId;
-    /** Schema IRI */
-    schemaId: SchemaIRI;
-    /** Initial property values */
-    properties: Record<PropertyKey, unknown>;
-}
-/**
- * Options for updating a Node.
- */
-interface UpdateNodeOptions {
-    /** Changed properties (sparse) */
-    properties: Record<PropertyKey, unknown>;
-}
-/**
- * A single operation within a transaction.
- */
-type TransactionOperation = {
-    type: 'create';
-    options: CreateNodeOptions$1;
-} | {
-    type: 'update';
-    nodeId: NodeId;
-    options: UpdateNodeOptions;
-} | {
-    type: 'delete';
-    nodeId: NodeId;
-} | {
-    type: 'restore';
-    nodeId: NodeId;
-};
-/**
- * Result of a transaction execution.
- * Returns the affected nodes in the same order as operations.
- */
-interface TransactionResult {
-    /** The batch ID shared by all changes */
-    batchId: string;
-    /** Results for each operation (NodeState or null for delete) */
-    results: (NodeState | null)[];
-    /** All changes created in this transaction */
-    changes: NodeChange[];
-    /** Map from temp ID → generated real ID (empty if no temp IDs were used) */
-    tempIds: Record<string, NodeId>;
-}
-/**
- * Event emitted when a Node changes.
- */
-interface NodeChangeEvent {
-    /** The change that was applied */
-    change: NodeChange;
-    /** The resulting Node state */
-    node: NodeState | null;
-    /** Whether this was a remote change (from sync) */
-    isRemote: boolean;
-}
-/**
- * Listener for Node change events.
- */
-type NodeChangeListener = (event: NodeChangeEvent) => void;
-/**
- * Options for getWithMigration.
- */
-interface GetWithMigrationOptions {
-    /** Target schema IRI to migrate to (required) */
-    targetSchemaId: SchemaIRI;
-}
-/**
- * Information about a migration that was applied.
- */
-interface MigrationInfo {
-    /** The original schema IRI of the stored data */
-    from: SchemaIRI;
-    /** The target schema IRI */
-    to: SchemaIRI;
-    /** Whether the migration preserved all data (no data loss) */
-    lossless: boolean;
-    /** Warnings about potential data loss */
-    warnings: string[];
-}
-/**
- * Result of getWithMigration.
- */
-interface MigratedNodeState extends NodeState {
+    revokeUrl(ref: FileRef): void;
     /**
-     * Migration info if the node was migrated from a different schema version.
-     * Undefined if no migration was needed.
+     * Revoke all cached blob URLs.
      */
-    _migrationInfo?: MigrationInfo;
+    revokeAllUrls(): void;
 }
 
-/**
- * NodeStore - Event-sourced storage for Nodes
- *
- * Manages Nodes using Change<T> from @xnetjs/sync with LWW conflict resolution.
- *
- * Key features:
- * - Simple CRUD API that creates Changes under the hood
- * - LWW conflict resolution using Lamport timestamps
- * - Sparse updates (only store changed properties)
- * - Materialized state for fast reads
- */
-
-/**
- * NodeStore manages event-sourced Nodes with LWW conflict resolution.
- */
-declare class NodeStore {
-    private storage;
-    private authorDID;
-    private signingKey;
-    private clock;
-    private conflicts;
-    private listeners;
-    private schemaLookup?;
-    private propertyLookup?;
-    private lensRegistry?;
-    private authEvaluator?;
-    private nodeContentCipher?;
-    private contentKeyCache?;
-    private authRelevantPropertyLookup?;
-    private onRecipientsMayNeedRecompute?;
-    private onUnauthorizedRemoteChange?;
-    readonly auth?: StoreAuthAPI;
-    private telemetry?;
-    constructor(options: NodeStoreOptions);
-    /**
-     * Initialize the store by loading the last Lamport time from storage.
-     * Call this before using the store.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Get the underlying storage adapter.
-     *
-     * Use this to access low-level storage operations like change history,
-     * document content, and Lamport timestamps. Useful for building history,
-     * audit, and verification features.
-     *
-     * @returns The NodeStorageAdapter instance
-     */
-    getStorageAdapter(): NodeStorageAdapter;
-    /**
-     * Create a new Node.
-     */
-    create(options: CreateNodeOptions$1): Promise<NodeState>;
-    /**
-     * Get a Node by ID.
-     */
-    get(id: NodeId): Promise<NodeState | null>;
-    /**
-     * Get a Node by ID with automatic schema migration.
-     *
-     * If the stored node's schema version differs from the target schema,
-     * and a migration path exists in the lens registry, the node's properties
-     * will be automatically transformed.
-     *
-     * @param id - The node ID to fetch
-     * @param options - Options including the target schema IRI
-     * @returns The node with migrated properties, or null if not found
-     *
-     * @example
-     * ```typescript
-     * // Get node and migrate to TaskSchema v2.0.0
-     * const node = await store.getWithMigration('node-123', {
-     *   targetSchemaId: TaskSchemaV2['@id']
-     * })
-     *
-     * if (node?._migrationInfo) {
-     *   console.log('Migrated from:', node._migrationInfo.from)
-     *   if (!node._migrationInfo.lossless) {
-     *     console.warn('Migration warnings:', node._migrationInfo.warnings)
-     *   }
-     * }
-     * ```
-     */
-    getWithMigration(id: NodeId, options: GetWithMigrationOptions): Promise<MigratedNodeState | null>;
-    /**
-     * Update a Node's properties.
-     */
-    update(id: NodeId, options: UpdateNodeOptions): Promise<NodeState>;
-    /**
-     * Delete a Node (soft delete).
-     */
-    delete(id: NodeId): Promise<void>;
-    /**
-     * Restore a deleted Node.
-     */
-    restore(id: NodeId): Promise<NodeState>;
-    /**
-     * List Nodes with optional filtering.
-     */
-    list(options?: ListNodesOptions): Promise<NodeState[]>;
-    /**
-     * Execute multiple operations as a single atomic transaction.
-     *
-     * All changes created in the transaction share the same batchId and Lamport
-     * timestamp, making them logically atomic. This is useful for:
-     * - Multi-node operations (move task between projects)
-     * - Undo/redo grouping
-     * - Audit trails ("user did X" as a single action)
-     * - Future blockchain integration (batch = transaction)
-     *
-     * @example
-     * ```typescript
-     * const result = await store.transaction([
-     *   { type: 'update', nodeId: task.id, options: { properties: { projectId: newProject.id } } },
-     *   { type: 'update', nodeId: oldProject.id, options: { properties: { taskIds: [...] } } },
-     *   { type: 'update', nodeId: newProject.id, options: { properties: { taskIds: [...] } } },
-     * ])
-     * console.log(`Batch ${result.batchId} applied ${result.changes.length} changes`)
-     * ```
-     */
-    transaction(operations: TransactionOperation[]): Promise<TransactionResult>;
-    /**
-     * Apply a remote change (from sync).
-     * Verifies the change signature before applying.
-     *
-     * @throws Error if signature verification fails
-     */
-    applyRemoteChange(change: NodeChange): Promise<void>;
-    /**
-     * Apply multiple remote changes (from sync).
-     */
-    applyRemoteChanges(changes: NodeChange[]): Promise<void>;
-    /**
-     * Get all changes for a Node (for sync).
-     */
-    getChanges(nodeId: NodeId): Promise<NodeChange[]>;
-    /**
-     * Get all changes (for full sync).
-     */
-    getAllChanges(): Promise<NodeChange[]>;
-    /**
-     * Get changes since a Lamport time (for delta sync).
-     */
-    getChangesSince(sinceLamport: number): Promise<NodeChange[]>;
-    /**
-     * Get the current Lamport time (for sync protocol).
-     */
-    getCurrentLamportTime(): number;
-    /**
-     * Get recent merge conflicts (for debugging/UI).
-     */
-    getRecentConflicts(): MergeConflict[];
-    /**
-     * Clear conflict history.
-     */
-    clearConflicts(): void;
-    /**
-     * Get CRDT document content for a node.
-     * Returns null if no document content exists.
-     */
-    getDocumentContent(nodeId: NodeId): Promise<Uint8Array | null>;
-    /**
-     * Set CRDT document content for a node.
-     * Used to persist serialized Y.Doc or other CRDT state.
-     */
-    setDocumentContent(nodeId: NodeId, content: Uint8Array): Promise<void>;
-    /**
-     * Subscribe to node changes.
-     *
-     * @param listener - Callback invoked when nodes change
-     * @returns Unsubscribe function
-     *
-     * @example
-     * ```ts
-     * const unsubscribe = store.subscribe((event) => {
-     *   console.log('Node changed:', event.node?.id, event.isRemote)
-     * })
-     * // Later: unsubscribe()
-     * ```
-     */
-    subscribe(listener: NodeChangeListener): () => void;
-    /**
-     * Emit a change event to all listeners.
-     */
-    private emit;
-    /**
-     * Create a signed change.
-     */
-    private createChange;
-    /**
-     * Create a signed change with batch metadata.
-     * Used for transaction support - all changes in a batch share the same
-     * batchId, Lamport timestamp, and wallTime.
-     */
-    private createBatchedChange;
-    /**
-     * Apply a change to storage and update materialized state.
-     */
-    private applyChange;
-    /**
-     * Determine if newTs should replace existingTs (LWW).
-     */
-    private shouldReplace;
-    /**
-     * Trim conflicts array to prevent unbounded memory growth.
-     * Keeps only the most recent MAX_CONFLICTS entries.
-     */
-    private trimConflicts;
-    private assertAuthorized;
-    private assertAuthorizedBatch;
-    private inferActionFromChange;
-    private shouldRecomputeRecipients;
-    private persistEncryptedNodeSnapshot;
-    private decryptNodeSnapshotIfPresent;
-    private serializeNodeSnapshot;
-    private deserializeNodeSnapshot;
-    private parseEncryptedNodeSnapshot;
-}
-
-/**
- * Error thrown when a local mutation fails authorization checks.
- */
-declare class PermissionError extends Error {
-    readonly code = "PERMISSION_DENIED";
-    readonly action: AuthAction;
-    readonly nodeId: string;
-    readonly subject: DID$1;
-    readonly reasons: AuthDenyReason[];
-    readonly roles: string[];
-    readonly decision: AuthDecision;
-    constructor(decision: AuthDecision);
-}
-
-/**
- * In-memory storage adapter for NodeStore.
- *
- * Useful for testing and ephemeral data.
- */
-
-/**
- * In-memory implementation of NodeStorageAdapter.
- */
-declare class MemoryNodeStorageAdapter implements NodeStorageAdapter {
-    private changes;
-    private changesByHash;
-    private nodes;
-    private documentContentStore;
-    private yjsSnapshotStore;
-    private lastLamportTime;
-    appendChange(change: NodeChange): Promise<void>;
-    getChanges(nodeId: NodeId): Promise<NodeChange[]>;
-    getAllChanges(): Promise<NodeChange[]>;
-    getChangesSince(sinceLamport: number): Promise<NodeChange[]>;
-    getChangeByHash(hash: ContentId): Promise<NodeChange | null>;
-    getLastChange(nodeId: NodeId): Promise<NodeChange | null>;
-    getNode(id: NodeId): Promise<NodeState | null>;
-    setNode(node: NodeState): Promise<void>;
-    deleteNode(id: NodeId): Promise<void>;
-    listNodes(options?: ListNodesOptions): Promise<NodeState[]>;
-    countNodes(options?: CountNodesOptions): Promise<number>;
-    getLastLamportTime(): Promise<number>;
-    setLastLamportTime(time: number): Promise<void>;
-    getDocumentContent(nodeId: NodeId): Promise<Uint8Array | null>;
-    setDocumentContent(nodeId: NodeId, content: Uint8Array): Promise<void>;
-    saveYjsSnapshot(snapshot: {
-        nodeId: NodeId;
-        timestamp: number;
-        snapshot: Uint8Array;
-        docState: Uint8Array;
-        byteSize: number;
-    }): Promise<void>;
-    getYjsSnapshots(nodeId: NodeId): Promise<{
-        nodeId: NodeId;
-        timestamp: number;
-        snapshot: Uint8Array;
-        docState: Uint8Array;
-        byteSize: number;
-    }[]>;
-    deleteYjsSnapshots(nodeId: NodeId): Promise<void>;
-    /**
-     * Clear all data (for testing).
-     */
-    clear(): void;
-    /**
-     * Get total change count (for testing).
-     */
-    getChangeCount(): number;
-    /**
-     * Get total node count (for testing).
-     */
-    getNodeCount(): number;
-}
-
-/**
- * SQLite storage adapter for NodeStore.
- *
- * Provides high-performance storage for nodes and changes using SQLite.
- * Works with any SQLiteAdapter implementation (Electron, Web, Expo).
- */
-
-/**
- * SQLite-backed storage adapter for NodeStore.
- *
- * This adapter provides high-performance storage for nodes and changes
- * using the platform-appropriate SQLite implementation.
- *
- * @example
- * ```typescript
- * import { createMemorySQLiteAdapter } from '@xnetjs/sqlite/memory'
- *
- * const sqliteAdapter = await createMemorySQLiteAdapter()
- * const nodeStorage = new SQLiteNodeStorageAdapter(sqliteAdapter)
- *
- * const store = new NodeStore({
- *   storage: nodeStorage,
- *   authorDID: identity.did,
- *   signingKey: identity.signingKey
- * })
- * ```
- */
-declare class SQLiteNodeStorageAdapter implements NodeStorageAdapter {
-    private db;
-    private stmtCache;
-    constructor(db: SQLiteAdapter);
-    getSQLiteAdapter(): SQLiteAdapter;
-    open(): Promise<void>;
-    close(): Promise<void>;
-    /**
-     * Get or create a prepared statement.
-     * Cached statements are reused for better performance.
-     */
-    private getStatement;
-    appendChange(change: NodeChange): Promise<void>;
-    getChanges(nodeId: NodeId): Promise<NodeChange[]>;
-    getAllChanges(): Promise<NodeChange[]>;
-    getChangesSince(sinceLamport: number): Promise<NodeChange[]>;
-    getChangeByHash(hash: ContentId): Promise<NodeChange | null>;
-    getLastChange(nodeId: NodeId): Promise<NodeChange | null>;
-    getNode(id: NodeId): Promise<NodeState | null>;
-    setNode(node: NodeState): Promise<void>;
-    /**
-     * Internal method for setting a node without starting a new transaction.
-     * Used by importNodes to avoid nested transactions.
-     */
-    private _setNodeInternal;
-    deleteNode(id: NodeId): Promise<void>;
-    listNodes(options?: ListNodesOptions): Promise<NodeState[]>;
-    /**
-     * Optimized listNodes using a single JOIN query.
-     * Fetches nodes and properties in one query for better performance with large datasets.
-     */
-    listNodesOptimized(options?: ListNodesOptions): Promise<NodeState[]>;
-    countNodes(options?: CountNodesOptions): Promise<number>;
-    getLastLamportTime(): Promise<number>;
-    setLastLamportTime(time: number): Promise<void>;
-    getDocumentContent(nodeId: NodeId): Promise<Uint8Array | null>;
-    setDocumentContent(nodeId: NodeId, content: Uint8Array): Promise<void>;
-    /**
-     * Save a Yjs snapshot for time travel.
-     */
-    saveYjsSnapshot(snapshot: {
-        nodeId: NodeId;
-        timestamp: number;
-        snapshot: Uint8Array;
-        docState: Uint8Array;
-        byteSize: number;
-    }): Promise<void>;
-    /**
-     * Get Yjs snapshots for a node.
-     */
-    getYjsSnapshots(nodeId: NodeId): Promise<Array<{
-        nodeId: NodeId;
-        timestamp: number;
-        snapshot: Uint8Array;
-        docState: Uint8Array;
-        byteSize: number;
-    }>>;
-    /**
-     * Delete Yjs snapshots for a node.
-     */
-    deleteYjsSnapshots(nodeId: NodeId): Promise<void>;
-    /**
-     * Import multiple nodes in a single transaction.
-     * Used for sync and restore operations.
-     */
-    importNodes(nodes: NodeState[]): Promise<void>;
-    /**
-     * Import multiple changes in a single transaction.
-     */
-    importChanges(changes: NodeChange[]): Promise<void>;
-    /**
-     * Clear all data (for testing or reset).
-     */
-    clear(): Promise<void>;
-    private serializePayload;
-    private deserializePayload;
-    private serializeValue;
-    private deserializeValue;
-    private deserializeChange;
-}
-
-interface NodeStoreReader {
-    get(id: string): Promise<NodeState | null>;
-    list(options?: {
-        schemaId?: string;
-        includeDeleted?: boolean;
-    }): Promise<NodeState[]>;
-    subscribe(listener: (event: NodeChangeEvent) => void): () => void;
-}
-interface DecisionCacheOptions {
-    ttlMs?: number;
-    maxSize?: number;
-    now?: () => number;
-}
-declare class DecisionCache {
-    private cache;
-    private ttlMs;
-    private readonly maxSize;
-    private readonly now;
-    constructor(options?: DecisionCacheOptions);
-    get(subject: DID$1, action: string, nodeId: string): AuthDecision | null;
-    set(subject: DID$1, action: string, nodeId: string, decision: AuthDecision): void;
-    invalidateNode(nodeId: string): void;
-    invalidateSubject(did: DID$1): void;
-    clear(): void;
-    setTTL(ttlMs: number): void;
-    private key;
-}
-interface DefaultRoleResolverOptions {
-    maxDepth?: number;
-    maxNodes?: number;
-}
-declare class DefaultRoleResolver {
-    private readonly store;
-    private readonly schemaRegistry;
-    private readonly maxDepth;
-    private readonly maxNodes;
-    constructor(store: NodeStoreReader, schemaRegistry: SchemaRegistry, options?: DefaultRoleResolverOptions);
-    resolveRoles(did: DID$1, node: NodeState, schema: Schema): Promise<Set<string>>;
-    resolveRoleMembers(resolver: RoleResolver, node: NodeState): Promise<DID$1[]>;
-    private resolveRoleMembersInner;
-    private checkRole;
-    private loadRelatedNodes;
-}
-interface DefaultPolicyEvaluatorOptions {
-    store: NodeStoreReader;
-    schemaRegistry: SchemaRegistry;
-    grantIndex?: GrantIndex;
-    cache?: DecisionCache;
-    roleResolver?: DefaultRoleResolver;
-    maxDepth?: number;
-    maxNodes?: number;
-    now?: () => number;
-    offlinePolicy?: Partial<OfflineAuthPolicy>;
-    getLastSyncedAt?: () => number;
-    isOnline?: () => boolean;
-    onRevalidation?: (event: RevalidationEvent) => void;
-    onDecision?: (event: AuthDecisionEvent) => void;
-}
-interface RevalidationEvent {
-    type: 'hybrid-revalidation';
-    at: number;
-    invalidated: 'all';
-}
-interface AuthDecisionEvent {
-    type: 'auth:decision';
-    timestamp: number;
-    subject: DID$1;
-    action: AuthDecision['action'];
-    resource: string;
-    allowed: boolean;
-    cached: boolean;
-    roles: string[];
-    reasons: AuthDenyReason[];
-    duration: number;
-}
-declare class DefaultPolicyEvaluator implements PolicyEvaluator {
-    private readonly options;
-    private readonly grantIndex?;
-    private readonly cache;
-    private readonly roleResolver;
-    private readonly now;
-    private offlinePolicy;
-    private readonly getLastSyncedAt?;
-    private readonly isOnline;
-    private readonly onRevalidation?;
-    private readonly onDecision?;
-    private lastConnectivityOnline;
-    constructor(options: DefaultPolicyEvaluatorOptions);
-    can(input: AuthCheckInput): Promise<AuthDecision>;
-    explain(input: AuthCheckInput): Promise<AuthTrace>;
-    invalidate(nodeId: string): void;
-    invalidateSubject(did: DID$1): void;
-    getOfflinePolicy(): OfflineAuthPolicy;
-    setOfflinePolicy(patch: Partial<OfflineAuthPolicy>): void;
-    handleConnectivityChange(isOnline: boolean): void;
-    private findMatchingGrant;
-    private checkFieldRules;
-    private decision;
-    private deny;
-    private loadNodeFromInput;
-    private isAuthStateStale;
-    private emitDecision;
-}
-
-interface GrantExpirationStore {
-    list(options?: {
-        schemaId?: string;
-        includeDeleted?: boolean;
-    }): Promise<Array<{
-        id: string;
-        properties: Record<string, unknown>;
-    }>>;
-    update(nodeId: string, options: {
-        properties: Record<string, unknown>;
-    }): Promise<unknown>;
-}
-interface GrantExpirationCleanerOptions {
-    clock?: () => number;
-    cleanupIntervalMs?: number;
-    clockSkewToleranceMs?: number;
-    systemRevoker?: string;
-}
-declare class GrantExpirationCleaner {
-    private readonly store;
-    static readonly DEFAULT_CLOCK_SKEW_TOLERANCE_MS = 60000;
-    static readonly DEFAULT_CLEANUP_INTERVAL_MS: number;
-    private readonly clock;
-    private readonly cleanupIntervalMs;
-    private readonly clockSkewToleranceMs;
-    private readonly systemRevoker;
-    private timer;
-    constructor(store: GrantExpirationStore, options?: GrantExpirationCleanerOptions);
-    start(): void;
-    stop(): void;
-    cleanup(): Promise<{
-        pruned: number;
-    }>;
-}
-
-/**
- * Schema types for xNet's code-first schema system.
- */
-
-/**
- * Property type identifiers.
- */
-type PropertyType = 'text' | 'number' | 'checkbox' | 'date' | 'dateRange' | 'select' | 'multiSelect' | 'person' | 'relation' | 'rollup' | 'formula' | 'url' | 'email' | 'phone' | 'file' | 'created' | 'updated' | 'createdBy';
-/**
- * Base property definition stored in a schema.
- */
-interface PropertyDefinition {
-    /** Property IRI (e.g., 'xnet://xnet.fyi/Task#title') */
-    '@id': string;
-    /** Property name */
-    name: string;
-    /** Property type */
-    type: PropertyType;
-    /** Whether this property is required */
-    required: boolean;
-    /** Type-specific configuration */
-    config?: Record<string, unknown>;
-}
-/**
- * A property builder returned by property helper functions.
- * Contains both the definition and runtime validation/coercion.
- */
-interface PropertyBuilder<T = unknown> {
-    /** The property definition for schema storage */
-    definition: Omit<PropertyDefinition, '@id' | 'name'>;
-    /** Validate a value against this property type */
-    validate(value: unknown): value is T;
-    /** Coerce a value to this property type (returns null if invalid) */
-    coerce(value: unknown): T | null;
-    /** TypeScript type marker (never used at runtime) */
-    _type: T;
-}
-/**
- * CRDT document type for collaborative content.
- *
- * When a schema specifies a document type, nodes of that schema
- * have an associated CRDT document that syncs via the CRDT's
- * native protocol (e.g., y-webrtc for Yjs).
- *
- * - 'yjs': Yjs Y.Doc for collaborative rich text, canvas, etc.
- * - 'automerge': Automerge document (future support)
- */
-type DocumentType = 'yjs' | 'automerge';
-/**
- * Schema definition stored as JSON-LD.
- */
-interface Schema {
-    /** Schema IRI */
-    '@id': SchemaIRI;
-    /** Type marker for JSON-LD */
-    '@type': 'xnet://xnet.fyi/Schema';
-    /** Human-readable name */
-    name: string;
-    /** Namespace for this schema */
-    namespace: string;
-    /**
-     * Schema version in semver format.
-     * Included in IRI as `@version` suffix.
-     */
-    version: string;
-    /**
-     * Previous schema IRI to migrate from.
-     * Used for automatic migration path discovery.
-     */
-    migrateFrom?: SchemaIRI;
-    /** Property definitions */
-    properties: PropertyDefinition[];
-    /** Parent schema IRI (for inheritance) */
-    extends?: SchemaIRI;
-    /**
-     * CRDT document type for collaborative content.
-     * When set, nodes of this schema have an associated CRDT document
-     * that syncs separately from properties (which use LWW).
-     */
-    document?: DocumentType;
-    /**
-     * Authorization rules for this schema.
-     * Defines roles, action permissions, and access control policies.
-     * When present, nodes of this schema are encrypted and access is controlled.
-     */
-    authorization?: SerializedAuthorization;
-}
-/**
- * Validation result from schema validation.
- */
-interface ValidationResult {
-    valid: boolean;
-    errors: ValidationError[];
-}
-/**
- * A single validation error.
- */
-interface ValidationError {
-    path: string;
-    message: string;
-    value?: unknown;
-}
-/**
- * Options for creating a node from a schema.
- */
-interface CreateNodeOptions {
-    /** Override the generated ID */
-    id?: string;
-    /** The creator's DID */
-    createdBy: DID;
-    /** Override the creation timestamp */
-    createdAt?: number;
-}
-/**
- * A defined schema with runtime methods.
- */
-interface DefinedSchema<TProperties extends Record<string, PropertyBuilder> = Record<string, PropertyBuilder>> {
-    /** The schema definition (JSON-LD compatible) */
-    schema: Schema;
-    /** Validate a node against this schema */
-    validate(node: unknown): ValidationResult;
-    /** Create a new node of this schema type */
-    create(properties: InferCreateProps<TProperties>, options: CreateNodeOptions): InferNode<TProperties>;
-    /** Type guard - check if a node matches this schema */
-    is(node: Node): node is InferNode<TProperties>;
-    /** Schema IRI for type inference */
-    readonly _schemaId: SchemaIRI;
-    /** Property builders for type inference */
-    readonly _properties: TProperties;
-}
-/**
- * Infer the TypeScript type from a property builder.
- */
-type InferPropertyType<B> = B extends PropertyBuilder<infer T> ? T : never;
-/**
- * Infer required properties from a record of property builders.
- */
-type RequiredKeys<P extends Record<string, PropertyBuilder>> = {
-    [K in keyof P]: P[K]['definition']['required'] extends true ? K : never;
-}[keyof P];
-/**
- * Infer optional properties from a record of property builders.
- */
-type OptionalKeys<P extends Record<string, PropertyBuilder>> = {
-    [K in keyof P]: P[K]['definition']['required'] extends true ? never : K;
-}[keyof P];
-/**
- * Infer the properties type from property builders.
- */
-type InferProperties<P extends Record<string, PropertyBuilder>> = {
-    [K in RequiredKeys<P>]: InferPropertyType<P[K]>;
-} & {
-    [K in OptionalKeys<P>]?: InferPropertyType<P[K]>;
-};
-/**
- * Infer the create props (what you pass to create()).
- * Same as InferProperties but allows undefined for optional fields.
- */
-type InferCreateProps<P extends Record<string, PropertyBuilder>> = {
-    [K in RequiredKeys<P>]: InferPropertyType<P[K]>;
-} & {
-    [K in OptionalKeys<P>]?: InferPropertyType<P[K]> | undefined;
-};
-/**
- * Infer the full Node type from property builders.
- */
-type InferNode<P extends Record<string, PropertyBuilder>> = {
-    id: string;
-    schemaId: SchemaIRI;
-    createdAt: number;
-    createdBy: DID;
-} & InferProperties<P>;
-
-/**
- * defineSchema - Create a schema definition with TypeScript inference.
- */
-
-/**
- * Options for defining a schema.
- */
-interface DefineSchemaOptions<P extends Record<string, PropertyBuilder>, A extends AuthorizationDefinition = AuthorizationDefinition> {
-    /** Schema name (e.g., 'Task', 'Page') */
-    name: string;
-    /** Namespace (e.g., 'xnet://xnet.fyi/') */
-    namespace: `xnet://${string}/`;
-    /**
-     * Schema version in semver format (e.g., '1.0.0', '2.1.0').
-     * Used for schema evolution and migration paths.
-     *
-     * Defaults to '1.0.0' if not specified.
-     *
-     * The version is included in the SchemaIRI:
-     * - Without version: `xnet://xnet.fyi/Task` (treated as @1.0.0)
-     * - With version: `xnet://xnet.fyi/Task@2.0.0`
-     */
-    version?: string;
-    /**
-     * Previous schema version to migrate from.
-     * Used to define automatic migration paths.
-     *
-     * Example: `xnet://xnet.fyi/Task@1.0.0`
-     */
-    migrateFrom?: SchemaIRI;
-    /** Property definitions */
-    properties: P;
-    /** Parent schema to extend */
-    extends?: DefinedSchema<Record<string, PropertyBuilder>>;
-    /**
-     * CRDT document type for collaborative content.
-     * - 'yjs': Yjs Y.Doc for rich text, canvas, etc.
-     * - 'automerge': Automerge document (future)
-     * - undefined: No document, properties only
-     */
-    document?: DocumentType;
-    /**
-     * Authorization rules for this schema.
-     * When present, nodes are subject to encrypted access control.
-     */
-    authorization?: A;
-}
-/**
- * Define a schema with full TypeScript inference.
- *
- * @example
- * ```typescript
- * const TaskSchema = defineSchema({
- *   name: 'Task',
- *   namespace: 'xnet://xnet.fyi/',
- *   properties: {
- *     title: text({ required: true }),
- *     status: select({ options: ['todo', 'done'] as const }),
- *     dueDate: date({})
- *   },
- *   document: 'yjs'  // Enable collaborative Y.Doc
- * })
- *
- * type Task = InferNode<typeof TaskSchema['_properties']>
- * ```
- */
-declare function defineSchema<P extends Record<string, PropertyBuilder>>(options: DefineSchemaOptions<P>): DefinedSchema<P>;
-
-/**
- * Text property helper.
- */
-
-interface TextOptions {
-    required?: boolean;
-    minLength?: number;
-    maxLength?: number;
-    pattern?: RegExp;
-    placeholder?: string;
-}
-/**
- * Define a text property.
- *
- * @example
- * ```typescript
- * const schema = defineSchema({
- *   properties: {
- *     title: text({ required: true, maxLength: 500 }),
- *     description: text({})
- *   }
- * })
- * ```
- */
-declare function text(options?: TextOptions): PropertyBuilder<string>;
-
-/**
- * Number property helper.
- */
-
-interface NumberOptions {
-    required?: boolean;
-    min?: number;
-    max?: number;
-    integer?: boolean;
-}
-/**
- * Define a number property.
- *
- * @example
- * ```typescript
- * const schema = defineSchema({
- *   properties: {
- *     price: number({ required: true, min: 0 }),
- *     quantity: number({ integer: true, min: 1 })
- *   }
- * })
- * ```
- */
-declare function number(options?: NumberOptions): PropertyBuilder<number>;
-
-/**
- * Checkbox (boolean) property helper.
- */
-
-interface CheckboxOptions {
-    required?: boolean;
-    default?: boolean;
-}
-/**
- * Define a checkbox (boolean) property.
- *
- * @example
- * ```typescript
- * const schema = defineSchema({
- *   properties: {
- *     completed: checkbox({ default: false }),
- *     archived: checkbox({})
- *   }
- * })
- * ```
- */
-declare function checkbox(options?: CheckboxOptions): PropertyBuilder<boolean>;
-
-/**
- * Date property helper.
- * Stores dates as Unix timestamps (milliseconds).
- */
-
-interface DateOptions {
-    required?: boolean;
-    includeTime?: boolean;
-}
-/**
- * Define a date property.
- * Dates are stored as Unix timestamps (milliseconds).
- *
- * @example
- * ```typescript
- * const schema = defineSchema({
- *   properties: {
- *     dueDate: date({ required: true }),
- *     reminder: date({ includeTime: true })
- *   }
- * })
- * ```
- */
-declare function date(options?: DateOptions): PropertyBuilder<number>;
-
-/**
- * Date range property helper.
- */
-
-/**
- * A date range with start and optional end.
- */
-interface DateRange$1 {
-    /** Start date as ISO 8601 string */
-    start: string;
-    /** End date as ISO 8601 string (optional for ongoing ranges) */
-    end?: string;
-}
-interface DateRangeOptions {
-    required?: boolean;
-    /** Include time, not just date */
-    includeTime?: boolean;
-}
-/**
- * Define a date range property.
- *
- * @example
- * ```typescript
- * const schema = defineSchema({
- *   properties: {
- *     duration: dateRange({ includeTime: true }),
- *     vacationPeriod: dateRange({ required: true })
- *   }
- * })
- * ```
- */
-declare function dateRange(options?: DateRangeOptions): PropertyBuilder<DateRange$1>;
-
-/**
- * Select property helper with literal type inference.
- */
-
-interface SelectOption$1 {
-    id: string;
-    name: string;
-    color?: string;
-}
-interface SelectOptions<T extends readonly SelectOption$1[]> {
-    options: T;
-    required?: boolean;
-    default?: T[number]['id'];
-}
-/**
- * Define a select (single choice) property.
- * Use `as const` on the options array for literal type inference.
- *
- * @example
- * ```typescript
- * const schema = defineSchema({
- *   properties: {
- *     status: select({
- *       options: [
- *         { id: 'todo', name: 'To Do', color: 'gray' },
- *         { id: 'done', name: 'Done', color: 'green' }
- *       ] as const,
- *       default: 'todo'
- *     }),
- *   }
- * })
- * // status type is 'todo' | 'done'
- * ```
- */
-declare function select<T extends readonly SelectOption$1[]>(options: SelectOptions<T>): PropertyBuilder<T[number]['id']>;
-
-/**
- * Multi-select property helper with literal type inference.
- */
-
-interface MultiSelectOptions<T extends readonly SelectOption$1[]> {
-    options: T;
-    required?: boolean;
-    default?: T[number]['id'][];
-}
-/**
- * Define a multi-select (multiple choice) property.
- * Use `as const` on the options array for literal type inference.
- *
- * @example
- * ```typescript
- * const schema = defineSchema({
- *   properties: {
- *     tags: multiSelect({
- *       options: [
- *         { id: 'bug', name: 'Bug', color: 'red' },
- *         { id: 'feature', name: 'Feature', color: 'blue' },
- *         { id: 'docs', name: 'Documentation', color: 'green' }
- *       ] as const
- *     }),
- *   }
- * })
- * // tags type is ('bug' | 'feature' | 'docs')[]
- * ```
- */
-declare function multiSelect<T extends readonly SelectOption$1[]>(options: MultiSelectOptions<T>): PropertyBuilder<T[number]['id'][]>;
-
-/**
- * Person (DID reference) property helper.
- */
-
-interface PersonOptions {
-    required?: boolean;
-    /** Allow multiple people */
-    multiple?: boolean;
-}
-/**
- * Define a person reference property.
- * Stores DIDs (decentralized identifiers) that reference users.
- *
- * @example
- * ```typescript
- * const schema = defineSchema({
- *   properties: {
- *     assignee: person({}),
- *     watchers: person({ multiple: true })
- *   }
- * })
- * ```
- */
-declare function person(options: PersonOptions & {
-    multiple: true;
-}): PropertyBuilder<DID[]>;
-declare function person(options?: PersonOptions): PropertyBuilder<DID>;
-
-/**
- * Relation (node reference) property helper.
- *
- * Stores a reference to another node by ID. Can optionally constrain the
- * target to a specific schema (typed relation) or leave it unconstrained
- * (untyped relation that can reference any node).
- *
- * This is the xNet equivalent of Datomic's `:db.type/ref` — it tells the
- * system that a property value is a node ID, enabling:
- * - Temp ID resolution in transactions
- * - Reverse lookups and cascade operations (future)
- * - Graph traversal through relation edges (future)
- */
-
-interface RelationOptions {
-    /**
-     * Target schema IRI to constrain this relation to a specific node type.
-     * When omitted, the relation can reference any node regardless of schema.
-     *
-     * @example
-     * // Typed: only references Task nodes
-     * parent: relation({ target: 'xnet://xnet.fyi/Task' })
-     *
-     * // Untyped: references any node
-     * target: relation({ required: true })
-     */
-    target?: SchemaIRI;
-    required?: boolean;
-    /** Allow multiple relations */
-    multiple?: boolean;
-}
-/**
- * Define a relation property that references other nodes.
- *
- * When `target` is specified, the relation is typed — it declares that
- * values should be node IDs of the given schema. When omitted, the
- * relation is untyped and can reference any node.
- *
- * @example
- * ```typescript
- * const schema = defineSchema({
- *   properties: {
- *     // Typed relation (references Task nodes only)
- *     parent: relation({ target: 'xnet://xnet.fyi/Task' }),
- *     subtasks: relation({ target: 'xnet://xnet.fyi/Task', multiple: true }),
- *
- *     // Untyped relation (references any node)
- *     target: relation({ required: true }),
- *     inReplyTo: relation({})
- *   }
- * })
- * ```
- */
-declare function relation(options: RelationOptions & {
-    multiple: true;
-}): PropertyBuilder<string[]>;
-declare function relation(options: RelationOptions): PropertyBuilder<string>;
-
-/**
- * URL property helper.
- */
-
-interface UrlOptions {
-    required?: boolean;
-    placeholder?: string;
-}
-/**
- * Define a URL property.
- *
- * @example
- * ```typescript
- * const schema = defineSchema({
- *   properties: {
- *     website: url({ placeholder: 'https://example.com' }),
- *     sourceRepo: url({ required: true })
- *   }
- * })
- * ```
- */
-declare function url(options?: UrlOptions): PropertyBuilder<string>;
-
-/**
- * Email property helper.
- */
-
-interface EmailOptions {
-    required?: boolean;
-    placeholder?: string;
-}
-/**
- * Define an email property.
- *
- * @example
- * ```typescript
- * const schema = defineSchema({
- *   properties: {
- *     email: email({ required: true, placeholder: 'user@example.com' })
- *   }
- * })
- * ```
- */
-declare function email(options?: EmailOptions): PropertyBuilder<string>;
-
-/**
- * Phone property helper.
- */
-
-interface PhoneOptions {
-    required?: boolean;
-    placeholder?: string;
-}
-/**
- * Define a phone number property.
- *
- * @example
- * ```typescript
- * const schema = defineSchema({
- *   properties: {
- *     phone: phone({ placeholder: '+1 (555) 123-4567' })
- *   }
- * })
- * ```
- */
-declare function phone(options?: PhoneOptions): PropertyBuilder<string>;
-
-/**
- * File reference property helper.
- */
-
-/**
- * File reference stored in a file property.
- */
-interface FileRef$1 {
-    /** Content-addressed ID (CID) of the file */
-    cid: string;
-    /** Original filename */
-    name: string;
-    /** MIME type */
-    mimeType: string;
-    /** File size in bytes */
-    size: number;
-}
-interface FileOptions {
-    required?: boolean;
-    /** Allow multiple files */
-    multiple?: boolean;
-    /** Accepted MIME types (e.g., ['image/*', 'application/pdf']) */
-    accept?: string[];
-    /** Maximum file size in bytes */
-    maxSize?: number;
-}
-/**
- * Define a file reference property.
- *
- * @example
- * ```typescript
- * const schema = defineSchema({
- *   properties: {
- *     avatar: file({ accept: ['image/*'], maxSize: 5_000_000 }),
- *     attachments: file({ multiple: true })
- *   }
- * })
- * ```
- */
-declare function file(options: FileOptions & {
-    multiple: true;
-}): PropertyBuilder<FileRef$1[]>;
-declare function file(options?: FileOptions): PropertyBuilder<FileRef$1>;
-
-/**
- * Created timestamp property helper.
- *
- * This is an auto-populated property that stores when a node was created.
- * The value is set automatically at node creation time and cannot be modified.
- */
-
-interface CreatedOptions {
-    /** Custom label for UI display */
-    label?: string;
-}
-/**
- * Define a created timestamp property (auto-populated).
- *
- * The value is automatically set to Date.now() when the node is created
- * and cannot be modified afterward.
- *
- * @example
- * ```typescript
- * const schema = defineSchema({
- *   properties: {
- *     createdAt: created({ label: 'Created' })
- *   }
- * })
- * // createdAt is automatically set to creation timestamp
- * ```
- */
-declare function created(options?: CreatedOptions): PropertyBuilder<number>;
-
-/**
- * Updated timestamp property helper.
- *
- * This is an auto-populated property that stores when a node was last modified.
- * The value is automatically updated on each change.
- */
-
-interface UpdatedOptions {
-    /** Custom label for UI display */
-    label?: string;
-}
-/**
- * Define an updated timestamp property (auto-populated).
- *
- * The value is automatically updated to Date.now() whenever the node is modified.
- *
- * @example
- * ```typescript
- * const schema = defineSchema({
- *   properties: {
- *     updatedAt: updated({ label: 'Last Modified' })
- *   }
- * })
- * // updatedAt is automatically updated on each change
- * ```
- */
-declare function updated(options?: UpdatedOptions): PropertyBuilder<number>;
-
-/**
- * CreatedBy (author DID) property helper.
- *
- * This is an auto-populated property that stores who created a node.
- * The value is set automatically at node creation time and cannot be modified.
- */
-
-interface CreatedByOptions {
-    /** Custom label for UI display */
-    label?: string;
-}
-/**
- * Define a createdBy (author) property (auto-populated).
- *
- * The value is automatically set to the creator's DID when the node is created
- * and cannot be modified afterward.
- *
- * @example
- * ```typescript
- * const schema = defineSchema({
- *   properties: {
- *     author: createdBy({ label: 'Author' })
- *   }
- * })
- * // author is automatically set to the creator's DID
- * ```
- */
-declare function createdBy(options?: CreatedByOptions): PropertyBuilder<DID>;
-
-declare const PageSchema: DefinedSchema<{
-    /** Page title */
-    title: PropertyBuilder<string>;
-    /** Emoji or icon URL */
-    icon: PropertyBuilder<string>;
-    /** Cover image */
-    cover: PropertyBuilder<FileRef$1>;
-}>;
-/**
- * A Page node type (inferred from schema).
- */
-type Page = InferNode<(typeof PageSchema)['_properties']>;
-
-declare const DatabaseSchema: DefinedSchema<{
-    /** Database title */
-    title: PropertyBuilder<string>;
-    /** Emoji or icon URL */
-    icon: PropertyBuilder<string>;
-    /** Cover image */
-    cover: PropertyBuilder<FileRef$1>;
-    /** Default view type for this database */
-    defaultView: PropertyBuilder<"table" | "board" | "list" | "gallery" | "calendar" | "timeline">;
-    /**
-     * Cached row count for this database.
-     * Updated on row add/delete operations.
-     * Used for query routing decisions (local vs hub).
-     */
-    rowCount: PropertyBuilder<number>;
-}>;
-/**
- * A Database node type (inferred from schema).
- */
-type Database = InferNode<(typeof DatabaseSchema)['_properties']>;
-
-declare const DatabaseRowSchema: DefinedSchema<{
-    /**
-     * Reference to the parent database.
-     * This is a typed relation that only accepts Database node IDs.
-     */
-    database: PropertyBuilder<string>;
-    /**
-     * Fractional index for row ordering.
-     * Uses a string-based fractional indexing scheme (like Figma/Linear)
-     * that allows inserting between any two rows without reindexing.
-     *
-     * @see packages/data/src/database/fractional-index.ts
-     */
-    sortKey: PropertyBuilder<string>;
-}>;
-/**
- * A DatabaseRow node type (inferred from schema).
- *
- * Note: Cell values are stored as dynamic properties with `cell_` prefix,
- * so they won't appear in this type. Use `fromCellProperties()` to extract
- * cell values from a row's properties.
- */
-type DatabaseRow = InferNode<(typeof DatabaseRowSchema)['_properties']>;
-
-declare const TaskSchema: DefinedSchema<{
-    /** Task title */
-    title: PropertyBuilder<string>;
-    /** Whether the task is completed */
-    completed: PropertyBuilder<boolean>;
-    /** Task status */
-    status: PropertyBuilder<"done" | "todo" | "in-progress" | "cancelled">;
-    /** Task priority */
-    priority: PropertyBuilder<"low" | "medium" | "high" | "urgent">;
-    /** Due date */
-    dueDate: PropertyBuilder<number>;
-    /** Assigned person */
-    assignee: PropertyBuilder<`did:key:${string}`>;
-    /** Parent task (for subtasks) */
-    parent: PropertyBuilder<string>;
-}>;
-/**
- * A Task node type (inferred from schema).
- */
-type Task = InferNode<(typeof TaskSchema)['_properties']>;
-
-declare const CanvasSchema: DefinedSchema<{
-    /** Canvas title */
-    title: PropertyBuilder<string>;
-    /** Emoji or icon URL */
-    icon: PropertyBuilder<string>;
-}>;
-/**
- * A Canvas node type (inferred from schema).
- */
-type Canvas = InferNode<(typeof CanvasSchema)['_properties']>;
-
-declare const CommentSchema: DefinedSchema<{
-    /** The Node this comment is on (any schema - Page, Task, Database, Canvas, etc.) */
-    target: PropertyBuilder<string>;
-    /** Schema IRI of the target Node (optimization hint, not enforced) */
-    targetSchema: PropertyBuilder<string>;
-    /** Root comment ID for threading (null = this IS the root) */
-    inReplyTo: PropertyBuilder<string>;
-    /** Type of anchor point */
-    anchorType: PropertyBuilder<"text" | "node" | "cell" | "row" | "column" | "canvas-position" | "canvas-object">;
-    /** JSON-encoded anchor position data */
-    anchorData: PropertyBuilder<string>;
-    /** Comment body in GitHub-flavored markdown (stored as plain text) */
-    content: PropertyBuilder<string>;
-    /** Optional file attachments */
-    attachments: PropertyBuilder<FileRef$1[]>;
-    /** DID of user being replied to (UI hint) */
-    replyToUser: PropertyBuilder<`did:key:${string}`>;
-    /** Comment ID being referenced (for "in reply to" display) */
-    replyToCommentId: PropertyBuilder<string>;
-    /** Whether the thread has been resolved */
-    resolved: PropertyBuilder<boolean>;
-    /** Who resolved the thread */
-    resolvedBy: PropertyBuilder<`did:key:${string}`>;
-    /** When the thread was resolved */
-    resolvedAt: PropertyBuilder<number>;
-    /** Whether the comment has been edited */
-    edited: PropertyBuilder<boolean>;
-    /** When the comment was last edited */
-    editedAt: PropertyBuilder<number>;
-    createdAt: PropertyBuilder<number>;
-    createdBy: PropertyBuilder<`did:key:${string}`>;
-}>;
-/**
- * A Comment node type (inferred from schema).
- */
-type Comment = InferNode<(typeof CommentSchema)['_properties']>;
-
-declare const GrantSchema: DefinedSchema<{
-    issuer: PropertyBuilder<`did:key:${string}`>;
-    grantee: PropertyBuilder<`did:key:${string}`>;
-    resource: PropertyBuilder<string>;
-    resourceSchema: PropertyBuilder<string>;
-    actions: PropertyBuilder<string>;
-    expiresAt: PropertyBuilder<number>;
-    revokedAt: PropertyBuilder<number>;
-    revokedBy: PropertyBuilder<`did:key:${string}`>;
-    ucanToken: PropertyBuilder<string>;
-    proofDepth: PropertyBuilder<number>;
-    parentGrantId: PropertyBuilder<string>;
-}>;
-type Grant = InferNode<(typeof GrantSchema)['_properties']>;
-
-/**
- * Comment anchor types and utilities.
- *
- * Anchors define where a comment attaches to content. The anchorData field
- * on Comment is JSON-encoded using these types.
- */
-type AnchorType = 'text' | 'cell' | 'row' | 'column' | 'canvas-position' | 'canvas-object' | 'node';
-/**
- * Text selection in the rich text editor.
- * Uses Yjs RelativePosition to survive concurrent edits.
- */
-interface TextAnchor {
-    /** Yjs relative position for selection start (Base64-encoded Uint8Array) */
-    startRelative: string;
-    /** Yjs relative position for selection end */
-    endRelative: string;
-    /** The quoted text at time of comment (fallback for orphaned anchors) */
-    quotedText: string;
-}
-/** Database cell anchor */
-interface CellAnchor {
-    /** Node ID of the database row */
-    rowId: string;
-    /** Schema property key of the column */
-    propertyKey: string;
-}
-/** Database row anchor */
-interface RowAnchor {
-    /** Node ID of the database row */
-    rowId: string;
-}
-/** Database column anchor */
-interface ColumnAnchor {
-    /** Schema property key of the column */
-    propertyKey: string;
-}
-/**
- * Fixed canvas position (Figma-style pin).
- * Does not move when canvas objects move.
- */
-interface CanvasPositionAnchor {
-    /** Canvas-space X coordinate */
-    x: number;
-    /** Canvas-space Y coordinate */
-    y: number;
-}
-/**
- * Canvas object attachment (follows object movement).
- */
-interface CanvasObjectAnchor {
-    /** ID of the canvas object */
-    objectId: string;
-    /** Optional offset from object origin */
-    offsetX?: number;
-    offsetY?: number;
-}
-/**
- * Whole-node comment (no additional positioning needed).
- * The target on Comment is sufficient.
- */
-interface NodeAnchor {
-}
-/** Union type for all anchor data */
-type AnchorData = TextAnchor | CellAnchor | RowAnchor | ColumnAnchor | CanvasPositionAnchor | CanvasObjectAnchor | NodeAnchor;
-/**
- * Encode anchor data for storage.
- */
-declare function encodeAnchor(data: AnchorData): string;
-/**
- * Decode anchor data from storage.
- */
-declare function decodeAnchor<T extends AnchorData>(json: string): T;
-/**
- * Type guard for text anchors.
- */
-declare function isTextAnchor(data: AnchorData): data is TextAnchor;
-/**
- * Type guard for cell anchors.
- */
-declare function isCellAnchor(data: AnchorData): data is CellAnchor;
-/**
- * Type guard for row anchors.
- */
-declare function isRowAnchor(data: AnchorData): data is RowAnchor;
-/**
- * Type guard for column anchors.
- */
-declare function isColumnAnchor(data: AnchorData): data is ColumnAnchor;
-/**
- * Type guard for canvas position anchors.
- */
-declare function isCanvasPositionAnchor(data: AnchorData): data is CanvasPositionAnchor;
-/**
- * Type guard for canvas object anchors.
- */
-declare function isCanvasObjectAnchor(data: AnchorData): data is CanvasObjectAnchor;
-/**
- * Type guard for node anchors (empty object).
- */
-declare function isNodeAnchor(data: AnchorData): data is NodeAnchor;
-
-/**
- * Comment orphan detection utilities.
- *
- * An anchor is "orphaned" when its target no longer exists:
- * - Text anchor: The relative positions can't be resolved (text was deleted)
- * - Cell anchor: The row or column was deleted
- * - Row anchor: The row was deleted
- * - Column anchor: The column was deleted
- * - Canvas position: Never orphans (coordinates are absolute)
- * - Canvas object: The object was deleted
- * - Node anchor: Never orphans (points to the target node itself)
- */
-
-/** Why an anchor is orphaned */
-type OrphanReason = 'text-deleted' | 'row-deleted' | 'column-deleted' | 'object-deleted' | 'invalid-anchor';
-/** Result of orphan detection */
-interface OrphanStatus {
-    /** Whether the anchor is orphaned */
-    orphaned: boolean;
-    /** If orphaned, the reason */
-    reason?: OrphanReason;
-    /** Human-readable context (quoted text, row title, etc.) */
-    context?: string;
-}
-/** Functions to check if entities exist */
-interface OrphanResolvers {
-    /** Check if text anchor positions are still valid */
-    resolveTextAnchor?: (anchor: TextAnchor) => {
-        from: number;
-        to: number;
-    } | null;
-    /** Check if a row exists in a database */
-    rowExists?: (rowId: string) => boolean;
-    /** Check if a column/property exists in a database */
-    columnExists?: (propertyKey: string) => boolean;
-    /** Check if a canvas object exists */
-    objectExists?: (objectId: string) => boolean;
-    /** Check if a node exists */
-    nodeExists?: (nodeId: string) => boolean;
-}
-/**
- * Check if a comment anchor is orphaned.
- *
- * @param anchorType - Type of anchor
- * @param anchorData - JSON-encoded anchor data
- * @param resolvers - Functions to check entity existence
- * @returns OrphanStatus with orphaned flag and reason
- *
- * @example
- * ```ts
- * const status = checkOrphanStatus('text', anchorData, {
- *   resolveTextAnchor: (anchor) => resolveTextAnchor(editor, anchor)
- * })
- *
- * if (status.orphaned) {
- *   console.log(`Comment orphaned: ${status.reason}`)
- * }
- * ```
- */
-declare function checkOrphanStatus(anchorType: AnchorType | string, anchorData: string, resolvers: OrphanResolvers): OrphanStatus;
-/**
- * Filter orphaned comments from a list.
- *
- * @param comments - Array of comments to check
- * @param resolvers - Functions to check entity existence
- * @returns Object with active and orphaned comments
- */
-declare function filterOrphanedComments<T extends {
-    properties: {
-        anchorType: string;
-        anchorData: string;
-    };
-}>(comments: T[], resolvers: OrphanResolvers): {
-    active: T[];
-    orphaned: {
-        comment: T;
-        status: OrphanStatus;
-    }[];
-};
-
-/**
- * All built-in schemas, keyed by their IRI.
- *
- * Both unversioned (legacy) and versioned (@1.0.0) IRIs are supported.
- * The unversioned IRIs are aliases for @1.0.0 versions.
- */
-declare const builtInSchemas: {
-    readonly 'xnet://xnet.fyi/Page@1.0.0': () => Promise<DefinedSchema<{
-        title: PropertyBuilder<string>;
-        icon: PropertyBuilder<string>;
-        cover: PropertyBuilder<FileRef$1>;
-    }>>;
-    readonly 'xnet://xnet.fyi/Database@1.0.0': () => Promise<DefinedSchema<{
-        title: PropertyBuilder<string>;
-        icon: PropertyBuilder<string>;
-        cover: PropertyBuilder<FileRef$1>;
-        defaultView: PropertyBuilder<"table" | "board" | "list" | "gallery" | "calendar" | "timeline">;
-        rowCount: PropertyBuilder<number>;
-    }>>;
-    readonly 'xnet://xnet.fyi/DatabaseRow@1.0.0': () => Promise<DefinedSchema<{
-        database: PropertyBuilder<string>;
-        sortKey: PropertyBuilder<string>;
-    }>>;
-    readonly 'xnet://xnet.fyi/Task@1.0.0': () => Promise<DefinedSchema<{
-        title: PropertyBuilder<string>;
-        completed: PropertyBuilder<boolean>;
-        status: PropertyBuilder<"done" | "todo" | "in-progress" | "cancelled">;
-        priority: PropertyBuilder<"low" | "medium" | "high" | "urgent">;
-        dueDate: PropertyBuilder<number>;
-        assignee: PropertyBuilder<`did:key:${string}`>;
-        parent: PropertyBuilder<string>;
-    }>>;
-    readonly 'xnet://xnet.fyi/Canvas@1.0.0': () => Promise<DefinedSchema<{
-        title: PropertyBuilder<string>;
-        icon: PropertyBuilder<string>;
-    }>>;
-    readonly 'xnet://xnet.fyi/Comment@1.0.0': () => Promise<DefinedSchema<{
-        target: PropertyBuilder<string>;
-        targetSchema: PropertyBuilder<string>;
-        inReplyTo: PropertyBuilder<string>;
-        anchorType: PropertyBuilder<"text" | "node" | "cell" | "row" | "column" | "canvas-position" | "canvas-object">;
-        anchorData: PropertyBuilder<string>;
-        content: PropertyBuilder<string>;
-        attachments: PropertyBuilder<FileRef$1[]>;
-        replyToUser: PropertyBuilder<`did:key:${string}`>;
-        replyToCommentId: PropertyBuilder<string>;
-        resolved: PropertyBuilder<boolean>;
-        resolvedBy: PropertyBuilder<`did:key:${string}`>;
-        resolvedAt: PropertyBuilder<number>;
-        edited: PropertyBuilder<boolean>;
-        editedAt: PropertyBuilder<number>;
-        createdAt: PropertyBuilder<number>;
-        createdBy: PropertyBuilder<`did:key:${string}`>;
-    }>>;
-    readonly 'xnet://xnet.fyi/Grant@1.0.0': () => Promise<DefinedSchema<{
-        issuer: PropertyBuilder<`did:key:${string}`>;
-        grantee: PropertyBuilder<`did:key:${string}`>;
-        resource: PropertyBuilder<string>;
-        resourceSchema: PropertyBuilder<string>;
-        actions: PropertyBuilder<string>;
-        expiresAt: PropertyBuilder<number>;
-        revokedAt: PropertyBuilder<number>;
-        revokedBy: PropertyBuilder<`did:key:${string}`>;
-        ucanToken: PropertyBuilder<string>;
-        proofDepth: PropertyBuilder<number>;
-        parentGrantId: PropertyBuilder<string>;
-    }>>;
-    readonly 'xnet://xnet.fyi/Page': () => Promise<DefinedSchema<{
-        title: PropertyBuilder<string>;
-        icon: PropertyBuilder<string>;
-        cover: PropertyBuilder<FileRef$1>;
-    }>>;
-    readonly 'xnet://xnet.fyi/Database': () => Promise<DefinedSchema<{
-        title: PropertyBuilder<string>;
-        icon: PropertyBuilder<string>;
-        cover: PropertyBuilder<FileRef$1>;
-        defaultView: PropertyBuilder<"table" | "board" | "list" | "gallery" | "calendar" | "timeline">;
-        rowCount: PropertyBuilder<number>;
-    }>>;
-    readonly 'xnet://xnet.fyi/DatabaseRow': () => Promise<DefinedSchema<{
-        database: PropertyBuilder<string>;
-        sortKey: PropertyBuilder<string>;
-    }>>;
-    readonly 'xnet://xnet.fyi/Task': () => Promise<DefinedSchema<{
-        title: PropertyBuilder<string>;
-        completed: PropertyBuilder<boolean>;
-        status: PropertyBuilder<"done" | "todo" | "in-progress" | "cancelled">;
-        priority: PropertyBuilder<"low" | "medium" | "high" | "urgent">;
-        dueDate: PropertyBuilder<number>;
-        assignee: PropertyBuilder<`did:key:${string}`>;
-        parent: PropertyBuilder<string>;
-    }>>;
-    readonly 'xnet://xnet.fyi/Canvas': () => Promise<DefinedSchema<{
-        title: PropertyBuilder<string>;
-        icon: PropertyBuilder<string>;
-    }>>;
-    readonly 'xnet://xnet.fyi/Comment': () => Promise<DefinedSchema<{
-        target: PropertyBuilder<string>;
-        targetSchema: PropertyBuilder<string>;
-        inReplyTo: PropertyBuilder<string>;
-        anchorType: PropertyBuilder<"text" | "node" | "cell" | "row" | "column" | "canvas-position" | "canvas-object">;
-        anchorData: PropertyBuilder<string>;
-        content: PropertyBuilder<string>;
-        attachments: PropertyBuilder<FileRef$1[]>;
-        replyToUser: PropertyBuilder<`did:key:${string}`>;
-        replyToCommentId: PropertyBuilder<string>;
-        resolved: PropertyBuilder<boolean>;
-        resolvedBy: PropertyBuilder<`did:key:${string}`>;
-        resolvedAt: PropertyBuilder<number>;
-        edited: PropertyBuilder<boolean>;
-        editedAt: PropertyBuilder<number>;
-        createdAt: PropertyBuilder<number>;
-        createdBy: PropertyBuilder<`did:key:${string}`>;
-    }>>;
-    readonly 'xnet://xnet.fyi/Grant': () => Promise<DefinedSchema<{
-        issuer: PropertyBuilder<`did:key:${string}`>;
-        grantee: PropertyBuilder<`did:key:${string}`>;
-        resource: PropertyBuilder<string>;
-        resourceSchema: PropertyBuilder<string>;
-        actions: PropertyBuilder<string>;
-        expiresAt: PropertyBuilder<number>;
-        revokedAt: PropertyBuilder<number>;
-        revokedBy: PropertyBuilder<`did:key:${string}`>;
-        ucanToken: PropertyBuilder<string>;
-        proofDepth: PropertyBuilder<number>;
-        parentGrantId: PropertyBuilder<string>;
-    }>>;
-};
-/**
- * Built-in schema IRIs.
- */
-type BuiltInSchemaIRI = keyof typeof builtInSchemas;
-
-/**
- * Schema Registry - Runtime lookup for schema definitions.
- *
- * The registry provides:
- * - Registration of custom schemas
- * - Lookup by schema IRI
- * - Lazy loading of built-in schemas
- * - Validation that a node matches its schema
- */
-
-/**
- * Schema Registry for runtime schema lookup.
- */
-declare class SchemaRegistry {
-    private schemas;
-    private loadingPromises;
-    private remoteResolver;
-    /**
-     * Register a custom schema.
-     *
-     * @param schema - The defined schema to register
-     * @throws If a schema with this IRI is already registered
-     */
-    register<P extends Record<string, PropertyBuilder>>(schema: DefinedSchema<P>): void;
-    /**
-     * Get a schema by IRI.
-     * For built-in schemas, this will lazy-load them on first access.
-     *
-     * @param iri - The schema IRI
-     * @returns The schema, or undefined if not found
-     */
-    get(iri: SchemaIRI): Promise<DefinedSchema | undefined>;
-    /**
-     * Get a schema synchronously (only works for already-loaded schemas).
-     *
-     * @param iri - The schema IRI
-     * @returns The schema, or undefined if not loaded
-     */
-    getSync(iri: SchemaIRI): DefinedSchema | undefined;
-    /**
-     * Check if a schema is registered (either loaded or built-in).
-     */
-    has(iri: SchemaIRI): boolean;
-    /**
-     * Check if a schema is a built-in schema.
-     */
-    isBuiltIn(iri: SchemaIRI): boolean;
-    /**
-     * Get all registered schema IRIs (including built-in).
-     */
-    getAllIRIs(): SchemaIRI[];
-    /**
-     * Unregister a custom schema.
-     * Built-in schemas cannot be unregistered.
-     *
-     * @param iri - The schema IRI to unregister
-     * @returns true if the schema was unregistered
-     */
-    unregister(iri: SchemaIRI): boolean;
-    /**
-     * Clear all custom schemas (keeps built-in schemas).
-     */
-    clear(): void;
-    /**
-     * Set a remote resolver for fetching schemas by IRI.
-     * When a schema is not found locally, the resolver is queried.
-     */
-    setRemoteResolver(resolver: (iri: SchemaIRI) => Promise<Schema | null>): void;
-    /**
-     * Get the version of a registered schema.
-     *
-     * @param iri - The schema IRI (versioned or unversioned)
-     * @returns The version string, or undefined if not found
-     */
-    getVersion(iri: SchemaIRI): string | undefined;
-    /**
-     * Get all versions of a schema by its base name.
-     *
-     * @param baseIRI - The unversioned base IRI (e.g., 'xnet://xnet.fyi/Task')
-     * @returns Array of versioned schemas, sorted by version
-     */
-    getAllVersions(baseIRI: SchemaIRI): Array<{
-        iri: SchemaIRI;
-        version: string;
-        schema: DefinedSchema;
-    }>;
-    /**
-     * Parse a schema IRI into its components.
-     */
-    parseIRI(iri: SchemaIRI): ParsedSchemaIRI;
-}
-/**
- * Default global schema registry instance.
- */
-declare const schemaRegistry: SchemaRegistry;
-
-/**
- * Lens Builder Utilities - Helper functions for creating schema lenses.
- *
- * These utilities make it easy to define common schema transformations
- * like renaming properties, converting values, or adding defaults.
- *
- * @example
- * ```typescript
- * import { composeLens, rename, convert, addDefault } from '@xnetjs/data'
- *
- * const taskV1toV2 = composeLens(
- *   'xnet://xnet.fyi/Task@1.0.0',
- *   'xnet://xnet.fyi/Task@2.0.0',
- *   rename('complete', 'status'),
- *   convert('status', { true: 'done', false: 'todo' }, { done: true, todo: false }),
- *   addDefault('priority', 'medium')
- * )
- * ```
- */
-
-/**
- * Rename a property from one name to another.
- *
- * @example
- * ```typescript
- * rename('complete', 'status')
- * // { complete: true } → { status: true }
- * ```
- */
-declare function rename(from: string, to: string): LensOperation;
-/**
- * Convert property values using a mapping.
- *
- * @example
- * ```typescript
- * convert('status',
- *   { true: 'done', false: 'todo' },     // forward map
- *   { done: true, todo: false }           // backward map
- * )
- * // { status: true } → { status: 'done' }
- * ```
- */
-declare function convert<T extends string | number | boolean, U extends string | number | boolean>(prop: string, forwardMap: Record<string, U>, backwardMap: Record<string, T>): LensOperation;
-/**
- * Add a property with a default value if it doesn't exist.
- * On backward transform, the property is removed.
- *
- * @example
- * ```typescript
- * addDefault('priority', 'medium')
- * // {} → { priority: 'medium' }
- * // { priority: 'high' } → { priority: 'high' } (unchanged)
- * ```
- */
-declare function addDefault(prop: string, defaultValue: unknown): LensOperation;
-/**
- * Remove a property from the data.
- * On backward transform, the property is restored with undefined.
- *
- * @example
- * ```typescript
- * remove('legacyField')
- * // { legacyField: 'old', other: 1 } → { other: 1 }
- * ```
- */
-declare function remove(prop: string): LensOperation;
-/**
- * Transform a property value using custom functions.
- *
- * @example
- * ```typescript
- * transform('count',
- *   (v) => v * 100,    // forward: multiply by 100
- *   (v) => v / 100     // backward: divide by 100
- * )
- * // { count: 5 } → { count: 500 }
- * ```
- */
-declare function transform(prop: string, forwardFn: (value: unknown) => unknown, backwardFn: (value: unknown) => unknown, options?: {
-    lossless?: boolean;
-}): LensOperation;
-/**
- * Copy a property to a new name (keeping the original).
- *
- * @example
- * ```typescript
- * copy('name', 'displayName')
- * // { name: 'John' } → { name: 'John', displayName: 'John' }
- * ```
- */
-declare function copy(from: string, to: string): LensOperation;
-/**
- * Merge multiple properties into a new property.
- *
- * @example
- * ```typescript
- * merge(['firstName', 'lastName'], 'fullName', (first, last) => `${first} ${last}`)
- * // { firstName: 'John', lastName: 'Doe' } → { firstName: 'John', lastName: 'Doe', fullName: 'John Doe' }
- * ```
- */
-declare function merge(fromProps: string[], toProp: string, mergeFn: (...values: unknown[]) => unknown, splitFn?: (value: unknown) => unknown[]): LensOperation;
-/**
- * Apply a condition to determine whether to apply an operation.
- *
- * @example
- * ```typescript
- * when(
- *   (data) => data.type === 'task',
- *   addDefault('priority', 'medium')
- * )
- * ```
- */
-declare function when(condition: (data: Record<string, unknown>) => boolean, operation: LensOperation): LensOperation;
-/**
- * Compose multiple lens operations into a single SchemaLens.
- *
- * @example
- * ```typescript
- * const taskV1toV2 = composeLens(
- *   'xnet://xnet.fyi/Task@1.0.0',
- *   'xnet://xnet.fyi/Task@2.0.0',
- *   rename('complete', 'status'),
- *   convert('status', { true: 'done', false: 'todo' }, { done: true, todo: false }),
- *   addDefault('priority', 'medium')
- * )
- * ```
- */
-declare function composeLens(source: SchemaIRI, target: SchemaIRI, ...operations: LensOperation[]): SchemaLens;
-/**
- * Create a lens from just operations (without source/target).
- * Useful for testing or when IRIs will be added later.
- */
-declare function createOperations(...operations: LensOperation[]): {
-    forward: (data: Record<string, unknown>) => Record<string, unknown>;
-    backward: (data: Record<string, unknown>) => Record<string, unknown>;
-    lossless: boolean;
-};
-/**
- * Create an identity lens that does no transformation.
- * Useful as a placeholder or for testing.
- */
-declare function identity(source: SchemaIRI, target: SchemaIRI): SchemaLens;
-
-/**
- * Signed update handling for document changes
- */
-
-/**
- * Options for signing an update
- */
-interface SignUpdateOptions {
-    doc: Doc;
-    update: Uint8Array;
-    authorDID: string;
-    signingKey: Uint8Array;
-    parentHash: string;
-    vectorClock: VectorClock;
-}
-/**
- * Sign a Yjs update with the author's key
- */
-declare function signUpdate(options: SignUpdateOptions): SignedUpdate;
-/**
- * Verify a signed update
- */
-declare function verifyUpdate(update: SignedUpdate, getPublicKey: (did: string) => Uint8Array | null): boolean;
-/**
- * Apply a signed update to a document
- */
-declare function applySignedUpdate(doc: Doc, update: SignedUpdate): void;
-/**
- * Capture an update during a callback and sign it
- */
-declare function captureUpdate(doc: Doc, authorDID: string, signingKey: Uint8Array, parentHash: string, vectorClock: VectorClock, callback: () => void): SignedUpdate | null;
-/**
- * Merge multiple documents into one, handling concurrent updates
- */
-declare function mergeDocuments(target: Doc, sources: Doc[]): void;
-/**
- * Get missing updates between two state vectors
- */
-declare function getMissingUpdates(doc: Doc, remoteStateVector: Uint8Array): Uint8Array;
-
-/**
- * Block type registry for document content
- */
-
-type BlockType = 'paragraph' | 'heading' | 'list' | 'todo' | 'code' | 'quote' | 'divider' | 'image' | 'embed' | 'table' | 'callout' | 'toggle';
-type Block = {
-    id: string;
-    type: BlockType;
-    parent: string;
-    content: Y.XmlFragment | Y.Map<unknown>;
-    children: string[];
-    properties: Record<string, unknown>;
-};
-/**
- * Block definition for registering new block types
- */
-interface BlockDefinition {
-    type: BlockType;
-    create: (id: string, parent: string) => Block;
-    validate: (block: Block) => boolean;
-}
-/**
- * Register a new block type
- */
-declare function registerBlockType(definition: BlockDefinition): void;
-/**
- * Create a block of a specific type
- */
-declare function createBlock(type: BlockType, id: string, parent: string): Block;
-/**
- * Validate a block
- */
-declare function validateBlock(block: Block): boolean;
-/**
- * Get all registered block types
- */
-declare function getRegisteredBlockTypes(): BlockType[];
-
-/**
- * Awareness/presence tracking for collaborative editing
- */
-
-/**
- * User presence information
- */
-interface UserPresence {
-    did: string;
-    name: string;
-    color: string;
-    cursor?: CursorPosition;
-    selection?: SelectionRange;
-}
-/**
- * Cursor position in a document
- */
-interface CursorPosition {
-    blockId: string;
-    offset: number;
-}
-/**
- * Selection range in a document
- */
-interface SelectionRange {
-    anchor: CursorPosition;
-    head: CursorPosition;
-}
-/**
- * Create an awareness instance for a document
- */
-declare function createAwareness(doc: Doc): Awareness;
-/**
- * Set local user presence
- */
-declare function setLocalPresence(awareness: Awareness, presence: UserPresence): void;
-/**
- * Clear local user presence
- */
-declare function clearLocalPresence(awareness: Awareness): void;
-/**
- * Get remote user presences
- */
-declare function getRemotePresences(awareness: Awareness): Map<number, UserPresence>;
-/**
- * Get all presences including local
- */
-declare function getAllPresences(awareness: Awareness): Map<number, UserPresence>;
-/**
- * Subscribe to presence changes
- */
-declare function onPresenceChange(awareness: Awareness, callback: (changes: {
-    added: number[];
-    updated: number[];
-    removed: number[];
-}) => void): () => void;
-/**
- * Get local client ID
- */
-declare function getLocalClientId(awareness: Awareness): number;
-/**
- * Generate a random color for user presence
- */
-declare function generateUserColor(): string;
-
-/**
- * BlobService - High-level file upload and retrieval.
- *
- * Provides a simple API for storing and retrieving files,
- * handling chunking, URL generation, and cleanup.
- */
-
-interface BlobServiceOptions {
-    /** Maximum file size in bytes (default: 100MB) */
-    maxSize?: number;
-}
-declare class BlobService {
-    private chunkManager;
-    private options;
-    private urlCache;
-    constructor(chunkManager: ChunkManager, options?: BlobServiceOptions);
-    /**
-     * Upload a File and return a FileRef for storage in node properties.
-     */
-    upload(file: File): Promise<FileRef$1>;
-    /**
-     * Upload from Uint8Array (for programmatic use).
-     */
-    uploadData(data: Uint8Array, metadata: {
-        filename: string;
-        mimeType: string;
-    }): Promise<FileRef$1>;
-    /**
-     * Get a URL for displaying/downloading a file.
-     * Creates a blob URL that should be revoked when no longer needed.
-     */
-    getUrl(ref: FileRef$1): Promise<string>;
-    /**
-     * Get raw data for a file.
-     */
-    getData(ref: FileRef$1): Promise<Uint8Array | null>;
-    /**
-     * Check if a file exists locally.
-     */
-    has(ref: FileRef$1): Promise<boolean>;
-    /**
-     * Get list of missing chunk CIDs (for sync).
-     */
-    getMissingChunks(ref: FileRef$1): Promise<ContentId[]>;
-    /**
-     * Revoke a blob URL to free memory.
-     */
-    revokeUrl(ref: FileRef$1): void;
-    /**
-     * Revoke all cached blob URLs.
-     */
-    revokeAllUrls(): void;
-}
-
-/**
- * Cell value types for database rows.
- *
- * Cell values are stored as dynamic properties on DatabaseRow nodes,
- * keyed by column ID with a `cell_` prefix to avoid collisions with
- * schema-defined properties.
- */
-/**
- * Reference to a file stored in the system.
- */
-interface FileRef {
-    /** Unique file identifier */
-    id: string;
-    /** Original file name */
-    name: string;
-    /** File size in bytes */
-    size: number;
-    /** MIME type */
-    type: string;
-    /** URL to access the file */
-    url: string;
-}
-/**
- * A date range with start and end dates.
- */
-interface DateRange {
-    /** Start date (ISO 8601 string) */
-    start: string;
-    /** End date (ISO 8601 string) */
-    end: string;
-}
-/**
- * All possible cell value types.
- *
- * - string: text, url, email, phone, select (option ID), person (DID)
- * - number: number
- * - boolean: checkbox
- * - string (ISO 8601): date
- * - DateRange: dateRange
- * - string[]: multiSelect (option IDs), relation (row IDs)
- * - FileRef: file
- * - null: empty cell
- */
-type CellValue = string | number | boolean | DateRange | string[] | FileRef | null;
-/**
- * Prefix for cell value property keys.
- * This prevents collisions with schema-defined properties like 'database' and 'sortKey'.
- */
-declare const CELL_PREFIX = "cell_";
-/**
- * Convert a column ID to a cell property key.
- *
- * @example
- * cellKey('name') // 'cell_name'
- * cellKey('status') // 'cell_status'
- */
-declare function cellKey(columnId: string): string;
-/**
- * Check if a property key is a cell value key.
- *
- * @example
- * isCellKey('cell_name') // true
- * isCellKey('database') // false
- */
-declare function isCellKey(key: string): boolean;
-/**
- * Extract the column ID from a cell property key.
- *
- * @example
- * columnIdFromKey('cell_name') // 'name'
- * columnIdFromKey('cell_status') // 'status'
- */
-declare function columnIdFromKey(key: string): string;
-/**
- * Convert a record of column ID -> value to cell key -> value.
- *
- * @example
- * toCellProperties({ name: 'John', age: 30 })
- * // { cell_name: 'John', cell_age: 30 }
- */
-declare function toCellProperties(cells: Record<string, CellValue>): Record<string, CellValue>;
-/**
- * Extract cell values from a node's properties, converting cell keys back to column IDs.
- *
- * @example
- * fromCellProperties({ cell_name: 'John', cell_age: 30, database: 'db1' })
- * // { name: 'John', age: 30 }
- */
-declare function fromCellProperties(properties: Record<string, unknown>): Record<string, CellValue>;
-/**
- * Check if a value is a valid DateRange.
- */
-declare function isDateRange(value: unknown): value is DateRange;
-/**
- * Check if a value is a valid FileRef.
- */
-declare function isFileRef(value: unknown): value is FileRef;
-/**
- * Check if a value is a valid CellValue.
- */
-declare function isCellValue(value: unknown): value is CellValue;
-
-/**
- * Row CRUD operations for database rows.
- *
- * These functions provide a high-level API for creating, updating,
- * and querying database rows. They handle:
- * - Cell value storage with column ID prefixes
- * - Sort key generation for row ordering
- * - Database row count maintenance
- */
-
-/**
- * Options for creating a new row.
- */
-interface CreateRowOptions {
-    /** Parent database ID */
-    databaseId: string;
-    /** Initial cell values (columnId -> value) */
-    cells?: Record<string, CellValue>;
-    /**
-     * Insert position: before this row's sortKey.
-     * If neither before nor after is specified, appends to end.
-     */
-    before?: string;
-    /**
-     * Insert position: after this row's sortKey.
-     * If neither before nor after is specified, appends to end.
-     */
-    after?: string;
-}
-/**
- * Options for querying rows.
- */
-interface QueryRowsOptions {
-    /** Maximum number of rows to return */
-    limit?: number;
-    /** Cursor for pagination (sortKey of last row from previous page) */
-    cursor?: string;
-    /** Property to sort by (default: 'sortKey') */
-    sortBy?: string;
-    /** Sort direction (default: 'asc') */
-    sortDirection?: 'asc' | 'desc';
-}
-/**
- * Result of a row query.
- */
-interface QueryRowsResult {
-    /** The rows matching the query */
-    rows: DatabaseRowNode[];
-    /** Cursor for the next page (undefined if no more rows) */
-    cursor?: string;
-    /** Whether there are more rows after this page */
-    hasMore: boolean;
-}
-/**
- * A database row node with extracted cell values.
- */
-interface DatabaseRowNode extends NodeState {
-    /** Extracted cell values (columnId -> value) */
-    cells: Record<string, CellValue>;
-}
-/**
- * Create a new row in a database.
- *
- * @example
- * ```typescript
- * const rowId = await createRow(store, {
- *   databaseId: 'db_abc123',
- *   cells: {
- *     name: 'John Doe',
- *     status: 'active',
- *     priority: 3
- *   }
- * })
- * ```
- */
-declare function createRow(store: NodeStore, options: CreateRowOptions): Promise<string>;
-/**
- * Update a single cell value in a row.
- *
- * @example
- * ```typescript
- * await updateCell(store, rowId, 'status', 'completed')
- * ```
- */
-declare function updateCell(store: NodeStore, rowId: string, columnId: string, value: CellValue): Promise<void>;
-/**
- * Update multiple cell values in a row.
- *
- * @example
- * ```typescript
- * await updateCells(store, rowId, {
- *   name: 'Jane Doe',
- *   status: 'active'
- * })
- * ```
- */
-declare function updateCells(store: NodeStore, rowId: string, cells: Record<string, CellValue>): Promise<void>;
-/**
- * Delete a row from a database.
- *
- * @example
- * ```typescript
- * await deleteRow(store, rowId)
- * ```
- */
-declare function deleteRow(store: NodeStore, rowId: string): Promise<void>;
-/**
- * Get a single row by ID with extracted cell values.
- *
- * @example
- * ```typescript
- * const row = await getRow(store, rowId)
- * console.log(row.cells.name) // 'John Doe'
- * ```
- */
-declare function getRow(store: NodeStore, rowId: string): Promise<DatabaseRowNode | null>;
-/**
- * Query rows for a database with pagination.
- *
- * @example
- * ```typescript
- * const { rows, hasMore, cursor } = await queryRows(store, databaseId, {
- *   limit: 50
- * })
- *
- * // Get next page
- * if (hasMore) {
- *   const nextPage = await queryRows(store, databaseId, {
- *     limit: 50,
- *     cursor
- *   })
- * }
- * ```
- */
-declare function queryRows(store: NodeStore, databaseId: string, options?: QueryRowsOptions): Promise<QueryRowsResult>;
-/**
- * Move a row to a new position.
- *
- * @example
- * ```typescript
- * // Move row between two other rows
- * await moveRow(store, rowId, {
- *   after: 'row_abc',
- *   before: 'row_xyz'
- * })
- * ```
- */
-declare function moveRow(store: NodeStore, rowId: string, position: {
-    before?: string;
-    after?: string;
-}): Promise<void>;
-/**
- * Rebalance all rows in a database.
- * Use this when sort keys get too long (> 10 chars) due to many
- * insertions at the same position.
- *
- * @example
- * ```typescript
- * if (await checkNeedsRebalancing(store, databaseId)) {
- *   await rebalanceDatabase(store, databaseId)
- * }
- * ```
- */
-declare function rebalanceDatabase(store: NodeStore, databaseId: string): Promise<void>;
-/**
- * Check if a database needs rebalancing.
- * Returns true if any sort key exceeds the maximum recommended length.
- *
- * @param maxKeyLength - Maximum key length before rebalancing (default: 10)
- */
-declare function checkNeedsRebalancing(store: NodeStore, databaseId: string, maxKeyLength?: number): Promise<boolean>;
-
-/**
- * Fractional indexing for O(1) row ordering.
- *
- * Row order uses fractional indexing instead of array positions. Each row has
- * a `sortKey` string that can be sorted lexicographically. Inserting between
- * two rows generates a key that sorts between them, without updating any other rows.
- *
- * This approach is used by Figma, Linear, and other collaborative apps because
- * it enables O(1) insert/reorder operations and works naturally with database
- * queries (`ORDER BY sort_key`).
- *
- * @example
- * ```typescript
- * generateSortKey()           // "a0" - first key
- * generateSortKey("a0")       // "a1" - append
- * generateSortKey("a0", "a1") // "a0V" - insert between
- * ```
- */
-/**
- * Generate a sort key that orders between `before` and `after`.
- *
- * @param before - The key to sort after (or undefined for start)
- * @param after - The key to sort before (or undefined for end)
- * @returns A new key that sorts between before and after
- *
- * @example
- * ```typescript
- * generateSortKey()           // "a0" - first key
- * generateSortKey("a0")       // "a1" - append
- * generateSortKey(undefined, "a0") // key before a0
- * generateSortKey("a0", "a1") // "a0V" - insert between
- * ```
- */
-declare function generateSortKey(before?: string, after?: string): string;
-/**
- * Generate a sort key with random jitter to prevent collisions.
- * Use this in high-concurrency scenarios where multiple users might
- * insert at the same position simultaneously.
- *
- * @param before - The key to sort after (or undefined for start)
- * @param after - The key to sort before (or undefined for end)
- * @returns A new key with random suffix
- */
-declare function generateSortKeyWithJitter(before?: string, after?: string): string;
-/**
- * Validate that a key is well-formed.
- */
-declare function isValidSortKey(key: string): boolean;
-/**
- * Compare two sort keys.
- * Returns negative if a < b, positive if a > b, 0 if equal.
- *
- * Uses simple string comparison (not locale-aware) to ensure
- * consistent ordering across all environments.
- */
-declare function compareSortKeys(a: string, b: string): number;
-/**
- * Rebalance sort keys for a set of rows.
- * Generates evenly-spaced keys for all rows.
- *
- * Use this when sort keys get too long (> 10 chars) due to many
- * insertions at the same position.
- *
- * @param rowIds - Row IDs in current sorted order
- * @returns Map of rowId -> new sortKey
- *
- * @example
- * ```typescript
- * const newKeys = rebalanceSortKeys(['row1', 'row2', 'row3'])
- * // Map { 'row1' => '0U', 'row2' => '0q', 'row3' => '1C' }
- * ```
- */
-declare function rebalanceSortKeys(rowIds: string[]): Map<string, string>;
-/**
- * Get the maximum recommended key length before rebalancing.
- */
-declare const MAX_KEY_LENGTH = 10;
-/**
- * Check if any keys in a list exceed the maximum recommended length.
- */
-declare function needsRebalancing(sortKeys: string[]): boolean;
-
-/**
- * Column type definitions for database columns.
- *
- * Columns are stored in the database's Y.Doc as a Y.Array of Y.Maps,
- * enabling CRDT-based ordering and real-time schema sync.
- */
-/**
- * All supported column types.
- */
-type ColumnType = 'text' | 'number' | 'checkbox' | 'date' | 'dateRange' | 'select' | 'multiSelect' | 'person' | 'url' | 'email' | 'phone' | 'file' | 'relation' | 'rollup' | 'formula' | 'richText' | 'created' | 'createdBy' | 'updated' | 'updatedBy';
-/**
- * Column definition stored in the database's Y.Doc.
- */
-interface ColumnDefinition {
-    /** Unique column ID (nanoid) */
-    id: string;
-    /** Display name */
-    name: string;
-    /** Column type */
-    type: ColumnType;
-    /** Type-specific configuration */
-    config: ColumnConfig;
-    /** Width in pixels (for table view) */
-    width?: number;
-    /** Whether this is the title column */
-    isTitle?: boolean;
-}
-/**
- * Union of all column configuration types.
- */
-type ColumnConfig = TextColumnConfig | NumberColumnConfig | SelectColumnConfig | RelationColumnConfig | RollupColumnConfig | FormulaColumnConfig | DateColumnConfig | FileColumnConfig | EmptyConfig;
-/**
- * Empty config for simple types with no configuration.
- */
-type EmptyConfig = Record<string, never>;
-/**
- * Text column configuration.
- */
-interface TextColumnConfig {
-    /** Maximum length (optional) */
-    maxLength?: number;
-}
-/**
- * Number column configuration.
- */
-interface NumberColumnConfig {
-    /** Number format */
-    format?: 'number' | 'percent' | 'currency';
-    /** Currency code (if format is currency) */
-    currency?: string;
-    /** Decimal places */
-    precision?: number;
-}
-/**
- * Select/MultiSelect column configuration.
- */
-interface SelectColumnConfig {
-    /** Available options */
-    options: SelectOption[];
-    /** Allow creating new options inline */
-    allowCreate?: boolean;
-}
-/**
- * A single select option.
- */
-interface SelectOption {
-    id: string;
-    name: string;
-    color?: SelectColor;
-}
-/**
- * Available colors for select options.
- */
-type SelectColor = 'gray' | 'brown' | 'orange' | 'yellow' | 'green' | 'blue' | 'purple' | 'pink' | 'red';
-/**
- * Relation column configuration.
- */
-interface RelationColumnConfig {
-    /** Target database ID */
-    targetDatabase: string;
-    /** Allow multiple relations */
-    allowMultiple?: boolean;
-}
-/**
- * Rollup column configuration.
- */
-interface RollupColumnConfig {
-    /** Column ID of the relation to aggregate */
-    relationColumn: string;
-    /** Column ID on related rows to aggregate */
-    targetColumn: string;
-    /** Aggregation function */
-    aggregation: RollupAggregation;
-}
-/**
- * Available rollup aggregation functions.
- */
-type RollupAggregation = 'sum' | 'avg' | 'count' | 'min' | 'max' | 'concat' | 'unique' | 'empty' | 'notEmpty' | 'percentEmpty' | 'percentNotEmpty';
-/**
- * Formula column configuration.
- */
-interface FormulaColumnConfig {
-    /** Formula expression with {{columnId}} references */
-    expression: string;
-    /** Result type */
-    resultType: 'text' | 'number' | 'date' | 'checkbox';
-    /** Cached dependencies (auto-computed from expression) */
-    dependencies?: string[];
-}
-/**
- * Date column configuration.
- */
-interface DateColumnConfig {
-    /** Include time */
-    includeTime?: boolean;
-    /** Date format */
-    format?: 'full' | 'short' | 'relative';
-}
-/**
- * File column configuration.
- */
-interface FileColumnConfig {
-    /** Accepted MIME types */
-    accept?: string[];
-    /** Allow multiple files */
-    allowMultiple?: boolean;
-}
-/**
- * Check if a column type stores data in NodeStore (vs Y.Doc).
- */
-declare function isNodeStoreColumnType(type: ColumnType): boolean;
-/**
- * Check if a column type is computed (formula/rollup).
- */
-declare function isComputedColumnType(type: ColumnType): boolean;
-/**
- * Check if a column type is auto-populated.
- */
-declare function isAutoColumnType(type: ColumnType): boolean;
-/**
- * Check if a column type uses Y.Doc for storage.
- */
-declare function isYDocColumnType(type: ColumnType): boolean;
-
-/**
- * Rich text cell support for database rows.
- *
- * Rich text cells use the row's Y.Doc for collaborative editing.
- * Each rich text column gets its own Y.XmlFragment in the doc,
- * which supports TipTap/ProseMirror content.
- *
- * Not every row needs a Y.Doc - only rows with rich text columns.
- * This is determined by the database's column definitions.
- */
-
-/**
- * Prefix for rich text cell fragments in the Y.Doc.
- */
-declare const RICHTEXT_PREFIX = "richtext_";
-/**
- * Get or create a rich text cell in the row's Y.Doc.
- * The XML fragment supports TipTap/ProseMirror content.
- *
- * @example
- * ```typescript
- * const doc = await store.getOrCreateDoc(rowId)
- * const fragment = getRichTextCell(doc, 'notes')
- *
- * // Use with TipTap editor
- * const editor = new Editor({
- *   extensions: [Collaboration.configure({ fragment })]
- * })
- * ```
- */
-declare function getRichTextCell(doc: Y.Doc, columnId: string): Y.XmlFragment;
-/**
- * Check if a row has any rich text content for a specific column.
- */
-declare function hasRichTextContent(doc: Y.Doc, columnId: string): boolean;
-/**
- * Check if any columns in the list are rich text columns.
- * Used to decide whether to create/sync a Y.Doc for a row.
- *
- * @example
- * ```typescript
- * const columns = await getColumns(databaseId)
- * if (hasRichTextColumns(columns)) {
- *   // Row needs a Y.Doc
- *   const doc = await store.getOrCreateDoc(rowId)
- * }
- * ```
- */
-declare function hasRichTextColumns(columns: ColumnDefinition[]): boolean;
-/**
- * Get all rich text column IDs from a list of columns.
- */
-declare function getRichTextColumnIds(columns: ColumnDefinition[]): string[];
-/**
- * Delete a rich text cell from the row's Y.Doc.
- * Used when a rich text column is deleted.
- */
-declare function deleteRichTextCell(doc: Y.Doc, columnId: string): void;
-/**
- * Get plain text content from a rich text cell.
- * Useful for search indexing and previews.
- */
-declare function getRichTextPlainText(doc: Y.Doc, columnId: string): string;
-
-/**
- * Database Y.Doc initialization and management.
- *
- * The database's Y.Doc contains:
- * - columns: Y.Array of column definitions
- * - views: Y.Map of view configurations
- * - meta: Y.Map of metadata (row count cache, etc.)
- */
-
-/**
- * Initialize the Y.Doc structure for a new database.
- * Creates the columns array, views map, and meta map if they don't exist.
- *
- * @example
- * ```typescript
- * const doc = new Y.Doc()
- * initializeDatabaseDoc(doc)
- * ```
- */
-declare function initializeDatabaseDoc(doc: Y.Doc): void;
-/**
- * Check if a Y.Doc has been initialized as a database doc.
- */
-declare function isDatabaseDocInitialized(doc: Y.Doc): boolean;
-/**
- * Add a default title column to a new database.
- * Returns the column ID.
- *
- * @example
- * ```typescript
- * const doc = new Y.Doc()
- * initializeDatabaseDoc(doc)
- * const titleColumnId = addDefaultTitleColumn(doc)
- * ```
- */
-declare function addDefaultTitleColumn(doc: Y.Doc): string;
-/**
- * Add a default table view to a new database.
- * Returns the view ID.
- *
- * @example
- * ```typescript
- * const doc = new Y.Doc()
- * initializeDatabaseDoc(doc)
- * addDefaultTitleColumn(doc)
- * const viewId = addDefaultTableView(doc)
- * ```
- */
-declare function addDefaultTableView(doc: Y.Doc): string;
-/**
- * Set up a new database with default title column and table view.
- * Returns the column ID and view ID.
- *
- * @example
- * ```typescript
- * const doc = new Y.Doc()
- * const { columnId, viewId } = setupNewDatabase(doc)
- * ```
- */
-declare function setupNewDatabase(doc: Y.Doc): {
-    columnId: string;
-    viewId: string;
-};
-/**
- * Get a metadata value from the database doc.
- */
-declare function getMeta<T>(doc: Y.Doc, key: string): T | undefined;
-/**
- * Set a metadata value in the database doc.
- */
-declare function setMeta<T>(doc: Y.Doc, key: string, value: T): void;
-/**
- * Delete a metadata value from the database doc.
- */
-declare function deleteMeta(doc: Y.Doc, key: string): void;
-
-/**
- * Column CRUD operations for database columns.
- *
- * Columns are stored in the database's Y.Doc as a Y.Array of Y.Maps.
- * This enables CRDT-based ordering and real-time schema sync.
- */
-
-/**
- * Get all columns from a database doc.
- *
- * @example
- * ```typescript
- * const columns = getColumns(doc)
- * console.log(columns.map(c => c.name))
- * ```
- */
-declare function getColumns(doc: Y.Doc): ColumnDefinition[];
-/**
- * Get a single column by ID.
- *
- * @example
- * ```typescript
- * const column = getColumn(doc, 'abc123')
- * if (column) {
- *   console.log(column.name, column.type)
- * }
- * ```
- */
-declare function getColumn(doc: Y.Doc, columnId: string): ColumnDefinition | null;
-/**
- * Get the index of a column by ID.
- * Returns -1 if not found.
- */
-declare function getColumnIndex(doc: Y.Doc, columnId: string): number;
-/**
- * Get the title column from a database doc.
- * Returns null if no title column is defined.
- */
-declare function getTitleColumn(doc: Y.Doc): ColumnDefinition | null;
-/**
- * Create a new column.
- * Returns the new column ID.
- *
- * @example
- * ```typescript
- * const id = createColumn(doc, {
- *   name: 'Status',
- *   type: 'select',
- *   config: {
- *     options: [
- *       { id: 'todo', name: 'To Do', color: 'gray' },
- *       { id: 'done', name: 'Done', color: 'green' }
- *     ]
- *   }
- * })
- * ```
- */
-declare function createColumn(doc: Y.Doc, definition: Omit<ColumnDefinition, 'id'>): string;
-/**
- * Update a column's properties.
- *
- * @example
- * ```typescript
- * updateColumn(doc, 'abc123', { name: 'Project Status' })
- * ```
- */
-declare function updateColumn(doc: Y.Doc, columnId: string, updates: Partial<Omit<ColumnDefinition, 'id'>>): void;
-/**
- * Delete a column.
- * Also removes the column from all views' visible columns.
- *
- * @example
- * ```typescript
- * deleteColumn(doc, 'abc123')
- * ```
- */
-declare function deleteColumn(doc: Y.Doc, columnId: string): void;
-/**
- * Reorder a column to a new position.
- *
- * @example
- * ```typescript
- * // Move column to the beginning
- * reorderColumn(doc, 'abc123', 0)
- * ```
- */
-declare function reorderColumn(doc: Y.Doc, columnId: string, newIndex: number): void;
-/**
- * Duplicate a column.
- * Returns the new column ID.
- *
- * @example
- * ```typescript
- * const newId = duplicateColumn(doc, 'abc123', 'Status (Copy)')
- * ```
- */
-declare function duplicateColumn(doc: Y.Doc, columnId: string, newName?: string): string | null;
-
-/**
- * View type definitions for database views.
- *
- * Views are stored in the database's Y.Doc as a Y.Map of view configs,
- * enabling collaborative view editing and real-time sync.
- */
-/**
- * Available view types.
- */
-type ViewType = 'table' | 'board' | 'list' | 'gallery' | 'calendar' | 'timeline';
-/**
- * View configuration stored in the database's Y.Doc.
- */
-interface ViewConfig {
-    /** Unique view ID */
-    id: string;
-    /** Display name */
-    name: string;
-    /** View type */
-    type: ViewType;
-    /** Column visibility and order */
-    visibleColumns: string[];
-    /** Per-column widths (overrides column.width) */
-    columnWidths?: Record<string, number>;
-    /** Filter configuration */
-    filters?: FilterGroup | null;
-    /** Sort configuration */
-    sorts?: SortConfig[];
-    /** Group by column ID */
-    groupBy?: string | null;
-    /** Group sort direction */
-    groupSort?: 'asc' | 'desc';
-    /** Collapsed group IDs */
-    collapsedGroups?: string[];
-    /** Cover image column ID */
-    coverColumn?: string;
-    /** Card size */
-    cardSize?: 'small' | 'medium' | 'large';
-    /** Start date column ID */
-    dateColumn?: string;
-    /** End date column ID */
-    endDateColumn?: string;
-}
-/**
- * A group of filter conditions combined with AND/OR.
- */
-interface FilterGroup {
-    /** Logical operator */
-    operator: 'and' | 'or';
-    /** Conditions or nested groups */
-    conditions: Array<FilterCondition | FilterGroup>;
-}
-/**
- * A single filter condition.
- */
-interface FilterCondition {
-    /** Column ID to filter on */
-    columnId: string;
-    /** Filter operator */
-    operator: FilterOperator;
-    /** Filter value (type depends on column type and operator) */
-    value: unknown;
-}
-/**
- * Available filter operators.
- */
-type FilterOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'isEmpty' | 'isNotEmpty' | 'greaterThan' | 'lessThan' | 'greaterOrEqual' | 'lessOrEqual' | 'before' | 'after' | 'between' | 'hasAny' | 'hasAll' | 'hasNone';
-/**
- * Sort configuration for a column.
- */
-interface SortConfig {
-    /** Column ID to sort by */
-    columnId: string;
-    /** Sort direction */
-    direction: 'asc' | 'desc';
-}
-/**
- * Check if a filter item is a group (vs a condition).
- */
-declare function isFilterGroup(item: FilterCondition | FilterGroup): item is FilterGroup;
-/**
- * Check if a filter item is a condition (vs a group).
- */
-declare function isFilterCondition(item: FilterCondition | FilterGroup): item is FilterCondition;
-/**
- * Check if a view type supports grouping.
- */
-declare function supportsGrouping(type: ViewType): boolean;
-/**
- * Check if a view type requires a date column.
- */
-declare function requiresDateColumn(type: ViewType): boolean;
-
-/**
- * View CRUD operations for database views.
- *
- * Views are stored in the database's Y.Doc as a Y.Map of view configs.
- * This enables collaborative view editing and real-time sync.
- */
-
-/**
- * Get all views from a database doc.
- *
- * @example
- * ```typescript
- * const views = getViews(doc)
- * console.log(views.map(v => v.name))
- * ```
- */
-declare function getViews(doc: Y.Doc): ViewConfig[];
-/**
- * Get a single view by ID.
- *
- * @example
- * ```typescript
- * const view = getView(doc, 'abc123')
- * if (view) {
- *   console.log(view.name, view.type)
- * }
- * ```
- */
-declare function getView(doc: Y.Doc, viewId: string): ViewConfig | null;
-/**
- * Get the first view of a specific type.
- */
-declare function getViewByType(doc: Y.Doc, type: ViewType): ViewConfig | null;
-/**
- * Create a new view.
- * Returns the new view ID.
- *
- * @example
- * ```typescript
- * const id = createView(doc, {
- *   name: 'Board View',
- *   type: 'board',
- *   visibleColumns: ['col1', 'col2'],
- *   groupBy: 'col1'
- * })
- * ```
- */
-declare function createView(doc: Y.Doc, config: Omit<ViewConfig, 'id'>): string;
-/**
- * Update a view's properties.
- *
- * @example
- * ```typescript
- * updateView(doc, 'abc123', { name: 'My Board' })
- * ```
- */
-declare function updateView(doc: Y.Doc, viewId: string, updates: Partial<Omit<ViewConfig, 'id'>>): void;
-/**
- * Delete a view.
- *
- * @example
- * ```typescript
- * deleteView(doc, 'abc123')
- * ```
- */
-declare function deleteView(doc: Y.Doc, viewId: string): void;
-/**
- * Duplicate a view.
- * Returns the new view ID.
- *
- * @example
- * ```typescript
- * const newId = duplicateView(doc, 'abc123', 'My Copy')
- * ```
- */
-declare function duplicateView(doc: Y.Doc, viewId: string, newName?: string): string;
-/**
- * Set the filters for a view.
- *
- * @example
- * ```typescript
- * setViewFilters(doc, 'view123', {
- *   operator: 'and',
- *   conditions: [
- *     { columnId: 'status', operator: 'equals', value: 'done' }
- *   ]
- * })
- * ```
- */
-declare function setViewFilters(doc: Y.Doc, viewId: string, filters: FilterGroup | null): void;
-/**
- * Clear all filters from a view.
- */
-declare function clearViewFilters(doc: Y.Doc, viewId: string): void;
-/**
- * Set the sorts for a view.
- *
- * @example
- * ```typescript
- * setViewSorts(doc, 'view123', [
- *   { columnId: 'date', direction: 'desc' },
- *   { columnId: 'name', direction: 'asc' }
- * ])
- * ```
- */
-declare function setViewSorts(doc: Y.Doc, viewId: string, sorts: SortConfig[]): void;
-/**
- * Add a sort to a view.
- */
-declare function addViewSort(doc: Y.Doc, viewId: string, sort: SortConfig): void;
-/**
- * Remove a sort from a view by column ID.
- */
-declare function removeViewSort(doc: Y.Doc, viewId: string, columnId: string): void;
-/**
- * Clear all sorts from a view.
- */
-declare function clearViewSorts(doc: Y.Doc, viewId: string): void;
-/**
- * Set the group by column for a view.
- */
-declare function setViewGroupBy(doc: Y.Doc, viewId: string, columnId: string | null): void;
-/**
- * Toggle a group's collapsed state.
- */
-declare function toggleGroupCollapsed$1(doc: Y.Doc, viewId: string, groupId: string): void;
-/**
- * Set which columns are visible in a view.
- */
-declare function setVisibleColumns(doc: Y.Doc, viewId: string, columnIds: string[]): void;
-/**
- * Show a column in a view.
- */
-declare function showColumn(doc: Y.Doc, viewId: string, columnId: string): void;
-/**
- * Hide a column in a view.
- */
-declare function hideColumn(doc: Y.Doc, viewId: string, columnId: string): void;
-/**
- * Reorder columns in a view.
- */
-declare function reorderViewColumns(doc: Y.Doc, viewId: string, columnId: string, newIndex: number): void;
-/**
- * Set a column's width in a view.
- */
-declare function setColumnWidth(doc: Y.Doc, viewId: string, columnId: string, width: number): void;
-
-/**
- * Filter operators by column type.
- *
- * Maps each column type to the filter operators that are valid for that type.
- */
-
-/**
- * Valid filter operators for each column type.
- */
-declare const OPERATORS_BY_TYPE: Record<ColumnType, FilterOperator[]>;
-/**
- * Human-readable labels for filter operators.
- */
-declare const OPERATOR_LABELS: Record<FilterOperator, string>;
-/**
- * Get valid operators for a column type.
- */
-declare function getOperatorsForType(type: ColumnType): FilterOperator[];
-/**
- * Check if an operator is valid for a column type.
- */
-declare function isValidOperator(type: ColumnType, operator: FilterOperator): boolean;
-/**
- * Get the human-readable label for an operator.
- */
-declare function getOperatorLabel(operator: FilterOperator): string;
-/**
- * Check if an operator requires a value.
- */
-declare function operatorRequiresValue(operator: FilterOperator): boolean;
-
-/**
- * Filter engine for in-memory row filtering.
- *
- * Evaluates filter groups and conditions against database rows.
- */
-
-/**
- * A database row with cells.
- */
-interface FilterableRow {
-    id: string;
-    cells: Record<string, unknown>;
-}
-/**
- * Filter rows in memory using a filter group.
- *
- * @param rows - Rows to filter
- * @param columns - Column definitions for type information
- * @param filter - Filter group to apply (null returns all rows)
- * @returns Filtered rows
- *
- * @example
- * ```typescript
- * const filtered = filterRows(rows, columns, {
- *   operator: 'and',
- *   conditions: [
- *     { columnId: 'status', operator: 'equals', value: 'active' }
- *   ]
- * })
- * ```
- */
-declare function filterRows<T extends FilterableRow>(rows: T[], columns: ColumnDefinition[], filter: FilterGroup | null): T[];
-/**
- * Create a simple equals filter.
- */
-declare function createEqualsFilter(columnId: string, value: unknown): FilterGroup;
-/**
- * Create a filter that matches any of the given values.
- */
-declare function createAnyOfFilter(columnId: string, values: unknown[]): FilterGroup;
-/**
- * Combine multiple filter groups with AND.
- */
-declare function combineFiltersAnd(filters: FilterGroup[]): FilterGroup;
-/**
- * Combine multiple filter groups with OR.
- */
-declare function combineFiltersOr(filters: FilterGroup[]): FilterGroup;
-
-/**
- * Sort engine for in-memory row sorting.
- *
- * Supports multi-column sorting with type-aware comparison.
- */
-
-/**
- * A database row with cells and sortKey.
- */
-interface SortableRow {
-    id: string;
-    sortKey: string;
-    cells: Record<string, unknown>;
-}
-/**
- * Sort rows in memory using multi-column sort config.
- *
- * @param rows - Rows to sort
- * @param columns - Column definitions for type information
- * @param sorts - Sort configurations (applied in order)
- * @returns Sorted rows (new array)
- *
- * @example
- * ```typescript
- * const sorted = sortRows(rows, columns, [
- *   { columnId: 'status', direction: 'asc' },
- *   { columnId: 'name', direction: 'desc' }
- * ])
- * ```
- */
-declare function sortRows<T extends SortableRow>(rows: T[], columns: ColumnDefinition[], sorts: SortConfig[]): T[];
-/**
- * Create a single-column sort config.
- */
-declare function createSort(columnId: string, direction?: 'asc' | 'desc'): SortConfig;
-/**
- * Toggle sort direction.
- */
-declare function toggleSortDirection(direction: 'asc' | 'desc'): 'asc' | 'desc';
-/**
- * Add or update a sort in a sort list.
- * If the column already exists, toggles direction.
- * If it doesn't exist, adds it at the beginning.
- */
-declare function addOrToggleSort(sorts: SortConfig[], columnId: string): SortConfig[];
-/**
- * Remove a sort from a sort list.
- */
-declare function removeSort(sorts: SortConfig[], columnId: string): SortConfig[];
-
-/**
- * Group engine for in-memory row grouping.
- *
- * Groups rows by column value and calculates aggregates.
- */
-
-/**
- * A database row with cells.
- */
-interface GroupableRow {
-    id: string;
-    cells: Record<string, unknown>;
-}
-/**
- * Group configuration.
- */
-interface GroupConfig {
-    /** Column ID to group by */
-    columnId: string;
-    /** Sort direction for groups */
-    sort?: 'asc' | 'desc';
-    /** Collapsed group keys */
-    collapsedGroups?: string[];
-}
-/**
- * A group of rows.
- */
-interface RowGroup<T extends GroupableRow = GroupableRow> {
-    /** Group key (column value or special key like '_empty') */
-    key: string;
-    /** Display label */
-    label: string;
-    /** Group color (for select columns) */
-    color?: string;
-    /** Rows in this group */
-    rows: T[];
-    /** Calculated aggregates */
-    aggregates: GroupAggregates;
-    /** Whether this group is collapsed */
-    collapsed?: boolean;
-}
-/**
- * Aggregate values for a group.
- */
-interface GroupAggregates {
-    /** Row count */
-    count: number;
-    /** Sum of number columns (keyed by columnId_sum) */
-    [key: string]: number | undefined;
-}
-/**
- * Group rows by a column value.
- *
- * @param rows - Rows to group
- * @param columns - Column definitions for type information
- * @param groupBy - Group configuration (null returns single group with all rows)
- * @returns Array of row groups
- *
- * @example
- * ```typescript
- * const groups = groupRows(rows, columns, { columnId: 'status' })
- * // Returns: [{ key: 'active', label: 'Active', rows: [...] }, ...]
- * ```
- */
-declare function groupRows<T extends GroupableRow>(rows: T[], columns: ColumnDefinition[], groupBy: GroupConfig | null): RowGroup<T>[];
-/**
- * Toggle a group's collapsed state.
- */
-declare function toggleGroupCollapsed(collapsedGroups: string[] | undefined, groupKey: string): string[];
-/**
- * Expand all groups.
- */
-declare function expandAllGroups(): string[];
-/**
- * Collapse all groups.
- */
-declare function collapseAllGroups<T extends GroupableRow>(groups: RowGroup<T>[]): string[];
-
-/**
- * Query pipeline for database rows.
- *
- * Executes filter -> sort -> group pipeline on rows.
- */
-
-/**
- * A row that can be processed by the query pipeline.
- */
-interface QueryableRow extends FilterableRow, SortableRow, GroupableRow {
-    id: string;
-    sortKey: string;
-    cells: Record<string, unknown>;
-}
-/**
- * Query options for the pipeline.
- */
-interface QueryOptions {
-    /** Filter configuration */
-    filter?: FilterGroup | null;
-    /** Sort configurations (applied in order) */
-    sorts?: SortConfig[];
-    /** Group configuration */
-    groupBy?: GroupConfig | null;
-    /** Maximum rows to return */
-    limit?: number;
-    /** Offset for pagination */
-    offset?: number;
-}
-/**
- * Result of a query execution.
- */
-interface QueryResult<T extends QueryableRow = QueryableRow> {
-    /** Grouped rows */
-    groups: RowGroup<T>[];
-    /** Total row count (before filtering) */
-    total: number;
-    /** Filtered row count (after filtering, before pagination) */
-    filtered: number;
-}
-/**
- * Execute a full query pipeline: filter -> sort -> group.
- *
- * @param rows - Rows to query
- * @param columns - Column definitions for type information
- * @param options - Query options
- * @returns Query result with groups, total, and filtered counts
- *
- * @example
- * ```typescript
- * const result = executeQuery(rows, columns, {
- *   filter: { operator: 'and', conditions: [{ columnId: 'status', operator: 'equals', value: 'active' }] },
- *   sorts: [{ columnId: 'name', direction: 'asc' }],
- *   groupBy: { columnId: 'status' }
- * })
- * ```
- */
-declare function executeQuery<T extends QueryableRow>(rows: T[], columns: ColumnDefinition[], options?: QueryOptions): QueryResult<T>;
-/**
- * Create a simple query with just filtering.
- */
-declare function createFilterQuery(filter: FilterGroup): QueryOptions;
-/**
- * Create a simple query with just sorting.
- */
-declare function createSortQuery(sorts: SortConfig[]): QueryOptions;
-/**
- * Create a paginated query.
- */
-declare function createPaginatedQuery(page: number, pageSize: number, options?: Omit<QueryOptions, 'limit' | 'offset'>): QueryOptions;
-/**
- * Flatten groups into a single array of rows.
- */
-declare function flattenGroups<T extends QueryableRow>(groups: RowGroup<T>[]): T[];
-/**
- * Get total row count from groups.
- */
-declare function getTotalFromGroups<T extends QueryableRow>(groups: RowGroup<T>[]): number;
-
-/**
- * Database Schema Utilities
- *
- * Utilities for generating unique, versioned schema IRIs for databases
- * and managing schema metadata stored in Y.Doc.
- */
-
-/**
- * Schema metadata stored in a database's Y.Doc.
- */
-interface DatabaseSchemaMetadata {
-    /** User-editable schema name */
-    name: string;
-    /** Optional description */
-    description?: string;
-    /** Semver version (auto-incremented) */
-    version: string;
-    /** When the database was created */
-    createdAt: number;
-    /** Last column modification time */
-    updatedAt: number;
-}
-/**
- * A stored column in a database's Y.Doc.
- */
-interface StoredColumn {
-    id: string;
-    name: string;
-    type: PropertyType;
-    config?: Record<string, unknown>;
-}
-/**
- * Schema version history entry.
- */
-interface SchemaVersionEntry {
-    version: string;
-    timestamp: number;
-    columns: StoredColumn[];
-    changeType: 'initial' | 'add' | 'update' | 'delete';
-    changeDescription?: string;
-}
-/**
- * Type of version bump.
- */
-type VersionBumpType = 'patch' | 'minor';
-/**
- * Default namespace for database-defined schemas.
- */
-declare const DATABASE_SCHEMA_NAMESPACE = "xnet://xnet.fyi/";
-/**
- * Prefix for database schema IRIs.
- */
-declare const DATABASE_SCHEMA_PREFIX = "xnet://xnet.fyi/db/";
-/**
- * Generate a schema IRI from a database ID and version.
- *
- * @example
- * buildSchemaIRI('abc123', '1.0.0') // => 'xnet://xnet.fyi/db/abc123@1.0.0'
- */
-declare function buildSchemaIRI(databaseId: string, version: string): SchemaIRI;
-/**
- * Parse a database schema IRI to extract the database ID and version.
- *
- * @returns { databaseId, version } or null if the IRI doesn't match the pattern
- *
- * @example
- * parseSchemaIRI('xnet://xnet.fyi/db/abc123@1.0.0')
- * // => { databaseId: 'abc123', version: '1.0.0' }
- */
-declare function parseDatabaseSchemaIRI(iri: string): {
-    databaseId: string;
-    version: string;
-} | null;
-/**
- * Check if an IRI is a database-defined schema IRI.
- */
-declare function isDatabaseSchemaIRI(iri: string): boolean;
-/**
- * Parse a semver version string.
- *
- * @returns { major, minor, patch } or null if invalid
- */
-declare function parseVersion(version: string): {
-    major: number;
-    minor: number;
-    patch: number;
-} | null;
-/**
- * Bump a schema version.
- *
- * - patch: 1.0.0 -> 1.0.1 (add column, update column, rename)
- * - minor: 1.0.0 -> 1.1.0 (delete column, change column type)
- *
- * @example
- * bumpSchemaVersion('1.0.0', 'patch') // => '1.0.1'
- * bumpSchemaVersion('1.0.5', 'minor') // => '1.1.0'
- */
-declare function bumpSchemaVersion(current: string, type: VersionBumpType): string;
-/**
- * Create initial schema metadata for a new database.
- */
-declare function createInitialSchemaMetadata(name: string): DatabaseSchemaMetadata;
-/**
- * Build a Schema object from database metadata and columns.
- *
- * This creates a unique, versioned schema for the database.
- *
- * @example
- * const schema = buildDatabaseSchema('db123', metadata, columns)
- * // schema['@id'] === 'xnet://xnet.fyi/db/db123@1.0.0'
- */
-declare function buildDatabaseSchema(databaseId: string, metadata: DatabaseSchemaMetadata, columns: StoredColumn[]): Schema;
-/**
- * Create a schema version history entry.
- */
-declare function createVersionEntry(version: string, columns: StoredColumn[], changeType: SchemaVersionEntry['changeType'], changeDescription?: string): SchemaVersionEntry;
-/**
- * Maximum number of version history entries to keep.
- */
-declare const MAX_VERSION_HISTORY = 50;
-/**
- * Prune version history to stay within limits.
- */
-declare function pruneVersionHistory(history: SchemaVersionEntry[]): SchemaVersionEntry[];
-/**
- * Determine the version bump type for a column operation.
- */
-declare function getVersionBumpType(operation: 'add' | 'update' | 'rename' | 'delete' | 'changeType'): VersionBumpType;
-
-/**
- * Database Schema Resolver
- *
- * Factory for creating a remote resolver that can fetch database-defined schemas
- * from their Y.Doc storage.
- */
-
-/**
- * Interface for fetching Y.Doc by document ID.
- * This allows the resolver to work with any sync mechanism.
- */
-interface DocFetcher {
-    /**
-     * Fetch a Y.Doc by its document ID.
-     * @returns The Y.Doc, or null if not found
-     */
-    getDoc(docId: string): Promise<Y.Doc | null>;
-}
-/**
- * Options for creating a database schema resolver.
- */
-interface CreateDatabaseSchemaResolverOptions {
-    /** The doc fetcher to use for retrieving Y.Doc instances */
-    docFetcher: DocFetcher;
-}
-/**
- * Create a remote resolver for database-defined schemas.
- *
- * The resolver:
- * 1. Parses the IRI to extract database ID and version
- * 2. Fetches the database's Y.Doc
- * 3. Extracts schema metadata and columns
- * 4. Builds and returns the Schema object
- *
- * @example
- * const resolver = createDatabaseSchemaResolver({
- *   docFetcher: syncManager
- * })
- * schemaRegistry.setRemoteResolver(resolver)
- */
-declare function createDatabaseSchemaResolver(options: CreateDatabaseSchemaResolverOptions): (iri: SchemaIRI) => Promise<Schema | null>;
-/**
- * Extract schema from a loaded Y.Doc.
- * Useful for direct access without going through the resolver.
- *
- * @param databaseId - The database node ID
- * @param doc - The database's Y.Doc
- * @returns The Schema object, or null if data is missing
- */
-declare function extractSchemaFromDoc(databaseId: string, doc: Y.Doc): Schema | null;
-/**
- * Get the current schema IRI for a database from its Y.Doc.
- *
- * @param databaseId - The database node ID
- * @param doc - The database's Y.Doc
- * @returns The schema IRI, or null if metadata is missing
- */
-declare function getSchemaIRIFromDoc(databaseId: string, doc: Y.Doc): SchemaIRI | null;
-
-/**
- * Database Schema Clone
- *
- * Utilities for cloning a database schema to create a new database
- * with the same structure but fresh data.
- */
-
-/**
- * Options for cloning a database schema.
- */
-interface CloneSchemaOptions {
-    /** Name for the new database (defaults to "Original Name (Copy)") */
-    name?: string;
-    /** Description for the new database */
-    description?: string;
-    /** Whether to include sample rows (default: false) */
-    includeRows?: boolean;
-    /** Maximum number of sample rows to include (default: 10) */
-    maxSampleRows?: number;
-}
-/**
- * Result of cloning a database schema.
- */
-interface CloneSchemaResult {
-    /** New column definitions with remapped IDs */
-    columns: StoredColumn[];
-    /** Mapping from old column IDs to new column IDs */
-    columnIdMap: Map<string, string>;
-    /** New schema metadata */
-    metadata: DatabaseSchemaMetadata;
-    /** Remapped view configurations */
-    views: {
-        tableView?: ViewConfig;
-        boardView?: ViewConfig;
-        [key: string]: ViewConfig | undefined;
-    };
-    /** Sample rows (if includeRows was true) */
-    sampleRows?: Array<Record<string, unknown>>;
-}
-/**
- * Source data for cloning.
- */
-interface CloneSourceData {
-    columns: StoredColumn[];
-    metadata: DatabaseSchemaMetadata;
-    tableView?: ViewConfig;
-    boardView?: ViewConfig;
-    rows?: Array<Record<string, unknown>>;
-}
-/**
- * Generate new column IDs for cloning.
- * Returns a map from old IDs to new IDs.
- */
-declare function generateColumnIdMap(columns: StoredColumn[]): Map<string, string>;
-/**
- * Clone columns with new IDs.
- */
-declare function cloneColumns(columns: StoredColumn[], idMap: Map<string, string>): StoredColumn[];
-/**
- * Remap column IDs in a view configuration.
- * This handles all the places where column IDs are referenced.
- */
-declare function remapViewColumnIds(view: ViewConfig, idMap: Map<string, string>): ViewConfig;
-/**
- * Clone sample rows with new IDs.
- */
-declare function cloneSampleRows(rows: Array<Record<string, unknown>>, idMap: Map<string, string>, maxRows?: number): Array<Record<string, unknown>>;
-/**
- * Clone a database schema to create a new database.
- *
- * This creates new column definitions, remapped view configs,
- * and fresh schema metadata with version 1.0.0.
- *
- * @param source - The source database data
- * @param options - Clone options
- * @returns The cloned schema data ready to be saved to a new Y.Doc
- *
- * @example
- * ```typescript
- * const source = {
- *   columns: getColumns(doc),
- *   metadata: getSchemaMetadata(doc),
- *   tableView: getTableView(doc),
- *   boardView: getBoardView(doc),
- *   rows: getRows(doc)
- * }
- *
- * const result = cloneSchema(source, { name: 'My New Database' })
- *
- * // Apply to new Y.Doc
- * newDoc.getMap('data').set('columns', result.columns)
- * newDoc.getMap('data').set('schema', result.metadata)
- * // etc.
- * ```
- */
-declare function cloneSchema(source: CloneSourceData, options?: CloneSchemaOptions): CloneSchemaResult;
-
-export { type AnchorData, type AnchorType, type Grant$1 as AuthGrant, BlobService, type BlobServiceOptions, type BlockDefinition, type BuiltInSchemaIRI, CELL_PREFIX, type Canvas, type CanvasObjectAnchor, type CanvasPositionAnchor, CanvasSchema, type CellAnchor, type DateRange as CellDateRange, type FileRef as CellFileRef, type CellValue, type CheckboxOptions, type CloneSchemaOptions, type CloneSchemaResult, type CloneSourceData, type ColumnAnchor, type ColumnConfig, type ColumnDefinition, type SelectOption as ColumnSelectOption, type ColumnType, type Comment, CommentSchema, type ConflictResult, type ContentKeyCache, type CountNodesOptions, type CreateDatabaseSchemaResolverOptions, type CreateNodeOptions, type CreateNodeOptions$1 as CreateNodeStoreOptions, type CreateRowOptions, type CreatedByOptions, type CreatedOptions, type CursorPosition, DATABASE_SCHEMA_NAMESPACE, DATABASE_SCHEMA_PREFIX, DEFAULT_OFFLINE_POLICY, type DID, type Database, type DatabaseRow, type DatabaseRowNode, DatabaseRowSchema, DatabaseSchema, type DatabaseSchemaMetadata, type DateColumnConfig, type DateOptions, type DateRange$1 as DateRange, type DateRangeOptions, DecisionCache, DefaultPolicyEvaluator, DefaultRoleResolver, type DefineSchemaOptions, type DefinedSchema, type DocFetcher, type EmailOptions, type EmptyConfig, type FileColumnConfig, type FileOptions, type FileRef$1 as FileRef, type FilterCondition, type FilterGroup, type FilterOperator, type FilterableRow, type FormulaColumnConfig, GRANT_SCHEMA_IRI, type GetWithMigrationOptions, type Grant, GrantExpirationCleaner, GrantIndex, type GrantInput, GrantRateLimiter, GrantSchema, type GroupAggregates, type GroupConfig, type GroupableRow, type InferCreateProps, type InferNode, type InferProperties, type InferPropertyType, type LensOperation, LensRegistry, type ListNodesOptions, MAX_KEY_LENGTH, MAX_VERSION_HISTORY, MemoryNodeStorageAdapter, type MergeConflict, type MigratedNodeState, MigrationError, type MigrationInfo, type MigrationResult, type MultiSelectOptions, type Node, type NodeAnchor, type NodeChange, type NodeChangeEvent, type NodeChangeListener, type NodeContentCipher, type NodeId, type NodePayload, type NodeState, type NodeStorageAdapter, NodeStore, type NodeStoreOptions, type NumberColumnConfig, type NumberOptions, OPERATORS_BY_TYPE, OPERATOR_LABELS, type OfflineAuthPolicy, type OrphanReason, type OrphanResolvers, type OrphanStatus, type Page, PageSchema, PermissionError, type PersonOptions, type PhoneOptions, type PropertyBuilder, type PropertyDefinition, type PropertyKey, type PropertyTimestamp, type PropertyType, type QueryOptions, type QueryResult, type QueryRowsOptions, type QueryRowsResult, type QueryableRow, RICHTEXT_PREFIX, type RelationColumnConfig, type RelationOptions, type RollupAggregation, type RollupColumnConfig, type RowAnchor, type RowGroup, SQLiteNodeStorageAdapter, type Schema, type SchemaIRI, type SchemaLens, type SchemaLookup, SchemaRegistry, type SchemaVersionEntry, type SelectColor, type SelectColumnConfig, type SelectOption$1 as SelectOption, type SelectOptions, type SelectionRange, type SignUpdateOptions, type SortConfig, type SortableRow, StoreAuth, type StoreAuthAPI, StoreAuthError, type StoreAuthErrorCode, type StoreAuthKeyManager, type StoreAuthOptions, type StoreAuthStore, type StoredColumn, TEMP_ID_PREFIX, type Task, TaskSchema, type TempIdResolution, type TextAnchor, type TextColumnConfig, type TextOptions, type TransactionOperation, type TransactionResult, type UpdateNodeOptions, type UpdatedOptions, type UrlOptions, type UserPresence, type ValidationError, type ValidationResult, type VersionBumpType, type ViewConfig, type ViewType, addDefault, addDefaultTableView, addDefaultTitleColumn, addOrToggleSort, addViewSort, applySignedUpdate, buildDatabaseSchema, buildSchemaIRI, builtInSchemas, bumpSchemaVersion, captureUpdate, cellKey, checkNeedsRebalancing, checkOrphanStatus, checkbox, clearLocalPresence, clearViewFilters, clearViewSorts, cloneColumns, cloneSampleRows, cloneSchema, collapseAllGroups, columnIdFromKey, combineFiltersAnd, combineFiltersOr, compareSortKeys, composeLens, convert, copy, createAnyOfFilter, createAwareness, createBlock, createColumn, createDatabaseSchemaResolver, createEqualsFilter, createFilterQuery, createInitialSchemaMetadata, createNodeId, createOperations, createPaginatedQuery, createRow, createSchemaLookup, createSort, createSortQuery, createVersionEntry, createView, created, createdBy, date, dateRange, decodeAnchor, defineSchema, deleteColumn, deleteMeta, deleteRichTextCell, deleteRow, deleteView, duplicateColumn, duplicateView, email, encodeAnchor, executeQuery, expandAllGroups, extractSchemaFromDoc, file, filterOrphanedComments, filterRows, flattenGroups, fromCellProperties, generateColumnIdMap, generateSortKey, generateSortKeyWithJitter, generateUserColor, getAllPresences, getColumn, getColumnIndex, getColumns, getLocalClientId, getMeta, getMissingUpdates, getOperatorLabel, getOperatorsForType, getRegisteredBlockTypes, getRemotePresences, getRichTextCell, getRichTextColumnIds, getRichTextPlainText, getRow, getSchemaIRIFromDoc, getTitleColumn, getTotalFromGroups, getVersionBumpType, getView, getViewByType, getViews, groupRows, hasRichTextColumns, hasRichTextContent, hideColumn, identity, initializeDatabaseDoc, isAutoColumnType, isCanvasObjectAnchor, isCanvasPositionAnchor, isCellAnchor, isDateRange as isCellDateRange, isFileRef as isCellFileRef, isCellKey, isCellValue, isColumnAnchor, isComputedColumnType, isDatabaseDocInitialized, isDatabaseSchemaIRI, isFilterCondition, isFilterGroup, isGrantActive, isNode, isNodeAnchor, isNodeStoreColumnType, isRowAnchor, isTempId, isTextAnchor, isValidOperator, isValidSortKey, isYDocColumnType, lensRegistry, merge, mergeDocuments, mergeOfflinePolicy, moveRow, multiSelect, needsRebalancing, number, onPresenceChange, operatorRequiresValue, parseDatabaseSchemaIRI, parseVersion, person, phone, pruneVersionHistory, queryRows, rebalanceDatabase, rebalanceSortKeys, registerBlockType, relation, remapViewColumnIds, remove, removeSort, removeViewSort, rename, reorderColumn, reorderViewColumns, requiresDateColumn, resolveTempIds, schemaRegistry, select, setColumnWidth, setLocalPresence, setMeta, setViewFilters, setViewGroupBy, setViewSorts, setVisibleColumns, setupNewDatabase, showColumn, signUpdate, sortRows, supportsGrouping, text, toCellProperties, toggleGroupCollapsed$1 as toggleGroupCollapsed, toggleGroupCollapsed as toggleGroupCollapsedState, toggleSortDirection, transform, updateCell, updateCells, updateColumn, updateView, updated, url, validateBlock, verifyUpdate, when };
+export { BlobService, type BlobServiceOptions, type BlockDefinition, DEFAULT_EXTERNAL_REFERENCE_IFRAME_ALLOW, EMBED_PROVIDERS, type EmbedProvider, type EmbedRegistryIframeSecurityAttributes, type EmbedRegistryPolicyDecision, type EmbedRegistryProvider, type EmbedRegistryProviderPolicy, type EvaluateEmbedRegistryPolicyInput, type EvaluateExternalReferenceEmbedPolicyInput, type ExternalReferenceDescriptor, type ExternalReferenceEmbedBlockReason, type ExternalReferenceEmbedPolicy, type ExternalReferenceEmbedPolicyDecision, type ExternalReferenceIframeSandboxToken, type ExternalReferenceKind, type ExternalReferenceMetadataFetcher, type ExternalReferenceMetadataResult, type ExternalReferenceMetadataSource, type ExternalReferenceMetadataStatus, type ExternalReferenceProvider, type ExternalReferenceResolvedMetadata, FileRef, type ResolveExternalReferenceMetadataInput, createBlock, detectEmbedProvider, evaluateEmbedRegistryPolicy, evaluateExternalReferenceEmbedPolicy, getEmbedRegistryProviderPolicies, getEmbedRegistryProviderPolicy, getExternalReferenceOEmbedEndpoint, getRegisteredBlockTypes, normalizeExternalReferenceUrl, parseEmbedUrl, parseExternalReferenceUrl, parseOpenGraphMetadata, registerBlockType, resolveExternalReferenceMetadata, validateBlock };