@delali/narsil 0.1.7 → 0.1.8

package/dist/config-cQLlYR3U.d.ts

@@ -0,0 +1,470 @@
+import { b as PersistenceAdapter, I as InvalidationAdapter, E as EmbeddingAdapter } from './adapters-Bo2JQg8b.js';
+import { A as AnyDocument, b as ScoringMode, S as SchemaDefinition, I as IndexConfig } from './schema-BVaw7nqz.js';
+
+declare const ErrorCodes: {
+    readonly SCHEMA_INVALID_TYPE: "SCHEMA_INVALID_TYPE";
+    readonly SCHEMA_MISSING_FIELD: "SCHEMA_MISSING_FIELD";
+    readonly SCHEMA_DEPTH_EXCEEDED: "SCHEMA_DEPTH_EXCEEDED";
+    readonly SCHEMA_INVALID_VECTOR_DIMENSION: "SCHEMA_INVALID_VECTOR_DIMENSION";
+    readonly SCHEMA_INVALID_GEOPOINT: "SCHEMA_INVALID_GEOPOINT";
+    readonly DOC_NOT_FOUND: "DOC_NOT_FOUND";
+    readonly DOC_ALREADY_EXISTS: "DOC_ALREADY_EXISTS";
+    readonly DOC_VALIDATION_FAILED: "DOC_VALIDATION_FAILED";
+    readonly INDEX_NOT_FOUND: "INDEX_NOT_FOUND";
+    readonly INDEX_ALREADY_EXISTS: "INDEX_ALREADY_EXISTS";
+    readonly PARTITION_CORRUPTED: "PARTITION_CORRUPTED";
+    readonly PARTITION_REBALANCING_BACKPRESSURE: "PARTITION_REBALANCING_BACKPRESSURE";
+    readonly WORKER_CRASHED: "WORKER_CRASHED";
+    readonly WORKER_BUSY: "WORKER_BUSY";
+    readonly WORKER_TIMEOUT: "WORKER_TIMEOUT";
+    readonly PERSISTENCE_SAVE_FAILED: "PERSISTENCE_SAVE_FAILED";
+    readonly PERSISTENCE_LOAD_FAILED: "PERSISTENCE_LOAD_FAILED";
+    readonly PERSISTENCE_DELETE_FAILED: "PERSISTENCE_DELETE_FAILED";
+    readonly PERSISTENCE_CRC_MISMATCH: "PERSISTENCE_CRC_MISMATCH";
+    readonly PERSISTENCE_WAL_CORRUPT: "PERSISTENCE_WAL_CORRUPT";
+    readonly PERSISTENCE_FSYNC_FAILED: "PERSISTENCE_FSYNC_FAILED";
+    readonly SEARCH_INVALID_FIELD: "SEARCH_INVALID_FIELD";
+    readonly SEARCH_INVALID_VECTOR_SIZE: "SEARCH_INVALID_VECTOR_SIZE";
+    readonly VECTOR_DIMENSION_MISMATCH: "VECTOR_DIMENSION_MISMATCH";
+    readonly SEARCH_INVALID_FILTER: "SEARCH_INVALID_FILTER";
+    readonly SEARCH_INVALID_MODE: "SEARCH_INVALID_MODE";
+    readonly SEARCH_INVALID_CURSOR: "SEARCH_INVALID_CURSOR";
+    readonly LANGUAGE_NOT_SUPPORTED: "LANGUAGE_NOT_SUPPORTED";
+    readonly ENVELOPE_VERSION_MISMATCH: "ENVELOPE_VERSION_MISMATCH";
+    readonly ENVELOPE_INVALID_MAGIC: "ENVELOPE_INVALID_MAGIC";
+    readonly PARTITION_CAPACITY_EXCEEDED: "PARTITION_CAPACITY_EXCEEDED";
+    readonly EMBEDDING_FAILED: "EMBEDDING_FAILED";
+    readonly EMBEDDING_DIMENSION_MISMATCH: "EMBEDDING_DIMENSION_MISMATCH";
+    readonly EMBEDDING_NO_SOURCE: "EMBEDDING_NO_SOURCE";
+    readonly EMBEDDING_CONFIG_INVALID: "EMBEDDING_CONFIG_INVALID";
+    readonly DOC_MISSING_REQUIRED_FIELD: "DOC_MISSING_REQUIRED_FIELD";
+    readonly CONFIG_INVALID: "CONFIG_INVALID";
+    readonly QUERY_ROUTING_FAILED: "QUERY_ROUTING_FAILED";
+    readonly QUERY_PARTIAL_FAILURE: "QUERY_PARTIAL_FAILURE";
+    readonly QUERY_NODE_TIMEOUT: "QUERY_NODE_TIMEOUT";
+    readonly QUERY_NO_ACTIVE_REPLICA: "QUERY_NO_ACTIVE_REPLICA";
+    readonly ALLOCATION_NO_DATA_NODES: "ALLOCATION_NO_DATA_NODES";
+    readonly ALLOCATION_INVALID_CONFIG: "ALLOCATION_INVALID_CONFIG";
+    readonly ALLOCATION_FAILED: "ALLOCATION_FAILED";
+    readonly CONTROLLER_LEASE_LOST: "CONTROLLER_LEASE_LOST";
+    readonly CONTROLLER_NOT_ACTIVE: "CONTROLLER_NOT_ACTIVE";
+    readonly CONTROLLER_METADATA_INVALID: "CONTROLLER_METADATA_INVALID";
+    readonly NODE_BOOTSTRAP_FAILED: "NODE_BOOTSTRAP_FAILED";
+    readonly NODE_ALREADY_JOINED: "NODE_ALREADY_JOINED";
+    readonly NODE_NOT_JOINED: "NODE_NOT_JOINED";
+    readonly COORDINATOR_DEPENDENCY_MISSING: "COORDINATOR_DEPENDENCY_MISSING";
+    readonly REPLICATION_ENTRY_INVALID: "REPLICATION_ENTRY_INVALID";
+    readonly REPLICATION_INSYNC_REMOVAL_FAILED: "REPLICATION_INSYNC_REMOVAL_FAILED";
+    readonly REPLICATION_ROLLBACK_FAILED: "REPLICATION_ROLLBACK_FAILED";
+    readonly SNAPSHOT_SYNC_UNAUTHORIZED: "SNAPSHOT_SYNC_UNAUTHORIZED";
+    readonly SNAPSHOT_SYNC_REQUEST_INVALID: "SNAPSHOT_SYNC_REQUEST_INVALID";
+    readonly SNAPSHOT_SYNC_INDEX_NOT_FOUND: "SNAPSHOT_SYNC_INDEX_NOT_FOUND";
+    readonly SNAPSHOT_SYNC_TOO_LARGE: "SNAPSHOT_SYNC_TOO_LARGE";
+    readonly SNAPSHOT_SYNC_CAPACITY_EXHAUSTED: "SNAPSHOT_SYNC_CAPACITY_EXHAUSTED";
+    readonly SNAPSHOT_SYNC_SNAPSHOT_FAILED: "SNAPSHOT_SYNC_SNAPSHOT_FAILED";
+    readonly SNAPSHOT_SYNC_DECODE_FAILED: "SNAPSHOT_SYNC_DECODE_FAILED";
+    readonly SNAPSHOT_SYNC_FRAME_INVALID: "SNAPSHOT_SYNC_FRAME_INVALID";
+    readonly SNAPSHOT_SYNC_HEADER_INVALID: "SNAPSHOT_SYNC_HEADER_INVALID";
+    readonly SNAPSHOT_SYNC_HEADER_MISMATCH: "SNAPSHOT_SYNC_HEADER_MISMATCH";
+    readonly SNAPSHOT_SYNC_CHUNK_OUT_OF_ORDER: "SNAPSHOT_SYNC_CHUNK_OUT_OF_ORDER";
+    readonly SNAPSHOT_SYNC_CHUNK_OVERFLOW: "SNAPSHOT_SYNC_CHUNK_OVERFLOW";
+    readonly SNAPSHOT_SYNC_CHUNK_SIZE_EXCEEDED: "SNAPSHOT_SYNC_CHUNK_SIZE_EXCEEDED";
+    readonly SNAPSHOT_SYNC_CHUNK_MISSING: "SNAPSHOT_SYNC_CHUNK_MISSING";
+    readonly SNAPSHOT_SYNC_END_MISSING: "SNAPSHOT_SYNC_END_MISSING";
+    readonly SNAPSHOT_SYNC_CHECKSUM_MISMATCH: "SNAPSHOT_SYNC_CHECKSUM_MISMATCH";
+    readonly SNAPSHOT_SYNC_PRIMARY_ERROR: "SNAPSHOT_SYNC_PRIMARY_ERROR";
+    readonly SNAPSHOT_SYNC_NO_TARGETS: "SNAPSHOT_SYNC_NO_TARGETS";
+    readonly SNAPSHOT_SYNC_TRANSPORT_FAILED: "SNAPSHOT_SYNC_TRANSPORT_FAILED";
+    readonly SNAPSHOT_SYNC_SCHEMA_UNAVAILABLE: "SNAPSHOT_SYNC_SCHEMA_UNAVAILABLE";
+    readonly SNAPSHOT_SYNC_RESTORE_FAILED: "SNAPSHOT_SYNC_RESTORE_FAILED";
+    readonly SNAPSHOT_SYNC_RESTORE_CLEANUP_FAILED: "SNAPSHOT_SYNC_RESTORE_CLEANUP_FAILED";
+    readonly SNAPSHOT_SYNC_TIMEOUT: "SNAPSHOT_SYNC_TIMEOUT";
+    readonly SNAPSHOT_SYNC_ALLOCATION_UNAVAILABLE: "SNAPSHOT_SYNC_ALLOCATION_UNAVAILABLE";
+    readonly SNAPSHOT_SYNC_NOT_ASSIGNED: "SNAPSHOT_SYNC_NOT_ASSIGNED";
+    readonly SNAPSHOT_SYNC_ABORTED: "SNAPSHOT_SYNC_ABORTED";
+};
+type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];
+declare class NarsilError extends Error {
+    readonly code: ErrorCode;
+    readonly details: Record<string, unknown>;
+    constructor(code: ErrorCode, message: string, details?: Record<string, unknown>);
+}
+
+type ComparisonFilter = {
+    eq?: number | string | boolean;
+    ne?: number | string | boolean;
+    gt?: number;
+    lt?: number;
+    gte?: number;
+    lte?: number;
+    between?: [number, number];
+};
+type StringFilter = ComparisonFilter & {
+    in?: string[];
+    nin?: string[];
+    startsWith?: string;
+    endsWith?: string;
+};
+type ArrayFilter = {
+    containsAll?: (string | number | boolean)[];
+    matchesAny?: (string | number | boolean)[];
+    size?: ComparisonFilter;
+};
+type PresenceFilter = {
+    exists?: boolean;
+    notExists?: boolean;
+    isEmpty?: boolean;
+    isNotEmpty?: boolean;
+};
+type GeoRadiusFilter = {
+    radius: {
+        lat: number;
+        lon: number;
+        distance: number;
+        unit: 'km' | 'mi' | 'm';
+        inside?: boolean;
+        highPrecision?: boolean;
+    };
+};
+type GeoPolygonFilter = {
+    polygon: {
+        points: Array<{
+            lat: number;
+            lon: number;
+        }>;
+        inside?: boolean;
+    };
+};
+type GeoFilter = GeoRadiusFilter | GeoPolygonFilter;
+type FieldFilter = ComparisonFilter | StringFilter | ArrayFilter | PresenceFilter | GeoFilter;
+type FilterExpression = {
+    fields?: Record<string, FieldFilter>;
+    and?: FilterExpression[];
+    or?: FilterExpression[];
+    not?: FilterExpression;
+};
+
+type SearchMode = 'fulltext' | 'vector' | 'hybrid';
+type TermMatchPolicy = 'all' | 'any' | number;
+interface QueryParams {
+    term?: string;
+    fields?: string[];
+    filters?: FilterExpression;
+    boost?: Record<string, number>;
+    scoring?: ScoringMode;
+    minScore?: number;
+    termMatch?: TermMatchPolicy;
+    tolerance?: number;
+    prefixLength?: number;
+    exact?: boolean;
+    facets?: FacetConfig;
+    sort?: Record<string, 'asc' | 'desc'>;
+    group?: GroupConfig;
+    limit?: number;
+    offset?: number;
+    searchAfter?: string;
+    highlight?: HighlightConfig;
+    pinned?: Array<{
+        docId: string;
+        position: number;
+    }>;
+    mode?: SearchMode;
+    vector?: VectorQueryConfig;
+    hybrid?: HybridConfig;
+    includeScoreComponents?: boolean;
+}
+/**
+ * Vector-search inputs passed under `QueryParams.vector`.
+ *
+ * Supply either a raw `value` array or a `text` string for auto-embedding;
+ * passing both throws `EMBEDDING_CONFIG_INVALID`. Result count is governed
+ * by the outer query's `limit`, not by any field on this object.
+ */
+interface VectorQueryConfig {
+    /**
+     * Name of the schema field that holds the vector to compare against.
+     * Must reference a field declared as `vector[N]` in the index schema.
+     */
+    field: string;
+    /**
+     * Raw query vector. Length must match the indexed field's dimension or
+     * the search rejects the request with `VECTOR_DIMENSION_MISMATCH`.
+     */
+    value?: number[];
+    /**
+     * Text to embed at query time using the index or instance embedding
+     * adapter. Mutually exclusive with `value`; requires a configured adapter.
+     */
+    text?: string;
+    /**
+     * Score floor applied during ranking. Hits scoring below this value
+     * are dropped before `limit` is enforced, so the returned hit count
+     * can be smaller than `limit` even when more documents exist. The
+     * floor is interpreted in score space for every metric; for
+     * `euclidean`, distance is mapped to a similarity score of
+     * `1 / (1 + distance)` first. Defaults to no floor.
+     */
+    similarity?: number;
+    /**
+     * Similarity metric used for ranking. Defaults to `cosine`. Choose
+     * `dotProduct` for raw inner-product scoring on already-normalised
+     * vectors and `euclidean` for distance-based ordering.
+     */
+    metric?: 'cosine' | 'dotProduct' | 'euclidean';
+    /**
+     * HNSW exploration factor for approximate search. Higher values raise
+     * recall at the cost of latency. Ignored while the field is still
+     * served by the brute-force backend. Defaults to the engine's built-in
+     * value when omitted.
+     */
+    efSearch?: number;
+}
+interface HybridConfig {
+    strategy?: 'rrf' | 'linear';
+    k?: number;
+    alpha?: number;
+}
+interface FacetConfig {
+    [field: string]: {
+        limit?: number;
+        sort?: 'asc' | 'desc';
+        ranges?: Array<{
+            from: number;
+            to: number;
+        }>;
+    };
+}
+interface GroupConfig {
+    fields: string[];
+    maxPerGroup?: number;
+    reduce?: GroupReducer;
+}
+type GroupReducer = {
+    reducer: (accumulator: unknown, doc: AnyDocument, score: number) => unknown;
+    initialValue: () => unknown;
+};
+interface HighlightConfig {
+    fields: string[];
+    preTag?: string;
+    postTag?: string;
+    maxSnippetLength?: number;
+}
+interface SuggestParams {
+    prefix: string;
+    limit?: number;
+}
+
+interface QueryResult<T = AnyDocument> {
+    hits: Array<Hit<T>>;
+    count: number;
+    elapsed: number;
+    cursor?: string;
+    facets?: Record<string, FacetResult>;
+    groups?: GroupResult[];
+}
+interface Hit<T = AnyDocument> {
+    id: string;
+    score: number;
+    document: T;
+    scoreComponents?: ScoreComponents;
+    highlights?: Record<string, HighlightMatch>;
+}
+interface ScoreComponents {
+    termFrequencies: Record<string, number>;
+    fieldLengths: Record<string, number>;
+    idf: Record<string, number>;
+}
+interface HighlightMatch {
+    snippet: string;
+    positions: Array<{
+        start: number;
+        end: number;
+    }>;
+}
+interface FacetResult {
+    values: Record<string, number>;
+    count: number;
+}
+interface GroupResult {
+    values: Record<string, unknown>;
+    hits: Array<Hit>;
+}
+interface PreflightResult {
+    count: number;
+    elapsed: number;
+}
+interface BatchResult {
+    succeeded: string[];
+    failed: Array<{
+        docId: string;
+        error: NarsilError;
+    }>;
+}
+interface IndexStats {
+    documentCount: number;
+    partitionCount: number;
+    /**
+     * Formula-based estimate of the index's main-thread memory footprint, summed
+     * across every partition and vector index for this index. Computed from
+     * structural counters (document count, posting counts, field-index sizes),
+     * not measured. Per-object V8 overhead (hidden classes, map transitions,
+     * GC headers) is not captured here, so this number routinely undershoots
+     * the real heap by a meaningful factor. Use {@link Narsil.getMemoryStats}
+     * when sizing host memory.
+     */
+    estimatedMemoryBytes: number;
+    language: string;
+    schema: SchemaDefinition;
+}
+interface IndexInfo {
+    name: string;
+    documentCount: number;
+    partitionCount: number;
+    language: string;
+}
+interface PartitionStatsResult {
+    partitionId: number;
+    documentCount: number;
+    /**
+     * Formula-based estimate of this partition's memory footprint. V8 has no
+     * per-object heap accounting API, so this number is derived from structural
+     * counters (document count, posting counts, field-index sizes) and does not
+     * include per-object overhead. Treat as an estimate, not a measurement.
+     */
+    estimatedMemoryBytes: number;
+}
+interface SuggestResult {
+    terms: Array<{
+        term: string;
+        documentFrequency: number;
+    }>;
+    elapsed: number;
+}
+/**
+ * Snapshot of V8 heap usage as reported by `process.memoryUsage()`. All values
+ * are bytes. `null` in environments that do not expose `process.memoryUsage`,
+ * such as browsers.
+ */
+interface ProcessMemoryReport {
+    heapUsed: number;
+    heapTotal: number;
+    external: number;
+    rss: number;
+}
+interface MemoryStats {
+    /**
+     * V8 heap usage for the host process at the moment the call was made. This
+     * is process-wide, not engine-wide; if multiple Narsil engines are running
+     * in the same process every engine's `getMemoryStats` returns the same
+     * `process` figures. `null` in browsers and any runtime where
+     * `process.memoryUsage` is unavailable.
+     */
+    process: ProcessMemoryReport | null;
+    /**
+     * Sum of every index's {@link IndexStats.estimatedMemoryBytes} held by this
+     * engine. Formula-based; treat as an estimate, not a measurement. Useful
+     * for cross-engine relative comparisons inside a single process where
+     * `process.heapUsed` cannot tell engines apart.
+     */
+    estimatedIndexBytes: number;
+    /**
+     * Per-worker V8 heap usage when the engine has been promoted to a worker
+     * pool. Empty when no workers are active.
+     */
+    workers: Array<{
+        workerId: number;
+        heapUsed: number;
+        heapTotal: number;
+        external: number;
+    }>;
+}
+interface VectorMaintenanceResult {
+    fieldName: string;
+    tombstoneRatio: number;
+    graphCount: number;
+    bufferSize: number;
+    building: boolean;
+    estimatedCompactMs: number;
+    estimatedOptimizeMs: number;
+}
+
+interface NarsilPlugin {
+    name: string;
+    beforeInsert?(ctx: InsertContext): void | Promise<void>;
+    afterInsert?(ctx: InsertContext): void | Promise<void>;
+    beforeRemove?(ctx: RemoveContext): void | Promise<void>;
+    afterRemove?(ctx: RemoveContext): void | Promise<void>;
+    beforeUpdate?(ctx: UpdateContext): void | Promise<void>;
+    afterUpdate?(ctx: UpdateContext): void | Promise<void>;
+    beforeSearch?(ctx: SearchContext): void | Promise<void>;
+    afterSearch?(ctx: SearchContext): void | Promise<void>;
+    onIndexCreate?(ctx: IndexContext): void | Promise<void>;
+    onIndexDrop?(ctx: IndexContext): void | Promise<void>;
+    onPartitionSplit?(ctx: PartitionContext): void | Promise<void>;
+    onWorkerPromote?(ctx: WorkerContext): void | Promise<void>;
+}
+interface InsertContext {
+    indexName: string;
+    docId: string;
+    document: AnyDocument;
+}
+interface RemoveContext {
+    indexName: string;
+    docId: string;
+}
+interface UpdateContext {
+    indexName: string;
+    docId: string;
+    oldDocument: AnyDocument;
+    newDocument: AnyDocument;
+}
+interface SearchContext {
+    indexName: string;
+    params: QueryParams;
+    results?: QueryResult;
+}
+interface IndexContext {
+    indexName: string;
+    config: IndexConfig;
+}
+interface PartitionContext {
+    indexName: string;
+    oldPartitionCount: number;
+    newPartitionCount: number;
+}
+interface WorkerContext {
+    workerCount: number;
+    reason: string;
+}
+
+interface NarsilConfig {
+    persistence?: PersistenceAdapter;
+    invalidation?: InvalidationAdapter;
+    plugins?: NarsilPlugin[];
+    idGenerator?: () => string;
+    workers?: WorkerConfig;
+    flush?: FlushConfig;
+    embedding?: EmbeddingAdapter;
+    durability?: DurabilityConfig;
+}
+interface DurabilityConfig {
+    directory?: string;
+    mode?: 'sync' | 'async';
+    flushIntervalMs?: number;
+    segmentMaxBytes?: number;
+    checkpointIntervalMs?: number;
+    checkpointMutationThreshold?: number;
+    compactionThreshold?: number;
+}
+interface WorkerConfig {
+    enabled?: boolean;
+    count?: number;
+    promotionThreshold?: number;
+    totalPromotionThreshold?: number;
+}
+interface FlushConfig {
+    interval?: number;
+    mutationThreshold?: number;
+}
+
+export { type ArrayFilter as A, type BatchResult as B, type ComparisonFilter as C, type VectorQueryConfig as D, type ErrorCode as E, type FacetConfig as F, type GeoPolygonFilter as G, type HighlightConfig as H, type IndexContext as I, type WorkerContext as J, type MemoryStats as M, type NarsilConfig as N, type PartitionContext as P, type QueryParams as Q, type RemoveContext as R, type ScoreComponents as S, type TermMatchPolicy as T, type UpdateContext as U, type VectorMaintenanceResult as V, type WorkerConfig as W, ErrorCodes as a, type FacetResult as b, type FilterExpression as c, type FlushConfig as d, type GeoRadiusFilter as e, type GroupConfig as f, type GroupReducer as g, type GroupResult as h, type HighlightMatch as i, type Hit as j, type HybridConfig as k, type IndexInfo as l, type IndexStats as m, type InsertContext as n, NarsilError as o, type NarsilPlugin as p, type PartitionStatsResult as q, type PreflightResult as r, type PresenceFilter as s, type ProcessMemoryReport as t, type QueryResult as u, type SearchContext as v, type SearchMode as w, type StringFilter as x, type SuggestParams as y, type SuggestResult as z };

package/dist/direct-executor-FX56DYD3.mjs

@@ -0,0 +1,4 @@
+export { createDirectExecutor } from './chunk-FS7XLIUS.mjs';
+import './chunk-S7RJJMHI.mjs';
+import './chunk-TW6BXTOL.mjs';
+import './chunk-ALB35PRQ.mjs';

package/dist/distribution/coordinator/etcd.d.ts

@@ -0,0 +1,16 @@
+import { C as ClusterCoordinator } from '../../types-Bt7c4hDF.js';
+import '../../schema-BVaw7nqz.js';
+import '../../adapters-Bo2JQg8b.js';
+
+interface EtcdCoordinatorConfig {
+    endpoints: string[];
+    keyPrefix: string;
+    nodeHeartbeatTtlSeconds: number;
+    leaseTtlSeconds: number;
+}
+
+declare function validateNodeId(nodeId: string): void;
+
+declare function createEtcdCoordinator(config?: Partial<EtcdCoordinatorConfig>): Promise<ClusterCoordinator>;
+
+export { type EtcdCoordinatorConfig, createEtcdCoordinator, validateNodeId };

package/dist/distribution/coordinator/etcd.mjs

@@ -0,0 +1,2 @@
+export { createEtcdCoordinator, validateNodeId } from '../../chunk-WISGW24C.mjs';
+import '../../chunk-ALB35PRQ.mjs';

package/dist/distribution/coordinator/in-memory.d.ts

@@ -0,0 +1,7 @@
+import { C as ClusterCoordinator } from '../../types-Bt7c4hDF.js';
+import '../../schema-BVaw7nqz.js';
+import '../../adapters-Bo2JQg8b.js';
+
+declare function createInMemoryCoordinator(): ClusterCoordinator;
+
+export { createInMemoryCoordinator };

package/dist/distribution/coordinator/in-memory.mjs

@@ -0,0 +1 @@
+export { createInMemoryCoordinator } from '../../chunk-RQLXC2YS.mjs';

package/dist/distribution.d.ts

@@ -0,0 +1,122 @@
+import { C as ClusterCoordinator, N as NodeRegistration, A as AllocationTable, a as NodeRole, b as NodeCapacity } from './types-Bt7c4hDF.js';
+export { c as AllocationConstraints, d as AllocationEvent, e as NodeEvent, P as PartitionAssignment, f as PartitionState, S as SchemaEvent } from './types-Bt7c4hDF.js';
+import { B as BatchResult, Q as QueryParams, u as QueryResult, N as NarsilConfig } from './config-cQLlYR3U.js';
+import { I as IndexConfig, A as AnyDocument } from './schema-BVaw7nqz.js';
+export { createInMemoryCoordinator } from './distribution/coordinator/in-memory.js';
+import './adapters-Bo2JQg8b.js';
+
+interface TransportMessage {
+    type: string;
+    sourceId: string;
+    requestId: string;
+    payload: Uint8Array;
+}
+interface TransportConfig {
+    connectTimeout: number;
+    requestTimeout: number;
+    replicationTimeout: number;
+    snapshotTimeout: number;
+}
+interface NodeTransport {
+    send(target: string, message: TransportMessage): Promise<TransportMessage>;
+    stream(target: string, message: TransportMessage, handler: (chunk: Uint8Array) => void): Promise<void>;
+    listen(handler: (message: TransportMessage, respond: (response: TransportMessage) => void) => void | Promise<void>): Promise<() => void>;
+    shutdown(): Promise<void>;
+}
+
+interface ControllerConfig {
+    nodeId: string;
+    coordinator: ClusterCoordinator;
+    transport: NodeTransport;
+    leaseTtlMs: number;
+    standbyRetryMs: number;
+    knownIndexNames: string[];
+    onError?: (indexName: string, error: unknown) => void;
+}
+interface ControllerNode {
+    readonly isActive: boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+type DataNodeLifecycleStatus = 'stopped' | 'joining' | 'active' | 'leaving' | 'shutdown';
+interface NodeLifecycleConfig {
+    registration: NodeRegistration;
+    coordinator: ClusterCoordinator;
+    transport: NodeTransport;
+    knownIndexNames: string[];
+    bootstrapRetryBaseMs: number;
+    bootstrapRetryMaxMs: number;
+    bootstrapMaxRetries: number;
+    allocationDebounceMs: number;
+    onBootstrapPartition: (indexName: string, partitionId: number, primaryNodeId: string) => Promise<boolean>;
+    onRemovePartition?: (indexName: string, partitionId: number) => void;
+    onPrimaryDemotion?: (indexName: string, partitionId: number, newPrimaryNodeId: string) => void;
+    onError?: (error: unknown) => void;
+}
+interface DataNodeHandle {
+    readonly status: DataNodeLifecycleStatus;
+    readonly nodeId: string;
+    join(): Promise<void>;
+    leave(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+interface ClusterNodeConfig {
+    coordinator: ClusterCoordinator;
+    transport: NodeTransport;
+    address: string;
+    roles?: NodeRole[];
+    nodeId?: string;
+    capacity?: NodeCapacity;
+    engine?: NarsilConfig;
+    onError?: (error: Error) => void;
+}
+interface CreateIndexOptions {
+    partitionCount?: number;
+    replicationFactor?: number;
+}
+interface ClusterNamespace {
+    getAllocation(indexName: string): Promise<AllocationTable | null>;
+    getNodeInfo(): ClusterNodeInfo;
+    isControllerActive(): boolean;
+}
+interface ClusterNodeInfo {
+    nodeId: string;
+    roles: ReadonlyArray<NodeRole>;
+    status: string;
+}
+interface ClusterNode {
+    readonly nodeId: string;
+    readonly roles: ReadonlyArray<NodeRole>;
+    createIndex(name: string, config: IndexConfig, options?: CreateIndexOptions): Promise<void>;
+    insert(indexName: string, document: AnyDocument, docId?: string): Promise<string>;
+    insertBatch(indexName: string, documents: AnyDocument[]): Promise<BatchResult>;
+    remove(indexName: string, docId: string): Promise<void>;
+    removeBatch(indexName: string, docIds: string[]): Promise<BatchResult>;
+    query<T = AnyDocument>(indexName: string, params: QueryParams): Promise<QueryResult<T>>;
+    cluster: ClusterNamespace;
+    start(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+declare const DEFAULT_PARTITION_COUNT = 5;
+declare const DEFAULT_REPLICATION_FACTOR = 1;
+declare const DEFAULT_CAPACITY: NodeCapacity;
+
+declare function createClusterNode(config: ClusterNodeConfig): Promise<ClusterNode>;
+
+type StreamResponder = (chunks: Uint8Array[]) => void;
+interface InMemoryTransportInternal extends NodeTransport {
+    deliverMessage(message: TransportMessage, respond: (response: TransportMessage) => void): void;
+    deliverStream(message: TransportMessage, responder: StreamResponder): void;
+}
+interface InMemoryNetwork {
+    register(nodeId: string, transport: InMemoryTransportInternal): void;
+    unregister(nodeId: string): void;
+    getTransport(nodeId: string): InMemoryTransportInternal | undefined;
+}
+declare function createInMemoryNetwork(): InMemoryNetwork;
+declare function createInMemoryTransport(nodeId: string, network: InMemoryNetwork, config?: Partial<TransportConfig>): NodeTransport;
+
+export { AllocationTable, ClusterCoordinator, type ClusterNamespace, type ClusterNode, type ClusterNodeConfig, type ClusterNodeInfo, type ControllerConfig, type ControllerNode, type CreateIndexOptions, DEFAULT_CAPACITY, DEFAULT_PARTITION_COUNT, DEFAULT_REPLICATION_FACTOR, type DataNodeHandle, type InMemoryNetwork, type InMemoryTransportInternal, NodeCapacity, type NodeLifecycleConfig, NodeRegistration, NodeRole, type NodeTransport, type TransportConfig, createClusterNode, createInMemoryNetwork, createInMemoryTransport };