@delali/narsil 0.2.2 → 0.2.3-next.32

package/dist/chunk-RQLXC2YS.mjs

@@ -1,269 +0,0 @@
-// 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 };

package/dist/direct-executor-3W4QRA4E.mjs

@@ -1,5 +0,0 @@
-export { createDirectExecutor } from './chunk-ASI6AOW2.mjs';
-import './chunk-TGP5M5R7.mjs';
-import './chunk-S7RJJMHI.mjs';
-import './chunk-U2BKYEC7.mjs';
-import './chunk-UNJZ7ZDB.mjs';