@xnetjs/data 0.0.2 → 0.1.0

package/dist/types-S-BJAKyK.d.ts

@@ -0,0 +1,1576 @@
+import { DID as DID$1, AuthAction, AuthDecision, AuthTrace, PolicyEvaluator, ContentId, SerializedAuthorization } from '@xnetjs/core';
+import { PublicKeyResolver } from '@xnetjs/crypto';
+import { SQLiteOperationStats } from '@xnetjs/sqlite';
+import { Change, ChangeSigner } from '@xnetjs/sync';
+
+/**
+ * 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}`;
+/**
+ * Default version for schemas without explicit version.
+ */
+declare const DEFAULT_SCHEMA_VERSION = "1.0.0";
+/**
+ * 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;
+}
+/**
+ * Parse a SchemaIRI into its components.
+ *
+ * @example
+ * parseSchemaIRI('xnet://xnet.fyi/Task@2.0.0')
+ * // { baseIRI: 'xnet://xnet.fyi/Task', name: 'Task', version: '2.0.0', ... }
+ *
+ * parseSchemaIRI('xnet://xnet.fyi/Task')
+ * // { baseIRI: 'xnet://xnet.fyi/Task', name: 'Task', version: '1.0.0', hasExplicitVersion: false }
+ */
+declare function parseSchemaIRI(iri: SchemaIRI): ParsedSchemaIRI;
+/**
+ * Build a versioned SchemaIRI from components.
+ *
+ * @example
+ * buildSchemaIRI('xnet://xnet.fyi/', 'Task', '2.0.0')
+ * // 'xnet://xnet.fyi/Task@2.0.0'
+ */
+declare function buildSchemaIRI(namespace: string, name: string, version?: string): SchemaIRI;
+/**
+ * Normalize a SchemaIRI to always include version.
+ * Unversioned IRIs get @1.0.0 appended.
+ *
+ * @example
+ * normalizeSchemaIRI('xnet://xnet.fyi/Task')
+ * // 'xnet://xnet.fyi/Task@1.0.0'
+ *
+ * normalizeSchemaIRI('xnet://xnet.fyi/Task@2.0.0')
+ * // 'xnet://xnet.fyi/Task@2.0.0' (unchanged)
+ */
+declare function normalizeSchemaIRI(iri: SchemaIRI): SchemaIRI;
+/**
+ * Get the base (unversioned) IRI from a SchemaIRI.
+ *
+ * @example
+ * getBaseSchemaIRI('xnet://xnet.fyi/Task@2.0.0')
+ * // 'xnet://xnet.fyi/Task'
+ */
+declare function getBaseSchemaIRI(iri: SchemaIRI): SchemaIRI;
+/**
+ * Check if two SchemaIRIs refer to the same schema (ignoring version).
+ */
+declare function isSameSchema(iri1: SchemaIRI, iri2: SchemaIRI): boolean;
+/**
+ * Get the version from a SchemaIRI.
+ */
+declare function getSchemaVersion(iri: SchemaIRI): string;
+/**
+ * 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 */
+    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;
+
+/**
+ * Shared NodeStore query descriptor semantics.
+ */
+
+type SortDirection = 'asc' | 'desc';
+type SystemOrderField = 'createdAt' | 'updatedAt';
+type NodeQuerySpatialPoint = {
+    x: number;
+    y: number;
+};
+type NodeQuerySpatialRect = NodeQuerySpatialPoint & {
+    width: number;
+    height: number;
+};
+type NodeQuerySpatialPointFields = {
+    x: string;
+    y: string;
+};
+type NodeQuerySpatialRectFields = NodeQuerySpatialPointFields & {
+    width?: string;
+    height?: string;
+};
+type NodeQuerySpatialWindow = {
+    kind: 'window';
+    rect: NodeQuerySpatialRect;
+    fields: NodeQuerySpatialRectFields;
+    overscan?: number;
+};
+type NodeQuerySpatialRadius = {
+    kind: 'radius';
+    center: NodeQuerySpatialPoint;
+    radius: number;
+    fields: NodeQuerySpatialPointFields;
+};
+type NodeQuerySpatialFilter = NodeQuerySpatialWindow | NodeQuerySpatialRadius;
+type NodeQuerySearchField = 'title' | 'content';
+type NodeQuerySearchFilter = {
+    text: string;
+    fields?: NodeQuerySearchField[];
+};
+type NodeQueryMaterializedViewOptions = {
+    viewId: string;
+    maxAgeMs?: number;
+    forceRefresh?: boolean;
+};
+type NodeQueryPageCountMode = 'exact' | 'estimate' | 'none';
+type NodeQueryPageOptions = {
+    first: number;
+    after?: string;
+    count?: NodeQueryPageCountMode;
+};
+type NodeQueryCursorOrderEntry = {
+    field: string;
+    direction: SortDirection;
+    value: unknown;
+};
+type NodeQueryCursor = {
+    version: 1;
+    schemaId: SchemaIRI;
+    order: NodeQueryCursorOrderEntry[];
+    nodeId: string;
+};
+interface NodeQueryOptions<P extends Record<string, PropertyBuilder> = Record<string, PropertyBuilder>> {
+    nodeId?: string;
+    where?: Partial<InferCreateProps<P>>;
+    includeDeleted?: boolean;
+    orderBy?: {
+        [K in keyof InferCreateProps<P> | SystemOrderField]?: SortDirection;
+    };
+    limit?: number;
+    offset?: number;
+    page?: NodeQueryPageOptions;
+    spatial?: NodeQuerySpatialFilter;
+    search?: string | NodeQuerySearchFilter;
+    materializedView?: string | NodeQueryMaterializedViewOptions;
+}
+interface NodeQueryDescriptor {
+    schemaId: SchemaIRI;
+    nodeId?: string;
+    where?: Record<string, unknown>;
+    includeDeleted: boolean;
+    orderBy?: Record<string, SortDirection>;
+    limit?: number;
+    offset?: number;
+    after?: string;
+    count?: NodeQueryPageCountMode;
+    spatial?: NodeQuerySpatialFilter;
+    search?: NodeQuerySearchFilter;
+    materializedView?: NodeQueryMaterializedViewOptions;
+    /**
+     * Authorization fingerprint stamped by `NodeStore` when a materialized view
+     * is read under an active read-authorization evaluator (exploration 0226).
+     * It is NOT part of the descriptor hash (it is stripped by
+     * `withoutNodeQueryMaterializedView`) — a change is reported as a distinct
+     * `'authz-changed'` refresh reason rather than `'descriptor-changed'`. Set
+     * internally by the store, never by callers.
+     */
+    authFingerprint?: string;
+}
+interface NodeQueryPlanMetadata {
+    strategy: 'storage-query' | 'list-fallback' | 'auth-pushdown-candidates';
+    candidateNodeCount: number;
+    hydratedNodeCount: number;
+    returnedNodeCount: number;
+    durationMs: number;
+    sql?: string;
+    params?: unknown[];
+    postFilterReason?: string;
+    descriptorHash?: string;
+    adaptiveIndexNames?: string[];
+    candidateQueryDurationMs?: number;
+    usedIndexNames?: string[];
+    fullTableScan?: boolean;
+    queryPlanDetails?: string[];
+    availableIndexCount?: number;
+    adaptiveIndexCount?: number;
+    diagnosticsError?: string;
+    storageCapabilities?: NodeQueryStorageCapabilitiesMetadata;
+    candidateAccelerators?: string[];
+    spatialIndexKey?: string;
+    fullTextSearchQuery?: string;
+    materializedViewId?: string;
+    materializedCacheHit?: boolean;
+    materializedRefreshReason?: 'missing' | 'descriptor-changed' | 'authz-changed' | 'invalidated' | 'expired' | 'force-refresh';
+    materializedGeneratedAt?: number;
+    materializedInvalidatedAt?: number;
+    materializedRowCount?: number;
+    parityCheck?: NodeQueryParityCheckMetadata;
+}
+interface NodeQueryStorageCapabilitiesMetadata {
+    fullTextSearch: boolean;
+    rtree: boolean;
+}
+interface NodeQueryParityCheckMetadata {
+    strategy: 'exact' | 'skipped';
+    valid?: boolean;
+    reason?: string;
+    comparedNodeCount?: number;
+    expectedNodeCount?: number;
+    missingNodeIds?: string[];
+    extraNodeIds?: string[];
+    orderMismatch?: boolean;
+}
+interface NodeQueryResult {
+    nodes: NodeState[];
+    plan: NodeQueryPlanMetadata;
+    totalCount?: number;
+}
+declare function encodeNodeQueryCursor(descriptor: NodeQueryDescriptor, node: NodeState): string;
+declare function decodeNodeQueryCursor(cursor: string): NodeQueryCursor | null;
+declare function getNodeQuerySearchTokens(search: NodeQuerySearchFilter): string[];
+declare function createNodeQueryDescriptor<P extends Record<string, PropertyBuilder>>(schemaId: SchemaIRI, options?: NodeQueryOptions<P>): NodeQueryDescriptor;
+declare function nodeQueryDescriptorToOptions<P extends Record<string, PropertyBuilder> = Record<string, PropertyBuilder>>(descriptor: NodeQueryDescriptor): NodeQueryOptions<P>;
+declare function serializeNodeQueryDescriptor(descriptor: NodeQueryDescriptor): string;
+declare function matchesNodeQueryDescriptor(descriptor: NodeQueryDescriptor, node: NodeState | null | undefined): boolean;
+declare function filterNodeQueryResults(nodes: NodeState[], descriptor: NodeQueryDescriptor): NodeState[];
+declare function sortNodeQueryResults(nodes: NodeState[], descriptor: NodeQueryDescriptor): NodeState[];
+declare function applyNodeQueryDescriptor(nodes: NodeState[], descriptor: NodeQueryDescriptor): NodeState[];
+declare function nodeQueryDescriptorNeedsBoundedReload(descriptor: NodeQueryDescriptor): boolean;
+declare function withoutNodeQueryPagination(descriptor: NodeQueryDescriptor): NodeQueryDescriptor;
+declare function withoutNodeQueryMaterializedView(descriptor: NodeQueryDescriptor): NodeQueryDescriptor;
+
+/**
+ * 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...' }, ... }
+ * ```
+ */
+
+/** 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;
+/**
+ * Build a PropertyLookup from a schema getter function.
+ * Returns the set of all property names defined in the schema.
+ * Caches results for performance.
+ */
+declare function createPropertyLookup(getSchema: (iri: SchemaIRI) => DefinedSchema<Record<string, PropertyBuilder>> | undefined): PropertyLookup;
+/**
+ * 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>;
+}
+/**
+ * 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
+ */
+declare function resolveTempIds(operations: TransactionOperation[], schemaLookup?: SchemaLookup): TempIdResolution;
+
+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.
+ */
+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 {
+    id: 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;
+type RevocationConsistency = 'eventual' | 'strict';
+interface RevocationConfig {
+    mode: RevocationConsistency;
+    maxStaleness: number;
+}
+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>;
+    revoke(input: {
+        grantId: string;
+    }): Promise<void>;
+    listGrants(input: {
+        nodeId: string;
+        status?: GrantStatus;
+    }): Promise<Grant[]>;
+    listIssuedGrants(): Promise<Grant[]>;
+    listReceivedGrants(): Promise<Grant[]>;
+    getOfflinePolicy(): OfflineAuthPolicy;
+    setOfflinePolicy(policy: Partial<OfflineAuthPolicy>): void;
+}
+interface GrantInput {
+    to: DID$1;
+    actions: AuthAction[];
+    resource: string;
+    expiresIn?: string | number;
+    parentGrantId?: string;
+}
+interface Grant {
+    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>;
+    revoke(input: {
+        grantId: string;
+    }): Promise<void>;
+    listGrants(input: {
+        nodeId: string;
+        status?: GrantStatus;
+    }): Promise<Grant[]>;
+    listIssuedGrants(): Promise<Grant[]>;
+    listReceivedGrants(): Promise<Grant[]>;
+    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.
+ */
+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;
+}
+/**
+ * Result of a migration transformation.
+ */
+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[];
+}
+/**
+ * Error thrown when migration fails.
+ */
+declare class MigrationError extends Error {
+    readonly source?: SchemaIRI | undefined;
+    readonly target?: SchemaIRI | undefined;
+    constructor(message: string, source?: SchemaIRI | undefined, target?: SchemaIRI | undefined);
+}
+/**
+ * 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')
+ * ```
+ */
+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;
+}
+/**
+ * Default global lens registry instance.
+ */
+declare const lensRegistry: LensRegistry;
+
+/**
+ * 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.
+ *
+ * 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
+ */
+
+/** 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 logical time when this value was set */
+    lamport: number;
+    /** Author DID for LWW tiebreak */
+    author: DID$1;
+    /** 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.
+ */
+/**
+ * Filters a candidate node set down to the rows the current viewer may read.
+ * Only ever removes rows. Used by adapters to authorize a materialized view's
+ * id list once, at refresh time (exploration 0226).
+ */
+type NodeReadAuthorizer = (nodes: NodeState[]) => Promise<NodeState[]>;
+/**
+ * A reload-stable version of the authorization-relevant control-plane state.
+ * `count` and `maxUpdatedAt` over grants and `/sys/authz/` resources change
+ * whenever any grant is added, modified, or removed.
+ */
+interface AuthorizationStateVersion {
+    count: number;
+    maxUpdatedAt: number;
+}
+interface NodeStorageAdapter {
+    /** Open/initialize the storage connection */
+    open?(): Promise<void>;
+    /** Close the storage connection */
+    close?(): Promise<void>;
+    /**
+     * Execute a batch of storage operations as one adapter-owned transaction.
+     *
+     * Storage implementations pass a transaction-scoped adapter to `fn`; writes
+     * through that adapter must not start their own nested transaction.
+     */
+    withTransaction?<T>(fn: (storage: NodeStorageAdapter) => Promise<T>): Promise<T>;
+    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>;
+    /** Return the latest change for each requested node id. Missing nodes are omitted. */
+    getLastChangesByNodeId?(nodeIds: readonly NodeId[]): Promise<Map<NodeId, NodeChange>>;
+    /** Append multiple changes in one storage-owned write when supported. */
+    appendChanges?(changes: readonly NodeChange[]): Promise<void>;
+    getNode(id: NodeId): Promise<NodeState | null>;
+    /** Return existing materialized nodes in input order. Missing nodes are omitted. */
+    getNodes?(ids: readonly NodeId[]): Promise<NodeState[]>;
+    /** Return the subset of ids that currently exist in materialized storage. */
+    getExistingNodeIds?(ids: readonly NodeId[]): Promise<NodeId[]>;
+    /** Return all read state needed to plan a node batch in one adapter-owned preflight. */
+    getBatchPreflight?(ids: readonly NodeId[]): Promise<NodeBatchPreflightResult>;
+    setNode(node: NodeState, options?: SetNodeOptions): Promise<void>;
+    /** Import multiple materialized nodes in one storage-owned write when supported. */
+    importNodes?(nodes: readonly NodeState[], options?: ImportNodesOptions): Promise<void>;
+    /** Apply materialized nodes, signed changes, sync state, and batch indexes in one write. */
+    applyNodeBatch?(input: ApplyNodeBatchInput): Promise<ApplyNodeBatchResult>;
+    /** Rebuild secondary node indexes after an import that deferred index maintenance. */
+    rebuildIndexesForSchemas?(schemaIds: readonly SchemaIRI[], options?: RebuildNodeIndexesOptions): Promise<void>;
+    /**
+     * Refresh 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 may pick full scans over indexes (exploration 0184).
+     */
+    analyze?(): Promise<void>;
+    /**
+     * Incremental planner maintenance (`PRAGMA optimize`) — ANALYZEs only the
+     * tables that drifted. Cheap; safe to call at idle and before close.
+     */
+    optimize?(): Promise<void>;
+    deleteNode(id: NodeId): Promise<void>;
+    listNodes(options?: ListNodesOptions): Promise<NodeState[]>;
+    countNodes(options?: CountNodesOptions): Promise<number>;
+    queryNodes?(descriptor: NodeQueryDescriptor): Promise<NodeQueryResult>;
+    /**
+     * Inject the read-authorization filter the adapter applies before persisting
+     * a materialized view's id list (exploration 0226). `NodeStore` wires this to
+     * its `filterReadableNodes` so a materialization is authorized exactly once,
+     * at refresh time, and cache hits can be served without per-row re-checks.
+     * Pass `undefined` to clear it. Optional: adapters that don't implement it
+     * simply never materialize under authorization (the store falls back to the
+     * authorize-then-paginate path).
+     */
+    setNodeReadAuthorizer?(authorizer: NodeReadAuthorizer | undefined): void;
+    /**
+     * A cheap, reload-stable version stamp of the authorization-relevant state
+     * (grants + `/sys/authz/` resources). Folded into the materialized view's
+     * auth fingerprint so any grant change invalidates cached views across
+     * reloads. Optional; when absent the store will not materialize under authz.
+     */
+    getAuthorizationStateVersion?(): Promise<AuthorizationStateVersion>;
+    /** Optional runtime operation counters for import diagnostics. */
+    getOperationStats?(): Promise<SQLiteOperationStats | null> | SQLiteOperationStats | null;
+    /** Reset optional runtime operation counters before a focused measurement. */
+    resetOperationStats?(): Promise<void> | void;
+    getLastLamportTime(): Promise<number>;
+    setLastLamportTime(time: number): Promise<void>;
+    /**
+     * Per-room sync high-water mark (Lamport time) — the cursor a hub-sync
+     * provider has confirmed the hub durably stores. Persisting this stops the
+     * client replaying its entire change log on every reload (exploration 0206).
+     * Optional: adapters that don't implement it degrade to replay-from-0.
+     */
+    getSyncCursor?(room: string): Promise<number>;
+    setSyncCursor?(room: string, lamport: number): Promise<void>;
+    /**
+     * Generic app-state key/value, stored in an FK-free table. Used for blobs
+     * that are *not* node documents (e.g. the sync registry's tracked-node set):
+     * writing those through {@link setDocumentContent} hits `yjs_state`'s
+     * `node_id → nodes(id)` foreign key and fails with SQLITE_CONSTRAINT_FOREIGNKEY
+     * (exploration 0227). Optional: callers fall back to document content when an
+     * adapter doesn't implement it.
+     */
+    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>;
+}
+interface SetNodeOptions {
+    /**
+     * Whether storage may maintain plaintext property read indexes for this node.
+     * Encrypted NodeStore instances pass false and must rely on post-decryption
+     * query evaluation instead.
+     */
+    indexProperties?: boolean;
+}
+interface ImportNodesOptions extends SetNodeOptions {
+    /**
+     * Skip secondary scalar/spatial/FTS/materialized maintenance for this write.
+     * Callers must rebuild affected schema indexes before relying on indexed
+     * queries again.
+     */
+    deferIndexes?: boolean;
+    /**
+     * Treat the provided NodeState objects as the post-LWW materialized truth
+     * when updating secondary indexes. This avoids a per-node readback during
+     * import paths that already materialize against current storage state.
+     */
+    trustMaterializedState?: boolean;
+}
+type RebuildNodeIndexesOptions = SetNodeOptions;
+type NodeBatchIndexMode = 'eager' | 'touched' | 'defer-schema';
+interface NodeBatchPreflightResult {
+    /** Existing materialized nodes keyed by node ID. Missing node IDs are omitted. */
+    nodesById: Map<NodeId, NodeState>;
+    /** Latest known change for each requested node ID. Missing node IDs are omitted. */
+    lastChangesByNodeId: Map<NodeId, NodeChange>;
+}
+interface ApplyNodeBatchInput extends SetNodeOptions {
+    /** Batch ID shared by all supplied changes. */
+    batchId: string;
+    /** Final materialized state for changed nodes. */
+    nodes: readonly NodeState[];
+    /** Signed changes to append after materialized nodes exist. */
+    changes: readonly NodeChange[];
+    /** Last Lamport time after applying the batch. */
+    lastLamportTime: number;
+    /** Schemas affected by the batch, used for index/view invalidation. */
+    affectedSchemaIds: readonly SchemaIRI[];
+    /**
+     * Secondary index strategy for this batch.
+     *
+     * - `eager`: maintain indexes through the normal per-node write path.
+     * - `touched`: skip per-node indexes, then rebuild only touched node indexes.
+     * - `defer-schema`: skip indexes so the caller can rebuild affected schemas later.
+     */
+    indexMode: NodeBatchIndexMode;
+}
+interface ApplyNodeBatchResult {
+    /** Number of materialized node rows written or updated. */
+    nodeRowsWritten: number;
+    /** Number of property rows considered for write. */
+    propertyRowsWritten: number;
+    /** Number of change rows considered for append. */
+    changeRowsWritten: number;
+    /** Number of scalar index rows written. */
+    scalarRowsWritten: number;
+    /** Number of full-text index rows written. */
+    ftsRowsWritten: number;
+}
+type NodeBatchNotificationMode = 'per-node' | 'batch' | 'silent';
+type NodeBatchSyncMode = 'normal' | 'defer';
+interface NodeBatchWritePolicy {
+    /** Secondary index strategy for this batch. */
+    indexMode: NodeBatchIndexMode;
+    /** Live notification strategy after the batch is durable. */
+    notificationMode: NodeBatchNotificationMode;
+    /** Advisory sync strategy for runtimes that can coalesce outbound replication. */
+    syncMode: NodeBatchSyncMode;
+}
+interface NodeBatchWriteTimings {
+    /** Existing-node and parent-change lookup time. */
+    preflightMs: number;
+    /** In-memory materialization and change signing time. */
+    materializeMs: number;
+    /** Storage apply time, including indexes owned by the adapter. */
+    applyMs: number;
+    /** Listener notification time after the storage commit. */
+    notifyMs: number;
+    /** Full wall time for the batch write call. */
+    totalMs: number;
+}
+interface DeterministicNodeBatchWriteInput {
+    kind: 'deterministic-import';
+    drafts: readonly DeterministicNodeImportDraft[];
+    policy?: Partial<NodeBatchWritePolicy>;
+}
+interface OperationNodeBatchWriteInput {
+    kind: 'operations';
+    operations: readonly TransactionOperation[];
+    policy?: Partial<NodeBatchWritePolicy>;
+}
+type NodeBatchWriteInput = DeterministicNodeBatchWriteInput | OperationNodeBatchWriteInput;
+interface NodeBatchWriteResult {
+    /** The batch ID shared by all changes. */
+    batchId: string;
+    /** Number of drafts that created a node at the time they were applied. */
+    created: number;
+    /** Number of drafts that updated a node at the time they were applied. */
+    updated: number;
+    /** Final node IDs touched by the batch. */
+    nodeIds: NodeId[];
+    /** Schemas whose materialized nodes changed. */
+    schemaIds: SchemaIRI[];
+    /** Number of signed changes appended by the batch. */
+    changeCount: number;
+    /** Storage-level write counters when the adapter reports them. */
+    storage?: ApplyNodeBatchResult;
+    /** Phase timings for import diagnostics and progress UIs. */
+    timings: NodeBatchWriteTimings;
+}
+interface NodeBatchChangeEvent {
+    /** The batch ID shared by all changes. */
+    batchId: string;
+    /** Final node IDs touched by the batch. */
+    nodeIds: NodeId[];
+    /** Schemas whose materialized nodes changed. */
+    schemaIds: SchemaIRI[];
+    /** Number of drafts that created a node at the time they were applied. */
+    created: number;
+    /** Number of drafts that updated a node at the time they were applied. */
+    updated: number;
+    /** Number of signed changes appended by the batch. */
+    changeCount: number;
+    /** Whether this was a remote change batch from sync. */
+    isRemote: boolean;
+    /** Storage-level write counters when the adapter reports them. */
+    storage?: ApplyNodeBatchResult;
+    /** Phase timings for import diagnostics and progress UIs. */
+    timings: NodeBatchWriteTimings;
+}
+interface ListNodesOptions {
+    /** Filter by schema IRI */
+    schemaId?: SchemaIRI;
+    /** Include soft-deleted nodes */
+    includeDeleted?: boolean;
+    /** Sort by system metadata fields */
+    orderBy?: Partial<Record<SystemOrderField, SortDirection>>;
+    /** 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';
+}
+/**
+ * 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 async change signer (e.g. `createWebCryptoChangeSigner` from
+     * @xnetjs/sync, or a worker-backed signer). Signatures must be
+     * byte-identical to the synchronous Ed25519 path. When omitted, changes
+     * are signed synchronously with `signingKey` on the calling thread.
+     */
+    changeSigner?: ChangeSigner;
+    /**
+     * 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;
+    /**
+     * 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.
+     */
+    lensRegistry?: LensRegistry;
+    /** Optional authorization evaluator used for mutation gating. */
+    authEvaluator?: PolicyEvaluator;
+    /**
+     * Optional transparent node content cipher.
+     *
+     * When provided, NodeStore writes encrypted node payload snapshots via
+     * `setDocumentContent()` and decrypts them on read paths.
+     */
+    nodeContentCipher?: NodeContentCipher;
+    /**
+     * Optional cache for per-node content keys used by `nodeContentCipher`.
+     *
+     * This avoids expensive key unwraps on repeated reads.
+     */
+    contentKeyCache?: ContentKeyCache;
+    /**
+     * 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.
+     */
+    authRelevantPropertyLookup?: (schemaId: SchemaIRI) => Set<string> | undefined;
+    /**
+     * Optional callback triggered when an update touches auth-relevant properties.
+     * Integrators can use this to recompute recipients and rotate keys.
+     */
+    onRecipientsMayNeedRecompute?: (context: {
+        nodeId: NodeId;
+        schemaId: SchemaIRI;
+        changedProperties: string[];
+    }) => Promise<void> | void;
+    /**
+     * Optional callback for rejected unauthorized remote changes.
+     * Remote unauthorized changes are rejected silently and never applied.
+     */
+    onUnauthorizedRemoteChange?: (context: {
+        change: NodeChange;
+        action: AuthAction;
+        decision: AuthDecision;
+    }) => void;
+    /** Optional high-level authorization API attached as `store.auth`. */
+    auth?: StoreAuthAPI;
+    /**
+     * 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.
+     */
+    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 deterministic node import draft.
+ *
+ * Intended for importers that already know stable node IDs and want one
+ * signed change per draft while avoiding per-node storage transactions.
+ */
+interface DeterministicNodeImportDraft {
+    /** Stable node ID to create or update */
+    id: NodeId;
+    /** Schema IRI used when the node does not already exist */
+    schemaId: SchemaIRI;
+    /** Properties to merge with LWW semantics */
+    properties: Record<PropertyKey, unknown>;
+}
+interface ImportDeterministicNodesOptions {
+    /**
+     * Secondary index strategy for this import. Defaults to `touched`, which is
+     * optimized for bulk imports when storage supports `applyNodeBatch()`.
+     */
+    indexMode?: NodeBatchIndexMode;
+    /**
+     * Skip secondary index maintenance for this chunk. Call
+     * `NodeStore.rebuildIndexesForSchemas()` for the affected schemas before
+     * relying on indexed queries.
+     *
+     * @deprecated Prefer `indexMode: 'defer-schema'`.
+     */
+    deferIndexes?: boolean;
+}
+interface ImportDeterministicNodesResult {
+    /** The batch ID shared by all imported changes */
+    batchId: string;
+    /** Number of drafts that created a node at the time they were applied */
+    created: number;
+    /** Number of drafts that updated a node at the time they were applied */
+    updated: number;
+    /** Final materialized state for each changed node */
+    nodes: NodeState[];
+    /** All signed changes created for the import */
+    changes: NodeChange[];
+    /** Schemas whose materialized nodes changed */
+    affectedSchemaIds: SchemaIRI[];
+    /** Storage-level write counters when the adapter reports them. */
+    storage?: ApplyNodeBatchResult;
+    /** Phase timings for import diagnostics and progress UIs. */
+    timings: NodeBatchWriteTimings;
+}
+/**
+ * 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 node state before the change was applied */
+    previousNode: NodeState | null;
+    /** 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;
+type NodeBatchChangeListener = (event: NodeBatchChangeEvent) => 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 {
+    /**
+     * Migration info if the node was migrated from a different schema version.
+     * Undefined if no migration was needed.
+     */
+    _migrationInfo?: MigrationInfo;
+}
+
+/**
+ * Schema types for xNet's code-first schema system.
+ */
+
+/**
+ * Property type identifiers.
+ */
+type PropertyType = 'text' | 'number' | 'checkbox' | 'json' | '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>;
+    /**
+     * When true, this property is schema-defined and structurally locked: the
+     * universal/extension grid must not let the user rename, retype, or delete
+     * the column (values stay editable). Set by `buildEffectiveSchema` on the
+     * core properties of a schema that is being extended; user-added extension
+     * fields are never readonly. Absent/false for ordinary schema properties.
+     */
+    readonly?: boolean;
+}
+/**
+ * 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>;
+
+export { type PropertyKey as $, createNodeId as A, type PropertyType as B, type CreateNodeOptions$1 as C, type DefinedSchema as D, type PropertyDefinition as E, type ValidationError as F, type GetWithMigrationOptions as G, type CreateNodeOptions as H, type InferCreateProps as I, type InferPropertyType as J, type InferProperties as K, type ListNodesOptions as L, type MigratedNodeState as M, type NodeQueryPageCountMode as N, type OfflineAuthPolicy as O, type PropertyBuilder as P, type InferNode as Q, type SchemaLens as R, type SchemaIRI as S, type TransactionOperation as T, type UpdateNodeOptions as U, type ValidationResult as V, type LensOperation as W, type MigrationResult as X, MigrationError as Y, LensRegistry as Z, lensRegistry as _, type Schema as a, type StoreAuthKeyManager as a$, type NodePayload as a0, type PropertyTimestamp as a1, type SetNodeOptions as a2, type ImportNodesOptions as a3, type RebuildNodeIndexesOptions as a4, type ApplyNodeBatchInput as a5, type ApplyNodeBatchResult as a6, type NodeBatchIndexMode as a7, type NodeBatchNotificationMode as a8, type NodeBatchSyncMode as a9, createNodeQueryDescriptor as aA, encodeNodeQueryCursor as aB, decodeNodeQueryCursor as aC, nodeQueryDescriptorToOptions as aD, serializeNodeQueryDescriptor as aE, matchesNodeQueryDescriptor as aF, filterNodeQueryResults as aG, sortNodeQueryResults as aH, applyNodeQueryDescriptor as aI, getNodeQuerySearchTokens as aJ, nodeQueryDescriptorNeedsBoundedReload as aK, withoutNodeQueryPagination as aL, withoutNodeQueryMaterializedView as aM, isTempId as aN, TEMP_ID_PREFIX as aO, resolveTempIds as aP, createSchemaLookup as aQ, type SchemaLookup as aR, type TempIdResolution as aS, StoreAuth as aT, GrantRateLimiter as aU, GRANT_SCHEMA_IRI as aV, isGrantActive as aW, DEFAULT_OFFLINE_POLICY as aX, mergeOfflinePolicy as aY, type StoreAuthOptions as aZ, type StoreAuthStore as a_, type NodeBatchPreflightResult as aa, type DeterministicNodeBatchWriteInput as ab, type NodeBatchWritePolicy as ac, type NodeBatchWriteTimings as ad, type CountNodesOptions as ae, type NodeQuerySpatialPoint as af, type NodeQuerySpatialRect as ag, type NodeQuerySpatialPointFields as ah, type NodeQuerySpatialRectFields as ai, type NodeQuerySpatialWindow as aj, type NodeQuerySpatialRadius as ak, type NodeQuerySpatialFilter as al, type NodeQuerySearchField as am, type NodeQuerySearchFilter as an, type NodeQueryMaterializedViewOptions as ao, type NodeQueryPageOptions as ap, type NodeQueryCursorOrderEntry as aq, type NodeQueryCursor as ar, type NodeQueryOptions as as, type NodeQueryPlanMetadata as at, type NodeQueryParityCheckMetadata as au, type ConflictResult as av, type NodeBatchChangeEvent as aw, type NodeContentCipher as ax, type ContentKeyCache as ay, type MigrationInfo as az, type ParsedSchemaIRI as b, type GrantInput as b0, type Grant as b1, StoreAuthError as b2, type StoreAuthErrorCode as b3, type GrantNode as b4, type GrantIndexStore as b5, type GrantIndexOptions as b6, type RevocationConsistency as b7, type RevocationConfig as b8, type GrantRateLimiterOptions as b9, type DocumentType as ba, DEFAULT_SCHEMA_VERSION as bb, parseSchemaIRI as bc, buildSchemaIRI as bd, normalizeSchemaIRI as be, getBaseSchemaIRI as bf, isSameSchema as bg, getSchemaVersion as bh, type NodeReadAuthorizer as bi, type AuthorizationStateVersion as bj, type OperationNodeBatchWriteInput as bk, type PropertyLookup as bl, createPropertyLookup as bm, type SortDirection as c, type SystemOrderField as d, type StoreAuthAPI as e, type NodeStoreOptions as f, type NodeStorageAdapter as g, type NodeState as h, type NodeId as i, type NodeQueryDescriptor as j, type NodeQueryResult as k, type TransactionResult as l, type DeterministicNodeImportDraft as m, type ImportDeterministicNodesOptions as n, type ImportDeterministicNodesResult as o, type NodeBatchWriteInput as p, type NodeBatchWriteResult as q, type NodeChange as r, type MergeConflict as s, type NodeChangeListener as t, type NodeBatchChangeListener as u, type NodeChangeEvent as v, GrantIndex as w, type Node as x, type DID as y, isNode as z };