@xnetjs/data 0.0.2 → 0.1.0

package/dist/space-membership-DEUMM7NV.js

@@ -0,0 +1,14 @@
+import {
+  SPACE_MEMBERSHIP_SCHEMA_IRI,
+  SpaceMembershipSchema,
+  isSpaceRole,
+  spaceMembershipId
+} from "./chunk-T5AZAOG5.js";
+import "./chunk-EBNMV2VO.js";
+import "./chunk-RL64OJJ5.js";
+export {
+  SPACE_MEMBERSHIP_SCHEMA_IRI,
+  SpaceMembershipSchema,
+  isSpaceRole,
+  spaceMembershipId
+};

package/dist/store/index.d.ts

@@ -0,0 +1,518 @@
+import { g as NodeStorageAdapter, r as NodeChange, i as NodeId, h as NodeState, aa as NodeBatchPreflightResult, a3 as ImportNodesOptions, a5 as ApplyNodeBatchInput, a6 as ApplyNodeBatchResult, L as ListNodesOptions, ae as CountNodesOptions, a2 as SetNodeOptions, j as NodeQueryDescriptor, k as NodeQueryResult, S as SchemaIRI, a4 as RebuildNodeIndexesOptions, bi as NodeReadAuthorizer, bj as AuthorizationStateVersion } from '../types-S-BJAKyK.js';
+export { av as ConflictResult, ay as ContentKeyCache, C as CreateNodeOptions, ab as DeterministicNodeBatchWriteInput, m as DeterministicNodeImportDraft, G as GetWithMigrationOptions, n as ImportDeterministicNodesOptions, o as ImportDeterministicNodesResult, s as MergeConflict, M as MigratedNodeState, az as MigrationInfo, aw as NodeBatchChangeEvent, u as NodeBatchChangeListener, a7 as NodeBatchIndexMode, a8 as NodeBatchNotificationMode, a9 as NodeBatchSyncMode, p as NodeBatchWriteInput, ac as NodeBatchWritePolicy, q as NodeBatchWriteResult, ad as NodeBatchWriteTimings, v as NodeChangeEvent, t as NodeChangeListener, ax as NodeContentCipher, a0 as NodePayload, ar as NodeQueryCursor, aq as NodeQueryCursorOrderEntry, ao as NodeQueryMaterializedViewOptions, as as NodeQueryOptions, N as NodeQueryPageCountMode, ap as NodeQueryPageOptions, au as NodeQueryParityCheckMetadata, at as NodeQueryPlanMetadata, 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, f as NodeStoreOptions, bk as OperationNodeBatchWriteInput, $ as PropertyKey, bl as PropertyLookup, a1 as PropertyTimestamp, aR as SchemaLookup, c as SortDirection, d as SystemOrderField, aO as TEMP_ID_PREFIX, aS as TempIdResolution, T as TransactionOperation, l as TransactionResult, U as UpdateNodeOptions, aI as applyNodeQueryDescriptor, aA as createNodeQueryDescriptor, bm as createPropertyLookup, aQ as createSchemaLookup, aC as decodeNodeQueryCursor, aB as encodeNodeQueryCursor, aG as filterNodeQueryResults, aJ as getNodeQuerySearchTokens, aN as isTempId, aF as matchesNodeQueryDescriptor, 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';
+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';
+import { AuthAction, DID, AuthDenyReason, AuthDecision, ContentId } from '@xnetjs/core';
+import { SQLiteAdapter, SQLiteOperationStats } from '@xnetjs/sqlite';
+import '@xnetjs/crypto';
+import '@xnetjs/sync';
+
+/**
+ * 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;
+    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;
+    private syncCursors;
+    withTransaction<T>(fn: (storage: NodeStorageAdapter) => Promise<T>): Promise<T>;
+    appendChange(change: NodeChange): Promise<void>;
+    appendChanges(changes: readonly 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>;
+    getLastChangesByNodeId(nodeIds: readonly NodeId[]): Promise<Map<NodeId, NodeChange>>;
+    getNode(id: NodeId): Promise<NodeState | null>;
+    getNodes(ids: readonly NodeId[]): Promise<NodeState[]>;
+    getExistingNodeIds(ids: readonly NodeId[]): Promise<NodeId[]>;
+    getBatchPreflight(ids: readonly NodeId[]): Promise<NodeBatchPreflightResult>;
+    setNode(node: NodeState): Promise<void>;
+    importNodes(nodes: readonly NodeState[], _options?: ImportNodesOptions): Promise<void>;
+    applyNodeBatch(input: ApplyNodeBatchInput): Promise<ApplyNodeBatchResult>;
+    deleteNode(id: NodeId): Promise<void>;
+    listNodes(options?: ListNodesOptions): Promise<NodeState[]>;
+    countNodes(options?: CountNodesOptions): Promise<number>;
+    getLastLamportTime(): Promise<number>;
+    setLastLamportTime(time: number): Promise<void>;
+    getSyncCursor(room: string): Promise<number>;
+    setSyncCursor(room: string, lamport: 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;
+    private createSnapshot;
+    private restoreSnapshot;
+}
+
+/**
+ * SQLite storage adapter for NodeStore.
+ *
+ * Provides high-performance storage for nodes and changes using SQLite.
+ * Works with any SQLiteAdapter implementation (Electron, Web, Expo).
+ */
+
+interface SQLiteAdaptiveIndexingOptions {
+    enabled?: boolean;
+    minHits?: number;
+    minDurationMs?: number;
+    minCandidates?: number;
+    maxIndexesPerSchema?: number;
+    maxEstimatedBytesPerSchema?: number;
+    maxIndexedRowsPerSchema?: number;
+    dropUnusedAfterMs?: number;
+}
+interface SQLiteQueryVerificationOptions {
+    enabled?: boolean;
+    maxNodes?: number;
+    logFailures?: boolean;
+}
+interface SQLiteNodeStorageAdapterOptions {
+    adaptiveIndexing?: SQLiteAdaptiveIndexingOptions;
+    queryVerification?: SQLiteQueryVerificationOptions;
+    /**
+     * Collect EXPLAIN QUERY PLAN + index inventory per query. Costs extra
+     * round trips per query, so it is off unless explicitly enabled or the
+     * `xnet:query:debug` localStorage flag is set.
+     */
+    queryDiagnostics?: boolean;
+    /**
+     * Hydrate via SQL-side `json_group_object` aggregation — ONE row per node
+     * instead of one row per (node × property) — collapsing the boundary
+     * payload before it leaves SQLite (exploration 0264, Wave 2). Off by
+     * default while the mode is benchmarked; correctness is verified equal by
+     * the hydration test suite in both modes.
+     */
+    aggregatedHydration?: boolean;
+    /**
+     * Defer maintenance work (adaptive index creation) to an idle scheduler
+     * instead of running it inline on the query path. The web app passes a
+     * bootSettled-gated scheduler — no background work is free on the single
+     * serial SQLite worker (exploration 0260/0264). Default: run inline.
+     */
+    scheduleMaintenance?: (task: () => Promise<void> | void) => void;
+}
+/**
+ * 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;
+    private adaptiveIndexing;
+    private queryVerification;
+    private queryDiagnostics;
+    /** Hydrate one row per node via json_group_object (0264 Wave 2 flag). */
+    private aggregatedHydration;
+    /** Idle scheduler for maintenance work (adaptive index creation, 0264). */
+    private scheduleMaintenance?;
+    private pendingQueryTelemetry;
+    private pendingQueryTelemetryHits;
+    private adaptiveIndexBudgetColumnsReady;
+    private storageCapabilitiesPromise?;
+    private spatialTablesState;
+    private fullTextSearchTablesState;
+    private writeQueue;
+    /**
+     * Read-authorization filter applied before persisting a materialized view's
+     * id list (exploration 0226). Wired by `NodeStore` when an auth evaluator is
+     * present; `undefined` means materialized views are computed unauthorized
+     * (the trusted single-user case).
+     */
+    private nodeReadAuthorizer?;
+    /** One-time guard: ensure the `auth_fingerprint` column exists on upgraded DBs. */
+    private materializationColumnsReady;
+    constructor(db: SQLiteAdapter, options?: SQLiteNodeStorageAdapterOptions);
+    getSQLiteAdapter(): SQLiteAdapter;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Get or create a prepared statement.
+     * Cached statements are reused for better performance.
+     */
+    private getStatement;
+    private enqueueWrite;
+    withTransaction<T>(fn: (storage: NodeStorageAdapter) => Promise<T>): Promise<T>;
+    private createTransactionStorageAdapter;
+    appendChange(change: NodeChange): Promise<void>;
+    private appendChangeInternal;
+    appendChanges(changes: readonly NodeChange[]): Promise<void>;
+    private appendChangesInternal;
+    getChanges(nodeId: NodeId): Promise<NodeChange[]>;
+    getAllChanges(): Promise<NodeChange[]>;
+    getChangesSince(sinceLamport: number): Promise<NodeChange[]>;
+    /**
+     * Compact the local change log (exploration 0254 / F3): delete only
+     * *superseded* history so the OPFS file shrinks (fast cold open) and the
+     * outbound-resync slice shrinks (cheap first sync), without affecting reads,
+     * outbound sync, hash-chain chaining, or convergence with peers that never
+     * compacted.
+     *
+     * A row is deleted iff ALL of:
+     *  - `lamport_time < wsafe` — below the confirmed-durable floor, so the hub
+     *    holds it and it is not part of the unconfirmed outbound tail (K1);
+     *  - it is NOT a node's hash-chain tip — we keep every row at a node's
+     *    `MAX(lamport_time)` (the whole tie group), so `getLastChange()` still
+     *    returns a real tip and the next write's `parentHash`/hash/signature are
+     *    byte-identical to an uncompacted peer's (K2);
+     *  - it backs NO currently-winning LWW value — its `(node_id, lamport_time,
+     *    author)` is not the provenance of any live `node_properties` row (K3).
+     *
+     * K3 is the load-bearing safety net: because every live projection value keeps
+     * its backing row, the retained log still materialises to — and can re-push —
+     * the exact current state, so a stranded/rolled-back peer never loses live
+     * data. Reads are unaffected (they read the materialized `nodes`/
+     * `node_properties`, never the log). Only rows are deleted, never rewritten
+     * (the hash + signature are immutable and unforgeable). Runs chunked inside
+     * the write lane, yields between chunks, and never throws.
+     */
+    pruneSupersededChanges(wsafe: number, options?: {
+        chunk?: number;
+        maxRows?: number;
+    }): Promise<{
+        deleted: number;
+    }>;
+    getChangeByHash(hash: ContentId): Promise<NodeChange | null>;
+    getLastChange(nodeId: NodeId): Promise<NodeChange | null>;
+    getLastChangesByNodeId(nodeIds: readonly NodeId[]): Promise<Map<NodeId, NodeChange>>;
+    getNode(id: NodeId): Promise<NodeState | null>;
+    getNodes(ids: readonly NodeId[]): Promise<NodeState[]>;
+    getExistingNodeIds(ids: readonly NodeId[]): Promise<NodeId[]>;
+    getBatchPreflight(ids: readonly NodeId[]): Promise<NodeBatchPreflightResult>;
+    setNode(node: NodeState, options?: SetNodeOptions): 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>;
+    private deleteNodeInternal;
+    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>;
+    queryNodes(descriptor: NodeQueryDescriptor): Promise<NodeQueryResult>;
+    getLastLamportTime(): Promise<number>;
+    setLastLamportTime(time: number): Promise<void>;
+    private setLastLamportTimeInternal;
+    private syncCursorKey;
+    getSyncCursor(room: string): Promise<number>;
+    /**
+     * The lowest confirmed-durable sync cursor across every node-change room
+     * (`MIN` over the persisted `nodeSync:hwm:*` marks), or `null` when no room has
+     * ever confirmed. This is the safe compaction floor (exploration 0254): the
+     * hub durably holds every change at or below it. Returns `null` — never 0 — so
+     * a workspace that has never synced is left untouched.
+     */
+    getMinConfirmedSyncCursor(): Promise<number | null>;
+    setSyncCursor(room: string, lamport: number): Promise<void>;
+    /** Namespace app-state keys so they can't collide with sync cursors. */
+    private appStateKey;
+    getAppState(key: string): Promise<string | null>;
+    setAppState(key: string, value: string): Promise<void>;
+    getDocumentContent(nodeId: NodeId): Promise<Uint8Array | null>;
+    setDocumentContent(nodeId: NodeId, content: Uint8Array): Promise<void>;
+    private setDocumentContentInternal;
+    /**
+     * 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: readonly NodeState[], options?: ImportNodesOptions): Promise<void>;
+    applyNodeBatch(input: ApplyNodeBatchInput): Promise<ApplyNodeBatchResult>;
+    getOperationStats(): Promise<SQLiteOperationStats | null> | SQLiteOperationStats | null;
+    resetOperationStats(): Promise<void> | void;
+    private resolveApplyNodeBatchInput;
+    private canApplyNodeBatchWithTransactionBatch;
+    private canApplyNodeBatchWithTypedAdapterCommand;
+    private applyNodeBatchWithTypedAdapterCommand;
+    private createSQLiteNodeBatchApplyInput;
+    private applyNodeBatchWithTransactionBatch;
+    private applyNodeBatchInternal;
+    private importNodesInternal;
+    private canImportNodesWithTransactionBatch;
+    private importNodesWithTransactionBatch;
+    private createImportNodeOperations;
+    private createImportNodeOperationsForIndexMode;
+    private createAppendChangeOperation;
+    private createSetLastLamportTimeOperation;
+    private createInvalidateMaterializedViewsOperation;
+    private createDeleteRemovedPropertiesOperation;
+    private createScalarIndexOperations;
+    private createFullTextIndexOperations;
+    private countScalarIndexRowsForNode;
+    private hasSearchableNodeContent;
+    private syncTouchedIndexesForNodes;
+    /**
+     * Refresh the full query-planner statistics (`ANALYZE`). Call after a bulk
+     * import: SQLite does not auto-maintain stats, so a large insert leaves the
+     * planner "out of sync" and reads can pick full scans over indexes
+     * (exploration 0184). Best-effort — never throws into the caller.
+     */
+    analyze(): Promise<void>;
+    /**
+     * Incremental planner maintenance (`PRAGMA optimize`) — only ANALYZEs tables
+     * whose row counts have drifted. Cheap; safe to call at idle / before close.
+     */
+    optimize(): Promise<void>;
+    rebuildIndexesForSchemas(schemaIds: readonly SchemaIRI[], options?: RebuildNodeIndexesOptions): Promise<void>;
+    private rebuildIndexesForSchemasInternal;
+    private rebuildScalarIndexesForSchemas;
+    private rebuildSpatialIndexesForSchemas;
+    private rebuildFullTextIndexesForSchemas;
+    /**
+     * Rebuild the scalar sidecar from materialized node_properties.
+     */
+    rebuildScalarIndex(): Promise<{
+        nodesScanned: number;
+        scalarRowsWritten: number;
+    }>;
+    /**
+     * Import multiple changes in a single transaction.
+     */
+    importChanges(changes: readonly NodeChange[]): Promise<void>;
+    /**
+     * Clear all data (for testing or reset).
+     */
+    clear(): Promise<void>;
+    private hydrateJoinedRows;
+    private buildHydrateChunkQuery;
+    private hydrateNodesByIds;
+    /**
+     * Aggregated hydrate (exploration 0264, Wave 2): collapse the EAV rows to
+     * ONE row per node inside SQL via `json_group_object`, so the boundary
+     * ships N rows instead of N × properties. `value` is stored as JSON text
+     * in a BLOB — `json(CAST(… AS TEXT))` re-emits it as real JSON inside the
+     * aggregate (without the cast/wrap it would double-encode as a string).
+     */
+    private buildAggregatedHydrateChunkQuery;
+    /** Parse one-row-per-node aggregated hydrate results into NodeStates. */
+    private hydrateAggregatedRows;
+    /**
+     * Read (or refresh) a materialized view.
+     *
+     * A materialized view is a purely LOCAL, DERIVED cache: an ordered list of
+     * node ids (membership + order) plus bookkeeping. It is NEVER part of the
+     * change log and is NEVER synced — peers each derive their own. It therefore
+     * carries no authority and can be rebuilt or dropped at any time (a wiped
+     * cache only costs a recompute, never data). Content is re-hydrated from the
+     * live `nodes`/`node_properties` tables on every read, so the cache exposes
+     * nothing the underlying tables don't already, and a write to the schema
+     * (`invalidated_at`) or a grant change (`auth_fingerprint`) forces a
+     * re-materialization. See exploration 0226.
+     */
+    private queryMaterializedView;
+    private getMaterializedView;
+    /**
+     * Ensure the `auth_fingerprint` column exists. Fresh databases get it from
+     * the DDL; databases upgraded in place (the runtime applies the full DDL with
+     * `CREATE TABLE IF NOT EXISTS`, which cannot add a column) need this guard.
+     * Idempotent and memoized (exploration 0226).
+     */
+    private ensureMaterializationColumns;
+    setNodeReadAuthorizer(authorizer: NodeReadAuthorizer | undefined): void;
+    /**
+     * Reload-stable version of the authorization-relevant control-plane state:
+     * grants (`Grant` schema) and per-subject `/sys/authz/` resources. Ordinary
+     * data writes do not touch these, so a database's materialized views survive
+     * reloads and edits, but any grant change shifts `count`/`maxUpdatedAt` and
+     * forces an `'authz-changed'` refresh (exploration 0226).
+     */
+    getAuthorizationStateVersion(): Promise<AuthorizationStateVersion>;
+    private refreshMaterializedView;
+    private readMaterializedViewPage;
+    private invalidateMaterializedViewsForSchema;
+    private clearMaterializedViewRows;
+    private deleteRemovedProperties;
+    private syncScalarRowsForNode;
+    private prepareFullTextSearchQueryPlan;
+    private hasFullTextSearchTable;
+    private prepareSpatialQueryPlan;
+    private ensureSpatialTables;
+    private hasSpatialTables;
+    private createSpatialIndexConfig;
+    private syncSpatialRowsForNode;
+    private replaceSpatialRowForConfig;
+    private deleteSpatialRowsForNode;
+    private deleteSpatialRow;
+    private clearSpatialRowsForConfig;
+    private clearSpatialRows;
+    private buildSpatialIndexKey;
+    private getSpatialFieldConfig;
+    private getSpatialSearchBounds;
+    private getNodeSpatialBounds;
+    private getFiniteNumberProperty;
+    private toScalarIndexValue;
+    private hashScalarValue;
+    private stringifyStable;
+    private quoteSqlLiteral;
+    private quoteSqlIdentifier;
+    private recordQueryTelemetry;
+    /**
+     * Flush buffered query telemetry aggregates into
+     * `query_descriptor_stats`. Runs automatically every
+     * {@link QUERY_TELEMETRY_FLUSH_THRESHOLD} queries and on close; callers
+     * that need durable stats immediately (tests, diagnostics tooling) can
+     * invoke it directly.
+     */
+    flushQueryTelemetry(): Promise<void>;
+    private writeQueryTelemetryRow;
+    private isQueryDiagnosticsEnabled;
+    private collectCompiledQueryDiagnostics;
+    private getStorageCapabilities;
+    private debugQueryPlan;
+    private isQueryDebugEnabled;
+    private auditQueryParity;
+    private getNodeParityCandidates;
+    private compareQueryResults;
+    private shouldCreateAdaptiveIndexes;
+    private ensureAdaptiveIndexes;
+    private ensureAdaptiveIndexBudgetColumns;
+    private estimateAdaptiveIndexBudget;
+    private getAdaptiveIndexValueBytesExpression;
+    private makeAdaptiveIndexBudgetRoom;
+    private pruneAdaptiveIndexes;
+    private getAdaptiveIndexBudgetUsage;
+    private dropLeastUsefulAdaptiveIndex;
+    private dropAdaptiveIndex;
+    private debugAdaptiveIndex;
+    private buildProtectedIndexFilter;
+    private buildAdaptiveIndexName;
+    private buildAdaptiveIndexDDL;
+    private getAdaptiveIndexColumns;
+    private countCompiledNodeQuery;
+    private compileNodeQuery;
+    /**
+     * A custom-property sort can push down when it is the descriptor's ONLY
+     * order key and no cursor/spatial/search accelerator is in play. Gated on
+     * the adaptive-indexing flag: the typed partial indexes on
+     * `node_property_scalars` make the join+order cheap, and the flag keeps
+     * the behavioural change opt-in while it soaks (exploration 0264).
+     */
+    private resolvePropertySortPushdown;
+    private compileSqlQuery;
+    private getCompiledPostFilterReason;
+    private appendScalarPredicate;
+    /**
+     * ORDER BY for a pushed-down custom-property sort (0264). Mirrors the JS
+     * comparator in `applyNodeQueryDescriptor`: missing properties sort last
+     * ascending / first descending; typed value columns carry the order (for a
+     * homogeneous property exactly one is non-NULL). `n.id` breaks ties so the
+     * page boundary is a total order.
+     */
+    private buildPropertySortOrderBy;
+    private buildSqlOrderBy;
+    private hasOnlySystemOrdering;
+    private serializePayload;
+    private deserializePayload;
+    private serializeValue;
+    private deserializeValue;
+    private deserializeChange;
+}
+/**
+ * Create a SQLiteNodeStorageAdapter from an existing SQLiteAdapter.
+ * Use this when you want to share the SQLite connection with other services.
+ *
+ * @example
+ * ```typescript
+ * import { createMemorySQLiteAdapter } from '@xnetjs/sqlite/memory'
+ * import { createNodeStorageAdapter } from '@xnetjs/data'
+ *
+ * const db = await createMemorySQLiteAdapter()
+ * const storage = createNodeStorageAdapter(db)
+ * ```
+ */
+declare function createNodeStorageAdapter(db: SQLiteAdapter, options?: SQLiteNodeStorageAdapterOptions): SQLiteNodeStorageAdapter;
+
+export { ApplyNodeBatchInput, ApplyNodeBatchResult, CountNodesOptions, ImportNodesOptions, ListNodesOptions, MemoryNodeStorageAdapter, NodeBatchPreflightResult, NodeChange, NodeId, NodeQueryDescriptor, NodeQueryResult, NodeState, NodeStorageAdapter, PermissionError, RebuildNodeIndexesOptions, type SQLiteAdaptiveIndexingOptions, SQLiteNodeStorageAdapter, type SQLiteNodeStorageAdapterOptions, type SQLiteQueryVerificationOptions, SetNodeOptions, createNodeStorageAdapter };

package/dist/store/index.js

@@ -0,0 +1,135 @@
+import {
+  MemoryNodeStorageAdapter,
+  NodeStore,
+  PermissionError,
+  QUERY_AST_VERSION,
+  SQLiteNodeStorageAdapter,
+  TEMP_ID_PREFIX,
+  and,
+  avg,
+  between,
+  contains,
+  count,
+  countDistinct,
+  createNodeStorageAdapter,
+  createPropertyLookup,
+  createSchemaLookup,
+  dashboardQuerySet,
+  defineNodeQueryAST,
+  defineQuerySetAST,
+  defineSavedViewDescriptor,
+  eq,
+  evaluateQueryASTPlannerGate,
+  executeQueryASTLoadedAggregates,
+  filterQueryASTLoadedRows,
+  follow,
+  from,
+  getQueryASTRelationIndexRequirements,
+  groupBy,
+  gt,
+  gte,
+  having,
+  includesAny,
+  isNotNull,
+  isNull,
+  isTempId,
+  lt,
+  lte,
+  matchesQueryASTLoadedRow,
+  max,
+  min,
+  neq,
+  not,
+  or,
+  planQueryASTAggregates,
+  queryOperators,
+  querySetCount,
+  resolveTempIds,
+  startsWith,
+  sum,
+  validateQueryAST,
+  validateSavedViewDescriptor
+} from "../chunk-UDWKWTAX.js";
+import {
+  applyNodeQueryDescriptor,
+  createNodeQueryDescriptor,
+  decodeNodeQueryCursor,
+  encodeNodeQueryCursor,
+  filterNodeQueryResults,
+  getNodeQuerySearchTokens,
+  matchesNodeQueryDescriptor,
+  nodeQueryDescriptorNeedsBoundedReload,
+  nodeQueryDescriptorToOptions,
+  serializeNodeQueryDescriptor,
+  sortNodeQueryResults,
+  withoutNodeQueryMaterializedView,
+  withoutNodeQueryPagination
+} from "../chunk-S5RP5RKY.js";
+import "../chunk-BY5O6LNC.js";
+import "../chunk-EBNMV2VO.js";
+import "../chunk-RL64OJJ5.js";
+export {
+  MemoryNodeStorageAdapter,
+  NodeStore,
+  PermissionError,
+  QUERY_AST_VERSION,
+  SQLiteNodeStorageAdapter,
+  TEMP_ID_PREFIX,
+  and,
+  applyNodeQueryDescriptor,
+  avg,
+  between,
+  contains,
+  count,
+  countDistinct,
+  createNodeQueryDescriptor,
+  createNodeStorageAdapter,
+  createPropertyLookup,
+  createSchemaLookup,
+  dashboardQuerySet,
+  decodeNodeQueryCursor,
+  defineNodeQueryAST,
+  defineQuerySetAST,
+  defineSavedViewDescriptor,
+  encodeNodeQueryCursor,
+  eq,
+  evaluateQueryASTPlannerGate,
+  executeQueryASTLoadedAggregates,
+  filterNodeQueryResults,
+  filterQueryASTLoadedRows,
+  follow,
+  from,
+  getNodeQuerySearchTokens,
+  getQueryASTRelationIndexRequirements,
+  groupBy,
+  gt,
+  gte,
+  having,
+  includesAny,
+  isNotNull,
+  isNull,
+  isTempId,
+  lt,
+  lte,
+  matchesNodeQueryDescriptor,
+  matchesQueryASTLoadedRow,
+  max,
+  min,
+  neq,
+  nodeQueryDescriptorNeedsBoundedReload,
+  nodeQueryDescriptorToOptions,
+  not,
+  or,
+  planQueryASTAggregates,
+  queryOperators,
+  querySetCount,
+  resolveTempIds,
+  serializeNodeQueryDescriptor,
+  sortNodeQueryResults,
+  startsWith,
+  sum,
+  validateQueryAST,
+  validateSavedViewDescriptor,
+  withoutNodeQueryMaterializedView,
+  withoutNodeQueryPagination
+};