@delali/narsil 0.1.7 → 0.1.8

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 };