@delali/narsil 0.1.7 → 0.1.9

package/dist/adapters/filesystem.d.ts

@@ -1,4 +1,4 @@
-import { P as PersistenceAdapter } from '../adapters-BbRkoiu9.js';
+import { b as PersistenceAdapter } from '../adapters-Bo2JQg8b.js';
 
 interface FilesystemPersistenceConfig {
     directory: string;

package/dist/adapters/filesystem.mjs

@@ -1,4 +1,4 @@
-import { NarsilError, ErrorCodes } from '../chunk-R2C2EQGO.mjs';
+import { NarsilError, ErrorCodes } from '../chunk-ALB35PRQ.mjs';
 
 // src/persistence/filesystem.ts
 var cachedFs = null;
@@ -30,6 +30,25 @@ async function resolveAndGuard(baseDir, key) {
   }
   return resolvedPath;
 }
+async function fsyncDirectory(dirPath, fs) {
+  let handle = null;
+  try {
+    handle = await fs.open(dirPath, "r");
+    await handle.sync();
+  } catch (err) {
+    const code = err.code;
+    if (code === "EISDIR" || code === "EPERM" || code === "EINVAL" || code === "ENOTSUP") {
+      return;
+    }
+    throw new NarsilError(ErrorCodes.PERSISTENCE_FSYNC_FAILED, `fsync failed for directory "${dirPath}"`, {
+      cause: err instanceof Error ? err.message : String(err)
+    });
+  } finally {
+    if (handle !== null) {
+      await handle.close().catch(() => void 0);
+    }
+  }
+}
 async function listDirectoryRecursive(dir, baseDir, pathMod, fs) {
   const results = [];
   let entries;
@@ -62,13 +81,38 @@ function createFilesystemPersistence(config) {
   }
   const baseDir = config.directory;
   return {
+    directory: baseDir,
     async save(key, data) {
       const resolvedPath = await resolveAndGuard(baseDir, key);
       const fs = await getFs();
       const pathMod = await getPath();
       const dir = pathMod.dirname(resolvedPath);
       await fs.mkdir(dir, { recursive: true });
-      await fs.writeFile(resolvedPath, data);
+      const tempName = `${pathMod.basename(resolvedPath)}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+      const tempPath = pathMod.join(dir, tempName);
+      let handle = null;
+      try {
+        handle = await fs.open(tempPath, "w");
+        await handle.write(data);
+        try {
+          await handle.sync();
+        } catch (err) {
+          throw new NarsilError(ErrorCodes.PERSISTENCE_FSYNC_FAILED, `fsync failed for "${key}"`, {
+            key,
+            cause: err instanceof Error ? err.message : String(err)
+          });
+        }
+        await handle.close();
+        handle = null;
+        await fs.rename(tempPath, resolvedPath);
+        await fsyncDirectory(dir, fs);
+      } catch (err) {
+        if (handle !== null) {
+          await handle.close().catch(() => void 0);
+        }
+        await fs.unlink(tempPath).catch(() => void 0);
+        throw err;
+      }
     },
     async load(key) {
       const resolvedPath = await resolveAndGuard(baseDir, key);

package/dist/adapters/indexeddb.d.ts

@@ -1,4 +1,4 @@
-import { P as PersistenceAdapter } from '../adapters-BbRkoiu9.js';
+import { b as PersistenceAdapter } from '../adapters-Bo2JQg8b.js';
 
 interface IndexedDBPersistenceConfig {
     dbName?: string;

package/dist/adapters/indexeddb.mjs

@@ -1,4 +1,4 @@
-import { NarsilError, ErrorCodes } from '../chunk-R2C2EQGO.mjs';
+import { NarsilError, ErrorCodes } from '../chunk-ALB35PRQ.mjs';
 
 // src/persistence/indexeddb.ts
 var DEFAULT_DB_NAME = "narsil";

package/dist/adapters/memory.d.ts

@@ -1,4 +1,4 @@
-import { P as PersistenceAdapter } from '../adapters-BbRkoiu9.js';
+import { b as PersistenceAdapter } from '../adapters-Bo2JQg8b.js';
 
 declare function createMemoryPersistence(): PersistenceAdapter;
 

package/dist/{adapters-BbRkoiu9.d.ts → adapters-Bo2JQg8b.d.ts}

@@ -3,6 +3,7 @@ interface PersistenceAdapter {
     load(key: string): Promise<Uint8Array | null>;
     delete(key: string): Promise<void>;
     list(prefix: string): Promise<string[]>;
+    readonly directory?: string;
 }
 interface InvalidationAdapter {
     publish(event: InvalidationEvent): Promise<void>;
@@ -33,4 +34,4 @@ interface EmbeddingAdapter {
     shutdown?(): Promise<void>;
 }
 
-export type { EmbeddingAdapter as E, InvalidationAdapter as I, PersistenceAdapter as P, InvalidationEvent as a, PartitionStatistics as b };
+export type { EmbeddingAdapter as E, InvalidationAdapter as I, PartitionStatistics as P, InvalidationEvent as a, PersistenceAdapter as b };

package/dist/chunk-ALB35PRQ.mjs

@@ -0,0 +1,98 @@
+// src/errors.ts
+var ErrorCodes = {
+  SCHEMA_INVALID_TYPE: "SCHEMA_INVALID_TYPE",
+  SCHEMA_MISSING_FIELD: "SCHEMA_MISSING_FIELD",
+  SCHEMA_DEPTH_EXCEEDED: "SCHEMA_DEPTH_EXCEEDED",
+  SCHEMA_INVALID_VECTOR_DIMENSION: "SCHEMA_INVALID_VECTOR_DIMENSION",
+  SCHEMA_INVALID_GEOPOINT: "SCHEMA_INVALID_GEOPOINT",
+  DOC_NOT_FOUND: "DOC_NOT_FOUND",
+  DOC_ALREADY_EXISTS: "DOC_ALREADY_EXISTS",
+  DOC_VALIDATION_FAILED: "DOC_VALIDATION_FAILED",
+  INDEX_NOT_FOUND: "INDEX_NOT_FOUND",
+  INDEX_ALREADY_EXISTS: "INDEX_ALREADY_EXISTS",
+  PARTITION_CORRUPTED: "PARTITION_CORRUPTED",
+  PARTITION_REBALANCING_BACKPRESSURE: "PARTITION_REBALANCING_BACKPRESSURE",
+  WORKER_CRASHED: "WORKER_CRASHED",
+  WORKER_BUSY: "WORKER_BUSY",
+  WORKER_TIMEOUT: "WORKER_TIMEOUT",
+  PERSISTENCE_SAVE_FAILED: "PERSISTENCE_SAVE_FAILED",
+  PERSISTENCE_LOAD_FAILED: "PERSISTENCE_LOAD_FAILED",
+  PERSISTENCE_DELETE_FAILED: "PERSISTENCE_DELETE_FAILED",
+  PERSISTENCE_CRC_MISMATCH: "PERSISTENCE_CRC_MISMATCH",
+  PERSISTENCE_WAL_CORRUPT: "PERSISTENCE_WAL_CORRUPT",
+  PERSISTENCE_FSYNC_FAILED: "PERSISTENCE_FSYNC_FAILED",
+  SEARCH_INVALID_FIELD: "SEARCH_INVALID_FIELD",
+  SEARCH_INVALID_VECTOR_SIZE: "SEARCH_INVALID_VECTOR_SIZE",
+  VECTOR_DIMENSION_MISMATCH: "VECTOR_DIMENSION_MISMATCH",
+  SEARCH_INVALID_FILTER: "SEARCH_INVALID_FILTER",
+  SEARCH_INVALID_MODE: "SEARCH_INVALID_MODE",
+  SEARCH_INVALID_CURSOR: "SEARCH_INVALID_CURSOR",
+  LANGUAGE_NOT_SUPPORTED: "LANGUAGE_NOT_SUPPORTED",
+  ENVELOPE_VERSION_MISMATCH: "ENVELOPE_VERSION_MISMATCH",
+  ENVELOPE_INVALID_MAGIC: "ENVELOPE_INVALID_MAGIC",
+  PARTITION_CAPACITY_EXCEEDED: "PARTITION_CAPACITY_EXCEEDED",
+  EMBEDDING_FAILED: "EMBEDDING_FAILED",
+  EMBEDDING_DIMENSION_MISMATCH: "EMBEDDING_DIMENSION_MISMATCH",
+  EMBEDDING_NO_SOURCE: "EMBEDDING_NO_SOURCE",
+  EMBEDDING_CONFIG_INVALID: "EMBEDDING_CONFIG_INVALID",
+  DOC_MISSING_REQUIRED_FIELD: "DOC_MISSING_REQUIRED_FIELD",
+  CONFIG_INVALID: "CONFIG_INVALID",
+  QUERY_ROUTING_FAILED: "QUERY_ROUTING_FAILED",
+  QUERY_PARTIAL_FAILURE: "QUERY_PARTIAL_FAILURE",
+  QUERY_NODE_TIMEOUT: "QUERY_NODE_TIMEOUT",
+  QUERY_NO_ACTIVE_REPLICA: "QUERY_NO_ACTIVE_REPLICA",
+  ALLOCATION_NO_DATA_NODES: "ALLOCATION_NO_DATA_NODES",
+  ALLOCATION_INVALID_CONFIG: "ALLOCATION_INVALID_CONFIG",
+  ALLOCATION_FAILED: "ALLOCATION_FAILED",
+  CONTROLLER_LEASE_LOST: "CONTROLLER_LEASE_LOST",
+  CONTROLLER_NOT_ACTIVE: "CONTROLLER_NOT_ACTIVE",
+  CONTROLLER_METADATA_INVALID: "CONTROLLER_METADATA_INVALID",
+  NODE_BOOTSTRAP_FAILED: "NODE_BOOTSTRAP_FAILED",
+  NODE_ALREADY_JOINED: "NODE_ALREADY_JOINED",
+  NODE_NOT_JOINED: "NODE_NOT_JOINED",
+  COORDINATOR_DEPENDENCY_MISSING: "COORDINATOR_DEPENDENCY_MISSING",
+  REPLICATION_ENTRY_INVALID: "REPLICATION_ENTRY_INVALID",
+  REPLICATION_INSYNC_REMOVAL_FAILED: "REPLICATION_INSYNC_REMOVAL_FAILED",
+  REPLICATION_ROLLBACK_FAILED: "REPLICATION_ROLLBACK_FAILED",
+  SNAPSHOT_SYNC_UNAUTHORIZED: "SNAPSHOT_SYNC_UNAUTHORIZED",
+  SNAPSHOT_SYNC_REQUEST_INVALID: "SNAPSHOT_SYNC_REQUEST_INVALID",
+  SNAPSHOT_SYNC_INDEX_NOT_FOUND: "SNAPSHOT_SYNC_INDEX_NOT_FOUND",
+  SNAPSHOT_SYNC_TOO_LARGE: "SNAPSHOT_SYNC_TOO_LARGE",
+  SNAPSHOT_SYNC_CAPACITY_EXHAUSTED: "SNAPSHOT_SYNC_CAPACITY_EXHAUSTED",
+  SNAPSHOT_SYNC_SNAPSHOT_FAILED: "SNAPSHOT_SYNC_SNAPSHOT_FAILED",
+  SNAPSHOT_SYNC_DECODE_FAILED: "SNAPSHOT_SYNC_DECODE_FAILED",
+  SNAPSHOT_SYNC_FRAME_INVALID: "SNAPSHOT_SYNC_FRAME_INVALID",
+  SNAPSHOT_SYNC_HEADER_INVALID: "SNAPSHOT_SYNC_HEADER_INVALID",
+  SNAPSHOT_SYNC_HEADER_MISMATCH: "SNAPSHOT_SYNC_HEADER_MISMATCH",
+  SNAPSHOT_SYNC_CHUNK_OUT_OF_ORDER: "SNAPSHOT_SYNC_CHUNK_OUT_OF_ORDER",
+  SNAPSHOT_SYNC_CHUNK_OVERFLOW: "SNAPSHOT_SYNC_CHUNK_OVERFLOW",
+  SNAPSHOT_SYNC_CHUNK_SIZE_EXCEEDED: "SNAPSHOT_SYNC_CHUNK_SIZE_EXCEEDED",
+  SNAPSHOT_SYNC_CHUNK_MISSING: "SNAPSHOT_SYNC_CHUNK_MISSING",
+  SNAPSHOT_SYNC_END_MISSING: "SNAPSHOT_SYNC_END_MISSING",
+  SNAPSHOT_SYNC_CHECKSUM_MISMATCH: "SNAPSHOT_SYNC_CHECKSUM_MISMATCH",
+  SNAPSHOT_SYNC_PRIMARY_ERROR: "SNAPSHOT_SYNC_PRIMARY_ERROR",
+  SNAPSHOT_SYNC_NO_TARGETS: "SNAPSHOT_SYNC_NO_TARGETS",
+  SNAPSHOT_SYNC_TRANSPORT_FAILED: "SNAPSHOT_SYNC_TRANSPORT_FAILED",
+  SNAPSHOT_SYNC_SCHEMA_UNAVAILABLE: "SNAPSHOT_SYNC_SCHEMA_UNAVAILABLE",
+  SNAPSHOT_SYNC_RESTORE_FAILED: "SNAPSHOT_SYNC_RESTORE_FAILED",
+  SNAPSHOT_SYNC_RESTORE_CLEANUP_FAILED: "SNAPSHOT_SYNC_RESTORE_CLEANUP_FAILED",
+  SNAPSHOT_SYNC_TIMEOUT: "SNAPSHOT_SYNC_TIMEOUT",
+  SNAPSHOT_SYNC_ALLOCATION_UNAVAILABLE: "SNAPSHOT_SYNC_ALLOCATION_UNAVAILABLE",
+  SNAPSHOT_SYNC_NOT_ASSIGNED: "SNAPSHOT_SYNC_NOT_ASSIGNED",
+  SNAPSHOT_SYNC_ABORTED: "SNAPSHOT_SYNC_ABORTED"
+};
+var NarsilError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "NarsilError";
+    this.code = code;
+    this.details = details ?? {};
+  }
+};
+function createNarsilError(code, message, details) {
+  return new NarsilError(code, message, details);
+}
+
+export { ErrorCodes, NarsilError, createNarsilError };

package/dist/chunk-KMMJMDUA.mjs

@@ -0,0 +1,44 @@
+// src/serialization/crc32.ts
+var IEEE_POLYNOMIAL = 3988292384;
+var cachedTable = null;
+function buildTable() {
+  const table = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let crc = i;
+    for (let bit = 0; bit < 8; bit++) {
+      crc = crc & 1 ? crc >>> 1 ^ IEEE_POLYNOMIAL : crc >>> 1;
+    }
+    table[i] = crc;
+  }
+  return table;
+}
+function getTable() {
+  if (cachedTable === null) {
+    cachedTable = buildTable();
+  }
+  return cachedTable;
+}
+function crc32(data) {
+  const table = getTable();
+  let crc = 4294967295;
+  for (let i = 0; i < data.length; i++) {
+    crc = crc >>> 8 ^ table[(crc ^ data[i]) & 255];
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function crc32Init() {
+  return 4294967295;
+}
+function crc32Update(state, data) {
+  const table = getTable();
+  let crc = state;
+  for (let i = 0; i < data.length; i++) {
+    crc = crc >>> 8 ^ table[(crc ^ data[i]) & 255];
+  }
+  return crc;
+}
+function crc32Final(state) {
+  return (state ^ 4294967295) >>> 0;
+}
+
+export { crc32, crc32Final, crc32Init, crc32Update };

package/dist/chunk-RQLXC2YS.mjs

@@ -0,0 +1,269 @@
+// src/distribution/coordinator/in-memory.ts
+var NODE_HEARTBEAT_PREFIX = "_narsil/node/";
+function bytesEqual(a, b) {
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+  for (let i = 0; i < a.byteLength; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function createInMemoryCoordinator() {
+  const nodes = /* @__PURE__ */ new Map();
+  const allocations = /* @__PURE__ */ new Map();
+  const partitionStates = /* @__PURE__ */ new Map();
+  const leases = /* @__PURE__ */ new Map();
+  const schemas = /* @__PURE__ */ new Map();
+  const kvStore = /* @__PURE__ */ new Map();
+  const nodeWatchers = /* @__PURE__ */ new Set();
+  const allocationWatchers = /* @__PURE__ */ new Set();
+  const schemaWatchers = /* @__PURE__ */ new Set();
+  let isShutdown = false;
+  function assertNotShutdown() {
+    if (isShutdown) {
+      throw new Error("Coordinator has been shut down");
+    }
+  }
+  function emitNodeEvent(event) {
+    for (const handler of nodeWatchers) {
+      try {
+        handler(event);
+      } catch (_) {
+      }
+    }
+  }
+  function emitAllocationEvent(event) {
+    for (const handler of allocationWatchers) {
+      try {
+        handler(event);
+      } catch (_) {
+      }
+    }
+  }
+  function emitSchemaEvent(event) {
+    for (const handler of schemaWatchers) {
+      try {
+        handler(event);
+      } catch (_) {
+      }
+    }
+  }
+  function clearLeaseEntry(key) {
+    const entry = leases.get(key);
+    if (entry !== void 0) {
+      clearTimeout(entry.timer);
+      leases.delete(key);
+    }
+  }
+  function createLeaseTimer(key, ttlMs) {
+    return setTimeout(() => {
+      leases.delete(key);
+      if (key.startsWith(NODE_HEARTBEAT_PREFIX)) {
+        const expiredNodeId = key.slice(NODE_HEARTBEAT_PREFIX.length);
+        nodes.delete(expiredNodeId);
+        emitNodeEvent({ type: "node_left", nodeId: expiredNodeId, registration: null });
+      }
+    }, ttlMs);
+  }
+  function isLeaseValid(key) {
+    const entry = leases.get(key);
+    if (entry === void 0) {
+      return false;
+    }
+    return entry.expiresAt > Date.now();
+  }
+  const coordinator = {
+    async registerNode(registration) {
+      assertNotShutdown();
+      nodes.set(registration.nodeId, registration);
+      const heartbeatKey = `${NODE_HEARTBEAT_PREFIX}${registration.nodeId}`;
+      const defaultTtlMs = 3e4;
+      clearLeaseEntry(heartbeatKey);
+      const timer = createLeaseTimer(heartbeatKey, defaultTtlMs);
+      leases.set(heartbeatKey, {
+        nodeId: registration.nodeId,
+        expiresAt: Date.now() + defaultTtlMs,
+        timer
+      });
+      emitNodeEvent({ type: "node_joined", nodeId: registration.nodeId, registration });
+    },
+    async deregisterNode(nodeId) {
+      assertNotShutdown();
+      const existed = nodes.delete(nodeId);
+      const heartbeatKey = `${NODE_HEARTBEAT_PREFIX}${nodeId}`;
+      clearLeaseEntry(heartbeatKey);
+      if (existed) {
+        emitNodeEvent({ type: "node_left", nodeId, registration: null });
+      }
+    },
+    async listNodes() {
+      assertNotShutdown();
+      return Array.from(nodes.values());
+    },
+    async watchNodes(handler) {
+      assertNotShutdown();
+      nodeWatchers.add(handler);
+      return () => {
+        nodeWatchers.delete(handler);
+      };
+    },
+    async getAllocation(indexName) {
+      assertNotShutdown();
+      return allocations.get(indexName) ?? null;
+    },
+    async putAllocation(indexName, table, expectedVersion) {
+      assertNotShutdown();
+      if (expectedVersion !== void 0) {
+        const current = allocations.get(indexName);
+        if (expectedVersion === null) {
+          if (current !== void 0) {
+            return false;
+          }
+        } else {
+          if (current === void 0 || current.version !== expectedVersion) {
+            return false;
+          }
+        }
+      }
+      allocations.set(indexName, table);
+      emitAllocationEvent({ indexName, table });
+      return true;
+    },
+    async watchAllocation(handler) {
+      assertNotShutdown();
+      allocationWatchers.add(handler);
+      return () => {
+        allocationWatchers.delete(handler);
+      };
+    },
+    async getPartitionState(indexName, partitionId) {
+      assertNotShutdown();
+      const indexStates = partitionStates.get(indexName);
+      if (indexStates === void 0) {
+        return "UNASSIGNED";
+      }
+      return indexStates.get(partitionId) ?? "UNASSIGNED";
+    },
+    async putPartitionState(indexName, partitionId, state) {
+      assertNotShutdown();
+      let indexStates = partitionStates.get(indexName);
+      if (indexStates === void 0) {
+        indexStates = /* @__PURE__ */ new Map();
+        partitionStates.set(indexName, indexStates);
+      }
+      indexStates.set(partitionId, state);
+    },
+    async acquireLease(key, nodeId, ttlMs) {
+      assertNotShutdown();
+      if (isLeaseValid(key)) {
+        const entry = leases.get(key);
+        if (entry !== void 0 && entry.nodeId !== nodeId) {
+          return false;
+        }
+        if (entry !== void 0 && entry.nodeId === nodeId) {
+          clearTimeout(entry.timer);
+          const timer2 = createLeaseTimer(key, ttlMs);
+          entry.expiresAt = Date.now() + ttlMs;
+          entry.timer = timer2;
+          return true;
+        }
+      }
+      clearLeaseEntry(key);
+      const timer = createLeaseTimer(key, ttlMs);
+      leases.set(key, { nodeId, expiresAt: Date.now() + ttlMs, timer });
+      return true;
+    },
+    async renewLease(key, nodeId, ttlMs) {
+      assertNotShutdown();
+      const entry = leases.get(key);
+      if (entry === void 0 || entry.nodeId !== nodeId) {
+        return false;
+      }
+      if (!isLeaseValid(key)) {
+        leases.delete(key);
+        return false;
+      }
+      clearTimeout(entry.timer);
+      entry.timer = createLeaseTimer(key, ttlMs);
+      entry.expiresAt = Date.now() + ttlMs;
+      return true;
+    },
+    async releaseLease(key) {
+      assertNotShutdown();
+      clearLeaseEntry(key);
+    },
+    async get(key) {
+      assertNotShutdown();
+      const value = kvStore.get(key);
+      return value !== void 0 ? new Uint8Array(value) : null;
+    },
+    async compareAndSet(key, expected, value) {
+      assertNotShutdown();
+      const current = kvStore.get(key);
+      if (expected === null) {
+        if (current !== void 0) {
+          return false;
+        }
+        kvStore.set(key, new Uint8Array(value));
+        return true;
+      }
+      if (current === void 0) {
+        return false;
+      }
+      if (!bytesEqual(current, expected)) {
+        return false;
+      }
+      kvStore.set(key, new Uint8Array(value));
+      return true;
+    },
+    async getSchema(indexName) {
+      assertNotShutdown();
+      return schemas.get(indexName) ?? null;
+    },
+    async putSchema(indexName, schema) {
+      assertNotShutdown();
+      schemas.set(indexName, schema);
+      emitSchemaEvent({ type: "schema_created", indexName, schema });
+    },
+    async watchSchemas(handler) {
+      assertNotShutdown();
+      schemaWatchers.add(handler);
+      return () => {
+        schemaWatchers.delete(handler);
+      };
+    },
+    async getLeaseHolder(key) {
+      assertNotShutdown();
+      if (!isLeaseValid(key)) {
+        clearLeaseEntry(key);
+        return null;
+      }
+      const entry = leases.get(key);
+      return entry?.nodeId ?? null;
+    },
+    async shutdown() {
+      if (isShutdown) {
+        return;
+      }
+      isShutdown = true;
+      for (const entry of leases.values()) {
+        clearTimeout(entry.timer);
+      }
+      leases.clear();
+      nodes.clear();
+      allocations.clear();
+      partitionStates.clear();
+      schemas.clear();
+      kvStore.clear();
+      nodeWatchers.clear();
+      allocationWatchers.clear();
+      schemaWatchers.clear();
+    }
+  };
+  return coordinator;
+}
+
+export { createInMemoryCoordinator };