@delali/narsil 0.1.0

package/dist/invalidation/broadcast-channel.d.ts

@@ -0,0 +1,8 @@
+import { I as InvalidationAdapter } from '../adapters-XODT2F3h.js';
+
+interface BroadcastChannelInvalidationConfig {
+    channelName?: string;
+}
+declare function createBroadcastChannelInvalidation(config?: BroadcastChannelInvalidationConfig): InvalidationAdapter;
+
+export { type BroadcastChannelInvalidationConfig, createBroadcastChannelInvalidation };

package/dist/invalidation/broadcast-channel.mjs

@@ -0,0 +1,46 @@
+// src/invalidation/broadcast-channel.ts
+var DEFAULT_CHANNEL_NAME = "narsil-invalidation";
+function isInvalidationEvent(data) {
+  if (typeof data !== "object" || data === null) {
+    return false;
+  }
+  const record = data;
+  return record.type === "partition" || record.type === "statistics";
+}
+function createBroadcastChannelInvalidation(config) {
+  const channelName = config?.channelName ?? DEFAULT_CHANNEL_NAME;
+  let channel = null;
+  function getChannel() {
+    if (channel !== null) {
+      return channel;
+    }
+    if (typeof BroadcastChannel === "undefined") {
+      throw new Error(
+        "BroadcastChannel is not available in this environment. Use a different invalidation adapter, or run in a browser or worker context that supports BroadcastChannel."
+      );
+    }
+    channel = new BroadcastChannel(channelName);
+    return channel;
+  }
+  return {
+    async publish(event) {
+      getChannel().postMessage(event);
+    },
+    async subscribe(fn) {
+      const ch = getChannel();
+      ch.onmessage = (e) => {
+        if (isInvalidationEvent(e.data)) {
+          fn(e.data);
+        }
+      };
+    },
+    async shutdown() {
+      if (channel !== null) {
+        channel.close();
+        channel = null;
+      }
+    }
+  };
+}
+
+export { createBroadcastChannelInvalidation };

package/dist/invalidation/filesystem.d.ts

@@ -0,0 +1,10 @@
+import { I as InvalidationAdapter } from '../adapters-XODT2F3h.js';
+
+interface FilesystemInvalidationConfig {
+    directory: string;
+    pollInterval?: number;
+    instanceId?: string;
+}
+declare function createFilesystemInvalidation(config: FilesystemInvalidationConfig): InvalidationAdapter;
+
+export { type FilesystemInvalidationConfig, createFilesystemInvalidation };

package/dist/invalidation/filesystem.mjs

@@ -0,0 +1,159 @@
+// src/invalidation/filesystem.ts
+var MARKER_MAX_AGE_MS = 6e4;
+var DEFAULT_POLL_INTERVAL = 1e3;
+function generateInstanceId() {
+  if (typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  return `inst-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function isValidDirectory(directory) {
+  const normalized = directory.replace(/\\/g, "/");
+  if (normalized.includes("..")) {
+    return false;
+  }
+  return true;
+}
+function isInvalidationEvent(data) {
+  if (typeof data !== "object" || data === null) {
+    return false;
+  }
+  const record = data;
+  return record.type === "partition" || record.type === "statistics";
+}
+function createFilesystemInvalidation(config) {
+  if (!isValidDirectory(config.directory)) {
+    throw new Error(`Invalid directory path: path traversal detected in "${config.directory}"`);
+  }
+  const directory = config.directory;
+  const pollInterval = config.pollInterval ?? DEFAULT_POLL_INTERVAL;
+  const instanceId = config.instanceId ?? generateInstanceId();
+  if (instanceId.includes("/") || instanceId.includes("\\") || instanceId.includes("..") || instanceId.includes("\0")) {
+    throw new Error(`Invalid instanceId: "${instanceId}" contains path separator or traversal characters`);
+  }
+  let lastProcessedTimestamp = Date.now();
+  let pollTimer = null;
+  let handler = null;
+  async function ensureDirectory() {
+    const fs = await import('fs/promises');
+    try {
+      await fs.mkdir(directory, { recursive: true });
+    } catch {
+    }
+  }
+  async function processMarkerFiles() {
+    if (!handler) {
+      return;
+    }
+    const fs = await import('fs/promises');
+    const path = await import('path');
+    let files;
+    try {
+      files = await fs.readdir(directory);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return;
+      }
+      throw err;
+    }
+    const jsonFiles = files.filter((f) => f.endsWith(".json")).sort();
+    const now = Date.now();
+    for (const file of jsonFiles) {
+      const filePath = path.join(directory, file);
+      let content;
+      try {
+        content = await fs.readFile(filePath, "utf-8");
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          continue;
+        }
+        throw err;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(content);
+      } catch {
+        try {
+          await fs.unlink(filePath);
+        } catch {
+        }
+        continue;
+      }
+      const writtenAt = typeof parsed.writtenAt === "number" ? parsed.writtenAt : 0;
+      if (writtenAt <= lastProcessedTimestamp) {
+        if (now - writtenAt > MARKER_MAX_AGE_MS) {
+          try {
+            await fs.unlink(filePath);
+          } catch {
+          }
+        }
+        continue;
+      }
+      if (parsed.instanceId === instanceId) {
+        if (now - writtenAt > MARKER_MAX_AGE_MS) {
+          try {
+            await fs.unlink(filePath);
+          } catch {
+          }
+        }
+        continue;
+      }
+      if (isInvalidationEvent(parsed)) {
+        handler(parsed);
+      }
+      if (writtenAt > lastProcessedTimestamp) {
+        lastProcessedTimestamp = writtenAt;
+      }
+      if (now - writtenAt > MARKER_MAX_AGE_MS) {
+        try {
+          await fs.unlink(filePath);
+        } catch {
+        }
+      }
+    }
+  }
+  return {
+    async publish(event) {
+      await ensureDirectory();
+      const fs = await import('fs/promises');
+      const path = await import('path');
+      const timestamp = Date.now();
+      const filename = `${timestamp}-${instanceId}.json`;
+      const filePath = path.join(directory, filename);
+      const payload = JSON.stringify({ ...event, instanceId, writtenAt: timestamp });
+      await fs.writeFile(filePath, payload, "utf-8");
+    },
+    async subscribe(fn) {
+      handler = fn;
+      lastProcessedTimestamp = Date.now();
+      pollTimer = setInterval(() => {
+        processMarkerFiles().catch(() => {
+        });
+      }, pollInterval);
+    },
+    async shutdown() {
+      if (pollTimer !== null) {
+        clearInterval(pollTimer);
+        pollTimer = null;
+      }
+      handler = null;
+      const fs = await import('fs/promises');
+      const path = await import('path');
+      let files;
+      try {
+        files = await fs.readdir(directory);
+      } catch {
+        return;
+      }
+      const ownFiles = files.filter((f) => f.endsWith(`-${instanceId}.json`));
+      for (const file of ownFiles) {
+        try {
+          await fs.unlink(path.join(directory, file));
+        } catch {
+        }
+      }
+    }
+  };
+}
+
+export { createFilesystemInvalidation };

package/dist/invalidation/noop.d.ts

@@ -0,0 +1,5 @@
+import { I as InvalidationAdapter } from '../adapters-XODT2F3h.js';
+
+declare function createNoopInvalidation(): InvalidationAdapter;
+
+export { createNoopInvalidation };

package/dist/invalidation/noop.mjs

@@ -0,0 +1,13 @@
+// src/invalidation/noop.ts
+function createNoopInvalidation() {
+  return {
+    async publish() {
+    },
+    async subscribe() {
+    },
+    async shutdown() {
+    }
+  };
+}
+
+export { createNoopInvalidation };

package/dist/language-ClUGLuoC.d.ts

@@ -0,0 +1,13 @@
+interface LanguageModule {
+    name: string;
+    stemmer: ((token: string) => string) | null;
+    stopWords: Set<string>;
+    tokenizer?: TokenizerConfig;
+}
+interface TokenizerConfig {
+    splitPattern?: RegExp;
+    normalizeDiacritics?: boolean;
+    minTokenLength?: number;
+}
+
+export type { LanguageModule as L };

package/dist/languages/arabic.d.ts

@@ -0,0 +1,5 @@
+import { L as LanguageModule } from '../language-ClUGLuoC.js';
+
+declare const arabic: LanguageModule;
+
+export { arabic };