@gravito/constellation 1.0.0-alpha.2

package/dist/index.cjs

@@ -0,0 +1,2142 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/storage/DiskSitemapStorage.ts
+var exports_DiskSitemapStorage = {};
+__export(exports_DiskSitemapStorage, {
+  DiskSitemapStorage: () => DiskSitemapStorage
+});
+
+class DiskSitemapStorage {
+  outDir;
+  baseUrl;
+  constructor(outDir, baseUrl) {
+    this.outDir = outDir;
+    this.baseUrl = baseUrl;
+  }
+  async write(filename, content) {
+    await import_promises.default.mkdir(this.outDir, { recursive: true });
+    await import_promises.default.writeFile(import_node_path.default.join(this.outDir, filename), content);
+  }
+  async read(filename) {
+    try {
+      return await import_promises.default.readFile(import_node_path.default.join(this.outDir, filename), "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  async exists(filename) {
+    try {
+      await import_promises.default.access(import_node_path.default.join(this.outDir, filename));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getUrl(filename) {
+    const base = this.baseUrl.endsWith("/") ? this.baseUrl.slice(0, -1) : this.baseUrl;
+    const file = filename.startsWith("/") ? filename.slice(1) : filename;
+    return `${base}/${file}`;
+  }
+}
+var import_promises, import_node_path;
+var init_DiskSitemapStorage = __esm(() => {
+  import_promises = __toESM(require("node:fs/promises"));
+  import_node_path = __toESM(require("node:path"));
+});
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  routeScanner: () => routeScanner,
+  generateI18nEntries: () => generateI18nEntries,
+  SitemapStream: () => SitemapStream,
+  SitemapIndex: () => SitemapIndex,
+  SitemapGenerator: () => SitemapGenerator,
+  ShadowProcessor: () => ShadowProcessor,
+  S3SitemapStorage: () => S3SitemapStorage,
+  RouteScanner: () => RouteScanner,
+  RedisRedirectManager: () => RedisRedirectManager,
+  RedisProgressStorage: () => RedisProgressStorage,
+  RedisChangeTracker: () => RedisChangeTracker,
+  RedirectHandler: () => RedirectHandler,
+  RedirectDetector: () => RedirectDetector,
+  ProgressTracker: () => ProgressTracker,
+  OrbitSitemap: () => OrbitSitemap,
+  MemorySitemapStorage: () => MemorySitemapStorage,
+  MemoryRedirectManager: () => MemoryRedirectManager,
+  MemoryProgressStorage: () => MemoryProgressStorage,
+  MemoryChangeTracker: () => MemoryChangeTracker,
+  IncrementalGenerator: () => IncrementalGenerator,
+  GenerateSitemapJob: () => GenerateSitemapJob,
+  GCPSitemapStorage: () => GCPSitemapStorage,
+  DiskSitemapStorage: () => DiskSitemapStorage,
+  DiffCalculator: () => DiffCalculator
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/core/ChangeTracker.ts
+class MemoryChangeTracker {
+  changes = [];
+  maxChanges;
+  constructor(options = {}) {
+    this.maxChanges = options.maxChanges || 1e5;
+  }
+  async track(change) {
+    this.changes.push(change);
+    if (this.changes.length > this.maxChanges) {
+      this.changes = this.changes.slice(-this.maxChanges);
+    }
+  }
+  async getChanges(since) {
+    if (!since) {
+      return [...this.changes];
+    }
+    return this.changes.filter((change) => change.timestamp >= since);
+  }
+  async getChangesByUrl(url) {
+    return this.changes.filter((change) => change.url === url);
+  }
+  async clear(since) {
+    if (!since) {
+      this.changes = [];
+      return;
+    }
+    this.changes = this.changes.filter((change) => change.timestamp < since);
+  }
+}
+
+class RedisChangeTracker {
+  client;
+  keyPrefix;
+  ttl;
+  constructor(options) {
+    this.client = options.client;
+    this.keyPrefix = options.keyPrefix || "sitemap:changes:";
+    this.ttl = options.ttl || 604800;
+  }
+  getKey(url) {
+    return `${this.keyPrefix}${url}`;
+  }
+  getListKey() {
+    return `${this.keyPrefix}list`;
+  }
+  async track(change) {
+    const key = this.getKey(change.url);
+    const listKey = this.getListKey();
+    const data = JSON.stringify(change);
+    await this.client.set(key, data, "EX", this.ttl);
+    const score = change.timestamp.getTime();
+    await this.client.zadd(listKey, score, change.url);
+    await this.client.expire(listKey, this.ttl);
+  }
+  async getChanges(since) {
+    try {
+      const listKey = this.getListKey();
+      const minScore = since ? since.getTime() : 0;
+      const urls = await this.client.zrangebyscore(listKey, minScore, "+inf");
+      const changes = [];
+      for (const url of urls) {
+        const key = this.getKey(url);
+        const data = await this.client.get(key);
+        if (data) {
+          const change = JSON.parse(data);
+          change.timestamp = new Date(change.timestamp);
+          changes.push(change);
+        }
+      }
+      return changes.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    } catch {
+      return [];
+    }
+  }
+  async getChangesByUrl(url) {
+    try {
+      const key = this.getKey(url);
+      const data = await this.client.get(key);
+      if (!data) {
+        return [];
+      }
+      const change = JSON.parse(data);
+      change.timestamp = new Date(change.timestamp);
+      return [change];
+    } catch {
+      return [];
+    }
+  }
+  async clear(since) {
+    try {
+      const listKey = this.getListKey();
+      if (!since) {
+        const urls = await this.client.zrange(listKey, 0, -1);
+        for (const url of urls) {
+          await this.client.del(this.getKey(url));
+        }
+        await this.client.del(listKey);
+      } else {
+        const maxScore = since.getTime();
+        const urls = await this.client.zrangebyscore(listKey, 0, maxScore);
+        for (const url of urls) {
+          await this.client.del(this.getKey(url));
+          await this.client.zrem(listKey, url);
+        }
+      }
+    } catch {}
+  }
+}
+// src/core/DiffCalculator.ts
+class DiffCalculator {
+  batchSize;
+  constructor(options = {}) {
+    this.batchSize = options.batchSize || 1e4;
+  }
+  calculate(oldEntries, newEntries) {
+    const oldMap = new Map;
+    const newMap = new Map;
+    for (const entry of oldEntries) {
+      oldMap.set(entry.url, entry);
+    }
+    for (const entry of newEntries) {
+      newMap.set(entry.url, entry);
+    }
+    const added = [];
+    const updated = [];
+    const removed = [];
+    for (const [url, newEntry] of newMap) {
+      const oldEntry = oldMap.get(url);
+      if (!oldEntry) {
+        added.push(newEntry);
+      } else if (this.hasChanged(oldEntry, newEntry)) {
+        updated.push(newEntry);
+      }
+    }
+    for (const [url] of oldMap) {
+      if (!newMap.has(url)) {
+        removed.push(url);
+      }
+    }
+    return { added, updated, removed };
+  }
+  async calculateBatch(oldEntries, newEntries) {
+    const oldMap = new Map;
+    const newMap = new Map;
+    for await (const entry of oldEntries) {
+      oldMap.set(entry.url, entry);
+    }
+    for await (const entry of newEntries) {
+      newMap.set(entry.url, entry);
+    }
+    return this.calculate(Array.from(oldMap.values()), Array.from(newMap.values()));
+  }
+  calculateFromChanges(baseEntries, changes) {
+    const entryMap = new Map;
+    for (const entry of baseEntries) {
+      entryMap.set(entry.url, entry);
+    }
+    for (const change of changes) {
+      if (change.type === "add" && change.entry) {
+        entryMap.set(change.url, change.entry);
+      } else if (change.type === "update" && change.entry) {
+        entryMap.set(change.url, change.entry);
+      } else if (change.type === "remove") {
+        entryMap.delete(change.url);
+      }
+    }
+    const newEntries = Array.from(entryMap.values());
+    return this.calculate(baseEntries, newEntries);
+  }
+  hasChanged(oldEntry, newEntry) {
+    if (oldEntry.lastmod !== newEntry.lastmod) {
+      return true;
+    }
+    if (oldEntry.changefreq !== newEntry.changefreq) {
+      return true;
+    }
+    if (oldEntry.priority !== newEntry.priority) {
+      return true;
+    }
+    const oldAlternates = JSON.stringify(oldEntry.alternates || []);
+    const newAlternates = JSON.stringify(newEntry.alternates || []);
+    if (oldAlternates !== newAlternates) {
+      return true;
+    }
+    return false;
+  }
+}
+// src/core/ShadowProcessor.ts
+class ShadowProcessor {
+  options;
+  shadowId;
+  operations = [];
+  constructor(options) {
+    this.options = options;
+    this.shadowId = `shadow-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+  }
+  async addOperation(operation) {
+    if (!this.options.enabled) {
+      await this.options.storage.write(operation.filename, operation.content);
+      return;
+    }
+    this.operations.push({
+      ...operation,
+      shadowId: operation.shadowId || this.shadowId
+    });
+    if (this.options.storage.writeShadow) {
+      await this.options.storage.writeShadow(operation.filename, operation.content, this.shadowId);
+    } else {
+      await this.options.storage.write(operation.filename, operation.content);
+    }
+  }
+  async commit() {
+    if (!this.options.enabled) {
+      return;
+    }
+    if (this.options.mode === "atomic") {
+      if (this.options.storage.commitShadow) {
+        await this.options.storage.commitShadow(this.shadowId);
+      }
+    } else {
+      for (const operation of this.operations) {
+        if (this.options.storage.commitShadow) {
+          await this.options.storage.commitShadow(operation.shadowId || this.shadowId);
+        }
+      }
+    }
+    this.operations = [];
+  }
+  async rollback() {
+    if (!this.options.enabled) {
+      return;
+    }
+    this.operations = [];
+  }
+  getShadowId() {
+    return this.shadowId;
+  }
+  getOperations() {
+    return [...this.operations];
+  }
+}
+
+// src/core/SitemapIndex.ts
+class SitemapIndex {
+  options;
+  entries = [];
+  constructor(options) {
+    this.options = { ...options };
+    if (this.options.baseUrl.endsWith("/")) {
+      this.options.baseUrl = this.options.baseUrl.slice(0, -1);
+    }
+  }
+  add(entry) {
+    if (typeof entry === "string") {
+      this.entries.push({ url: entry });
+    } else {
+      this.entries.push(entry);
+    }
+    return this;
+  }
+  addAll(entries) {
+    for (const entry of entries) {
+      this.add(entry);
+    }
+    return this;
+  }
+  toXML() {
+    const { baseUrl, pretty } = this.options;
+    let xml = `<?xml version="1.0" encoding="UTF-8"?>
+`;
+    xml += `<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+`;
+    const indent = pretty ? "  " : "";
+    const subIndent = pretty ? "    " : "";
+    const nl = pretty ? `
+` : "";
+    for (const entry of this.entries) {
+      let loc = entry.url;
+      if (!loc.startsWith("http")) {
+        if (!loc.startsWith("/")) {
+          loc = `/${loc}`;
+        }
+        loc = baseUrl + loc;
+      }
+      xml += `${indent}<sitemap>${nl}`;
+      xml += `${subIndent}<loc>${this.escape(loc)}</loc>${nl}`;
+      if (entry.lastmod) {
+        const date = entry.lastmod instanceof Date ? entry.lastmod : new Date(entry.lastmod);
+        xml += `${subIndent}<lastmod>${date.toISOString().split("T")[0]}</lastmod>${nl}`;
+      }
+      xml += `${indent}</sitemap>${nl}`;
+    }
+    xml += `</sitemapindex>`;
+    return xml;
+  }
+  escape(str) {
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  }
+}
+
+// src/core/SitemapStream.ts
+class SitemapStream {
+  options;
+  entries = [];
+  constructor(options) {
+    this.options = { ...options };
+    if (this.options.baseUrl.endsWith("/")) {
+      this.options.baseUrl = this.options.baseUrl.slice(0, -1);
+    }
+  }
+  add(entry) {
+    if (typeof entry === "string") {
+      this.entries.push({ url: entry });
+    } else {
+      this.entries.push(entry);
+    }
+    return this;
+  }
+  addAll(entries) {
+    for (const entry of entries) {
+      this.add(entry);
+    }
+    return this;
+  }
+  toXML() {
+    const { baseUrl, pretty } = this.options;
+    let xml = `<?xml version="1.0" encoding="UTF-8"?>
+`;
+    xml += `<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"`;
+    if (this.hasImages()) {
+      xml += ` xmlns:image="http://www.google.com/schemas/sitemap-image/1.1"`;
+    }
+    if (this.hasVideos()) {
+      xml += ` xmlns:video="http://www.google.com/schemas/sitemap-video/1.1"`;
+    }
+    if (this.hasNews()) {
+      xml += ` xmlns:news="http://www.google.com/schemas/sitemap-news/0.9"`;
+    }
+    if (this.hasAlternates()) {
+      xml += ` xmlns:xhtml="http://www.w3.org/1999/xhtml"`;
+    }
+    xml += `>
+`;
+    for (const entry of this.entries) {
+      xml += this.renderUrl(entry, baseUrl, pretty);
+    }
+    xml += `</urlset>`;
+    return xml;
+  }
+  renderUrl(entry, baseUrl, pretty) {
+    const indent = pretty ? "  " : "";
+    const subIndent = pretty ? "    " : "";
+    const nl = pretty ? `
+` : "";
+    let loc = entry.url;
+    if (!loc.startsWith("http")) {
+      if (!loc.startsWith("/")) {
+        loc = `/${loc}`;
+      }
+      loc = baseUrl + loc;
+    }
+    let item = `${indent}<url>${nl}`;
+    item += `${subIndent}<loc>${this.escape(loc)}</loc>${nl}`;
+    if (entry.lastmod) {
+      const date = entry.lastmod instanceof Date ? entry.lastmod : new Date(entry.lastmod);
+      item += `${subIndent}<lastmod>${date.toISOString().split("T")[0]}</lastmod>${nl}`;
+    }
+    if (entry.changefreq) {
+      item += `${subIndent}<changefreq>${entry.changefreq}</changefreq>${nl}`;
+    }
+    if (entry.priority !== undefined) {
+      item += `${subIndent}<priority>${entry.priority.toFixed(1)}</priority>${nl}`;
+    }
+    if (entry.alternates) {
+      for (const alt of entry.alternates) {
+        let altLoc = alt.url;
+        if (!altLoc.startsWith("http")) {
+          if (!altLoc.startsWith("/")) {
+            altLoc = `/${altLoc}`;
+          }
+          altLoc = baseUrl + altLoc;
+        }
+        item += `${subIndent}<xhtml:link rel="alternate" hreflang="${alt.lang}" href="${this.escape(altLoc)}"/>${nl}`;
+      }
+    }
+    if (entry.redirect?.canonical) {
+      let canonicalUrl = entry.redirect.canonical;
+      if (!canonicalUrl.startsWith("http")) {
+        if (!canonicalUrl.startsWith("/")) {
+          canonicalUrl = `/${canonicalUrl}`;
+        }
+        canonicalUrl = baseUrl + canonicalUrl;
+      }
+      item += `${subIndent}<xhtml:link rel="canonical" href="${this.escape(canonicalUrl)}"/>${nl}`;
+    }
+    if (entry.redirect && !entry.redirect.canonical) {
+      item += `${subIndent}<!-- Redirect: ${entry.redirect.from} → ${entry.redirect.to} (${entry.redirect.type}) -->${nl}`;
+    }
+    if (entry.images) {
+      for (const img of entry.images) {
+        let loc2 = img.loc;
+        if (!loc2.startsWith("http")) {
+          if (!loc2.startsWith("/")) {
+            loc2 = `/${loc2}`;
+          }
+          loc2 = baseUrl + loc2;
+        }
+        item += `${subIndent}<image:image>${nl}`;
+        item += `${subIndent}  <image:loc>${this.escape(loc2)}</image:loc>${nl}`;
+        if (img.title) {
+          item += `${subIndent}  <image:title>${this.escape(img.title)}</image:title>${nl}`;
+        }
+        if (img.caption) {
+          item += `${subIndent}  <image:caption>${this.escape(img.caption)}</image:caption>${nl}`;
+        }
+        if (img.geo_location) {
+          item += `${subIndent}  <image:geo_location>${this.escape(img.geo_location)}</image:geo_location>${nl}`;
+        }
+        if (img.license) {
+          item += `${subIndent}  <image:license>${this.escape(img.license)}</image:license>${nl}`;
+        }
+        item += `${subIndent}</image:image>${nl}`;
+      }
+    }
+    if (entry.videos) {
+      for (const video of entry.videos) {
+        item += `${subIndent}<video:video>${nl}`;
+        item += `${subIndent}  <video:thumbnail_loc>${this.escape(video.thumbnail_loc)}</video:thumbnail_loc>${nl}`;
+        item += `${subIndent}  <video:title>${this.escape(video.title)}</video:title>${nl}`;
+        item += `${subIndent}  <video:description>${this.escape(video.description)}</video:description>${nl}`;
+        if (video.content_loc) {
+          item += `${subIndent}  <video:content_loc>${this.escape(video.content_loc)}</video:content_loc>${nl}`;
+        }
+        if (video.player_loc) {
+          item += `${subIndent}  <video:player_loc>${this.escape(video.player_loc)}</video:player_loc>${nl}`;
+        }
+        if (video.duration) {
+          item += `${subIndent}  <video:duration>${video.duration}</video:duration>${nl}`;
+        }
+        if (video.view_count) {
+          item += `${subIndent}  <video:view_count>${video.view_count}</video:view_count>${nl}`;
+        }
+        if (video.publication_date) {
+          const pubDate = video.publication_date instanceof Date ? video.publication_date : new Date(video.publication_date);
+          item += `${subIndent}  <video:publication_date>${pubDate.toISOString()}</video:publication_date>${nl}`;
+        }
+        if (video.family_friendly) {
+          item += `${subIndent}  <video:family_friendly>${video.family_friendly}</video:family_friendly>${nl}`;
+        }
+        if (video.tag) {
+          for (const tag of video.tag) {
+            item += `${subIndent}  <video:tag>${this.escape(tag)}</video:tag>${nl}`;
+          }
+        }
+        item += `${subIndent}</video:video>${nl}`;
+      }
+    }
+    if (entry.news) {
+      item += `${subIndent}<news:news>${nl}`;
+      item += `${subIndent}  <news:publication>${nl}`;
+      item += `${subIndent}    <news:name>${this.escape(entry.news.publication.name)}</news:name>${nl}`;
+      item += `${subIndent}    <news:language>${this.escape(entry.news.publication.language)}</news:language>${nl}`;
+      item += `${subIndent}  </news:publication>${nl}`;
+      const pubDate = entry.news.publication_date instanceof Date ? entry.news.publication_date : new Date(entry.news.publication_date);
+      item += `${subIndent}  <news:publication_date>${pubDate.toISOString()}</news:publication_date>${nl}`;
+      item += `${subIndent}  <news:title>${this.escape(entry.news.title)}</news:title>${nl}`;
+      if (entry.news.genres) {
+        item += `${subIndent}  <news:genres>${this.escape(entry.news.genres)}</news:genres>${nl}`;
+      }
+      if (entry.news.keywords) {
+        item += `${subIndent}  <news:keywords>${entry.news.keywords.map((k) => this.escape(k)).join(", ")}</news:keywords>${nl}`;
+      }
+      item += `${subIndent}</news:news>${nl}`;
+    }
+    item += `${indent}</url>${nl}`;
+    return item;
+  }
+  hasImages() {
+    return this.entries.some((e) => e.images && e.images.length > 0);
+  }
+  hasVideos() {
+    return this.entries.some((e) => e.videos && e.videos.length > 0);
+  }
+  hasNews() {
+    return this.entries.some((e) => !!e.news);
+  }
+  hasAlternates() {
+    return this.entries.some((e) => e.alternates && e.alternates.length > 0);
+  }
+  escape(str) {
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  }
+}
+
+// src/core/SitemapGenerator.ts
+class SitemapGenerator {
+  options;
+  shadowProcessor = null;
+  constructor(options) {
+    this.options = {
+      maxEntriesPerFile: 50000,
+      filename: "sitemap.xml",
+      ...options
+    };
+    if (this.options.shadow?.enabled) {
+      this.shadowProcessor = new ShadowProcessor({
+        storage: this.options.storage,
+        mode: this.options.shadow.mode,
+        enabled: true
+      });
+    }
+  }
+  async run() {
+    let shardIndex = 1;
+    let currentCount = 0;
+    let currentStream = new SitemapStream({
+      baseUrl: this.options.baseUrl,
+      pretty: this.options.pretty
+    });
+    const index = new SitemapIndex({
+      baseUrl: this.options.baseUrl,
+      pretty: this.options.pretty
+    });
+    const flushShard = async () => {
+      if (currentCount === 0) {
+        return;
+      }
+      const baseName = this.options.filename?.replace(/\.xml$/, "");
+      const filename = `${baseName}-${shardIndex}.xml`;
+      const xml = currentStream.toXML();
+      if (this.shadowProcessor) {
+        await this.shadowProcessor.addOperation({ filename, content: xml });
+      } else {
+        await this.options.storage.write(filename, xml);
+      }
+      const url = this.options.storage.getUrl(filename);
+      index.add({
+        url,
+        lastmod: new Date
+      });
+      shardIndex++;
+      currentCount = 0;
+      currentStream = new SitemapStream({
+        baseUrl: this.options.baseUrl,
+        pretty: this.options.pretty
+      });
+    };
+    const { providers, maxEntriesPerFile } = this.options;
+    for (const provider of providers) {
+      const entries = await provider.getEntries();
+      const processEntry = async (entry) => {
+        currentStream.add(entry);
+        currentCount++;
+        if (currentCount >= maxEntriesPerFile) {
+          await flushShard();
+        }
+      };
+      if (Array.isArray(entries)) {
+        for (const entry of entries) {
+          await processEntry(entry);
+        }
+      } else if (entries && typeof entries[Symbol.asyncIterator] === "function") {
+        for await (const entry of entries) {
+          await processEntry(entry);
+        }
+      }
+    }
+    await flushShard();
+    const indexXml = index.toXML();
+    if (this.shadowProcessor) {
+      await this.shadowProcessor.addOperation({
+        filename: this.options.filename,
+        content: indexXml
+      });
+      await this.shadowProcessor.commit();
+    } else {
+      await this.options.storage.write(this.options.filename, indexXml);
+    }
+  }
+  getShadowProcessor() {
+    return this.shadowProcessor;
+  }
+}
+
+// src/core/IncrementalGenerator.ts
+class IncrementalGenerator {
+  options;
+  changeTracker;
+  diffCalculator;
+  generator;
+  constructor(options) {
+    this.options = options;
+    this.changeTracker = options.changeTracker;
+    this.diffCalculator = options.diffCalculator || new DiffCalculator;
+    this.generator = new SitemapGenerator(options);
+  }
+  async generateFull() {
+    await this.generator.run();
+    if (this.options.autoTrack) {
+      const { providers } = this.options;
+      for (const provider of providers) {
+        const entries = await provider.getEntries();
+        const entriesArray = Array.isArray(entries) ? entries : await this.toArray(entries);
+        for (const entry of entriesArray) {
+          await this.changeTracker.track({
+            type: "add",
+            url: entry.url,
+            entry,
+            timestamp: new Date
+          });
+        }
+      }
+    }
+  }
+  async generateIncremental(since) {
+    const changes = await this.changeTracker.getChanges(since);
+    if (changes.length === 0) {
+      return;
+    }
+    const baseEntries = await this.loadBaseEntries();
+    const diff = this.diffCalculator.calculateFromChanges(baseEntries, changes);
+    await this.generateDiff(diff);
+  }
+  async trackChange(change) {
+    await this.changeTracker.track(change);
+  }
+  async getChanges(since) {
+    return this.changeTracker.getChanges(since);
+  }
+  async loadBaseEntries() {
+    const entries = [];
+    const { providers } = this.options;
+    for (const provider of providers) {
+      const providerEntries = await provider.getEntries();
+      const entriesArray = Array.isArray(providerEntries) ? providerEntries : await this.toArray(providerEntries);
+      entries.push(...entriesArray);
+    }
+    return entries;
+  }
+  async generateDiff(_diff) {
+    await this.generator.run();
+  }
+  async toArray(iterable) {
+    const array = [];
+    for await (const item of iterable) {
+      array.push(item);
+    }
+    return array;
+  }
+}
+// src/core/ProgressTracker.ts
+class ProgressTracker {
+  storage;
+  updateInterval;
+  currentProgress = null;
+  updateTimer = null;
+  constructor(options) {
+    this.storage = options.storage;
+    this.updateInterval = options.updateInterval || 1000;
+  }
+  async init(jobId, total) {
+    this.currentProgress = {
+      jobId,
+      status: "pending",
+      total,
+      processed: 0,
+      percentage: 0,
+      startTime: new Date
+    };
+    await this.storage.set(jobId, this.currentProgress);
+  }
+  async update(processed, status) {
+    if (!this.currentProgress) {
+      return;
+    }
+    this.currentProgress.processed = processed;
+    this.currentProgress.percentage = Math.round(processed / this.currentProgress.total * 100);
+    if (status) {
+      this.currentProgress.status = status;
+    } else if (this.currentProgress.status === "pending") {
+      this.currentProgress.status = "processing";
+    }
+    if (!this.updateTimer) {
+      this.updateTimer = setInterval(() => {
+        this.flush().catch((err) => {
+          console.error("[ProgressTracker] Failed to flush progress:", err);
+        });
+      }, this.updateInterval);
+    }
+  }
+  async complete() {
+    if (!this.currentProgress) {
+      return;
+    }
+    this.currentProgress.status = "completed";
+    this.currentProgress.endTime = new Date;
+    this.currentProgress.percentage = 100;
+    await this.flush();
+    this.stop();
+  }
+  async fail(error) {
+    if (!this.currentProgress) {
+      return;
+    }
+    this.currentProgress.status = "failed";
+    this.currentProgress.endTime = new Date;
+    this.currentProgress.error = error;
+    await this.flush();
+    this.stop();
+  }
+  async flush() {
+    if (!this.currentProgress) {
+      return;
+    }
+    await this.storage.update(this.currentProgress.jobId, {
+      processed: this.currentProgress.processed,
+      percentage: this.currentProgress.percentage,
+      status: this.currentProgress.status,
+      endTime: this.currentProgress.endTime,
+      error: this.currentProgress.error
+    });
+  }
+  stop() {
+    if (this.updateTimer) {
+      clearInterval(this.updateTimer);
+      this.updateTimer = null;
+    }
+  }
+  getCurrentProgress() {
+    return this.currentProgress ? { ...this.currentProgress } : null;
+  }
+}
+// src/helpers/I18nSitemap.ts
+function generateI18nEntries(path, locales, baseUrl = "", options = {}) {
+  const cleanPath = path.startsWith("/") ? path : `/${path}`;
+  const cleanBaseUrl = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  const alternates = locales.map((locale) => {
+    return {
+      lang: locale,
+      url: `${cleanBaseUrl}/${locale}${cleanPath}`
+    };
+  });
+  return locales.map((locale) => {
+    return {
+      ...options,
+      url: `${cleanBaseUrl}/${locale}${cleanPath}`,
+      alternates
+    };
+  });
+}
+// src/jobs/GenerateSitemapJob.ts
+var import_stream = require("@gravito/stream");
+class GenerateSitemapJob extends import_stream.Job {
+  options;
+  generator;
+  totalEntries = 0;
+  processedEntries = 0;
+  constructor(options) {
+    super();
+    this.options = options;
+    this.generator = new SitemapGenerator(options.generatorOptions);
+  }
+  async handle() {
+    const { progressTracker, shadowProcessor, onProgress, onComplete, onError } = this.options;
+    try {
+      if (progressTracker) {
+        const total = await this.calculateTotal();
+        await progressTracker.init(this.options.jobId, total);
+        this.totalEntries = total;
+      }
+      await this.generateWithProgress();
+      if (shadowProcessor) {
+        await shadowProcessor.commit();
+      }
+      if (progressTracker) {
+        await progressTracker.complete();
+      }
+      if (onComplete) {
+        onComplete();
+      }
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (progressTracker) {
+        await progressTracker.fail(err.message);
+      }
+      if (onError) {
+        onError(err);
+      }
+      throw err;
+    }
+  }
+  async calculateTotal() {
+    let total = 0;
+    const { providers } = this.options.generatorOptions;
+    for (const provider of providers) {
+      const entries = await provider.getEntries();
+      if (Array.isArray(entries)) {
+        total += entries.length;
+      } else if (entries && typeof entries[Symbol.asyncIterator] === "function") {
+        for await (const _ of entries) {
+          total++;
+        }
+      }
+    }
+    return total;
+  }
+  async generateWithProgress() {
+    const { progressTracker, shadowProcessor, onProgress } = this.options;
+    const {
+      providers,
+      maxEntriesPerFile = 50000,
+      storage,
+      baseUrl,
+      pretty,
+      filename
+    } = this.options.generatorOptions;
+    await this.generator.run();
+    this.processedEntries = this.totalEntries;
+    if (progressTracker) {
+      await progressTracker.update(this.processedEntries, "processing");
+    }
+    if (onProgress) {
+      onProgress({
+        processed: this.processedEntries,
+        total: this.totalEntries,
+        percentage: this.totalEntries > 0 ? Math.round(this.processedEntries / this.totalEntries * 100) : 100
+      });
+    }
+  }
+}
+// src/OrbitSitemap.ts
+var import_node_crypto = require("node:crypto");
+
+// src/redirect/RedirectHandler.ts
+class RedirectHandler {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async processEntries(entries) {
+    const { manager, strategy, followChains, maxChainLength } = this.options;
+    const _processedEntries = [];
+    const redirectMap = new Map;
+    for (const entry of entries) {
+      const redirectTarget = await manager.resolve(entry.url, followChains, maxChainLength);
+      if (redirectTarget && entry.url !== redirectTarget) {
+        redirectMap.set(entry.url, {
+          from: entry.url,
+          to: redirectTarget,
+          type: 301
+        });
+      }
+    }
+    switch (strategy) {
+      case "remove_old_add_new":
+        return this.handleRemoveOldAddNew(entries, redirectMap);
+      case "keep_relation":
+        return this.handleKeepRelation(entries, redirectMap);
+      case "update_url":
+        return this.handleUpdateUrl(entries, redirectMap);
+      case "dual_mark":
+        return this.handleDualMark(entries, redirectMap);
+      default:
+        return entries;
+    }
+  }
+  handleRemoveOldAddNew(entries, redirectMap) {
+    const processed = [];
+    const redirectedUrls = new Set;
+    for (const entry of entries) {
+      const redirect = redirectMap.get(entry.url);
+      if (redirect) {
+        redirectedUrls.add(entry.url);
+        processed.push({
+          ...entry,
+          url: redirect.to,
+          redirect: {
+            from: redirect.from,
+            to: redirect.to,
+            type: redirect.type
+          }
+        });
+      } else if (!redirectedUrls.has(entry.url)) {
+        processed.push(entry);
+      }
+    }
+    return processed;
+  }
+  handleKeepRelation(entries, redirectMap) {
+    const processed = [];
+    for (const entry of entries) {
+      const redirect = redirectMap.get(entry.url);
+      if (redirect) {
+        processed.push({
+          ...entry,
+          redirect: {
+            from: redirect.from,
+            to: redirect.to,
+            type: redirect.type,
+            canonical: redirect.to
+          }
+        });
+      } else {
+        processed.push(entry);
+      }
+    }
+    return processed;
+  }
+  handleUpdateUrl(entries, redirectMap) {
+    return entries.map((entry) => {
+      const redirect = redirectMap.get(entry.url);
+      if (redirect) {
+        return {
+          ...entry,
+          url: redirect.to,
+          redirect: {
+            from: redirect.from,
+            to: redirect.to,
+            type: redirect.type
+          }
+        };
+      }
+      return entry;
+    });
+  }
+  handleDualMark(entries, redirectMap) {
+    const processed = [];
+    const addedUrls = new Set;
+    for (const entry of entries) {
+      const redirect = redirectMap.get(entry.url);
+      if (redirect) {
+        processed.push({
+          ...entry,
+          redirect: {
+            from: redirect.from,
+            to: redirect.to,
+            type: redirect.type
+          }
+        });
+        if (!addedUrls.has(redirect.to)) {
+          processed.push({
+            ...entry,
+            url: redirect.to,
+            redirect: {
+              from: redirect.from,
+              to: redirect.to,
+              type: redirect.type
+            }
+          });
+          addedUrls.add(redirect.to);
+        }
+      } else {
+        processed.push(entry);
+      }
+    }
+    return processed;
+  }
+}
+
+// src/storage/MemorySitemapStorage.ts
+class MemorySitemapStorage {
+  baseUrl;
+  files = new Map;
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  async write(filename, content) {
+    this.files.set(filename, content);
+  }
+  async read(filename) {
+    return this.files.get(filename) || null;
+  }
+  async exists(filename) {
+    return this.files.has(filename);
+  }
+  getUrl(filename) {
+    const base = this.baseUrl.endsWith("/") ? this.baseUrl.slice(0, -1) : this.baseUrl;
+    const file = filename.startsWith("/") ? filename.slice(1) : filename;
+    return `${base}/${file}`;
+  }
+}
+
+// src/OrbitSitemap.ts
+class OrbitSitemap {
+  options;
+  mode;
+  constructor(mode, options) {
+    this.mode = mode;
+    this.options = options;
+  }
+  static dynamic(options) {
+    return new OrbitSitemap("dynamic", {
+      path: "/sitemap.xml",
+      ...options
+    });
+  }
+  static static(options) {
+    return new OrbitSitemap("static", {
+      filename: "sitemap.xml",
+      ...options
+    });
+  }
+  install(core) {
+    if (this.mode === "dynamic") {
+      this.installDynamic(core);
+    } else {
+      console.log("[OrbitSitemap] Static mode configured. Use generate() to build sitemaps.");
+    }
+  }
+  installDynamic(core) {
+    const opts = this.options;
+    const storage = opts.storage ?? new MemorySitemapStorage(opts.baseUrl);
+    const indexFilename = opts.path?.split("/").pop() ?? "sitemap.xml";
+    const baseDir = opts.path ? opts.path.substring(0, opts.path.lastIndexOf("/")) : undefined;
+    const handler = async (ctx) => {
+      const reqPath = ctx.req.path;
+      const filename = reqPath.split("/").pop() || indexFilename;
+      const isIndex = filename === indexFilename;
+      let content = await storage.read(filename);
+      if (!content && isIndex) {
+        if (opts.lock) {
+          const locked = await opts.lock.acquire(filename, 60);
+          if (!locked) {
+            return ctx.text("Generating...", 503, { "Retry-After": "5" });
+          }
+        }
+        try {
+          const generator = new SitemapGenerator({
+            ...opts,
+            storage,
+            filename: indexFilename
+          });
+          await generator.run();
+        } finally {
+          if (opts.lock) {
+            await opts.lock.release(filename);
+          }
+        }
+        content = await storage.read(filename);
+      }
+      if (!content) {
+        return ctx.text("Not Found", 404);
+      }
+      return ctx.body(content, 200, {
+        "Content-Type": "application/xml",
+        "Cache-Control": opts.cacheSeconds ? `public, max-age=${opts.cacheSeconds}` : "no-cache"
+      });
+    };
+    core.router.get(opts.path, handler);
+    const basename = indexFilename.replace(".xml", "");
+    const shardRoute = `${baseDir}/${basename}-:shard.xml`;
+    core.router.get(shardRoute, handler);
+  }
+  async generate() {
+    if (this.mode !== "static") {
+      throw new Error("generate() can only be called in static mode");
+    }
+    const opts = this.options;
+    let storage = opts.storage;
+    if (!storage) {
+      const { DiskSitemapStorage: DiskSitemapStorage2 } = await Promise.resolve().then(() => (init_DiskSitemapStorage(), exports_DiskSitemapStorage));
+      storage = new DiskSitemapStorage2(opts.outDir, opts.baseUrl);
+    }
+    let providers = opts.providers;
+    if (opts.redirect?.enabled && opts.redirect.manager) {
+      const handler = new RedirectHandler({
+        manager: opts.redirect.manager,
+        strategy: opts.redirect.strategy || "remove_old_add_new",
+        followChains: opts.redirect.followChains,
+        maxChainLength: opts.redirect.maxChainLength
+      });
+      providers = opts.providers.map((provider) => ({
+        getEntries: async () => {
+          const entries = await provider.getEntries();
+          const entriesArray = Array.isArray(entries) ? entries : await this.toArray(entries);
+          return handler.processEntries(entriesArray);
+        }
+      }));
+    }
+    const generator = new SitemapGenerator({
+      ...opts,
+      providers,
+      storage,
+      filename: opts.filename || "sitemap.xml",
+      shadow: opts.shadow
+    });
+    await generator.run();
+    console.log(`[OrbitSitemap] Generated sitemap in ${opts.outDir}`);
+  }
+  async generateIncremental(since) {
+    if (this.mode !== "static") {
+      throw new Error("generateIncremental() can only be called in static mode");
+    }
+    const opts = this.options;
+    if (!opts.incremental?.enabled || !opts.incremental.changeTracker) {
+      throw new Error("Incremental generation is not enabled or changeTracker is not configured");
+    }
+    let storage = opts.storage;
+    if (!storage) {
+      const { DiskSitemapStorage: DiskSitemapStorage2 } = await Promise.resolve().then(() => (init_DiskSitemapStorage(), exports_DiskSitemapStorage));
+      storage = new DiskSitemapStorage2(opts.outDir, opts.baseUrl);
+    }
+    const incrementalGenerator = new IncrementalGenerator({
+      ...opts,
+      storage,
+      filename: opts.filename || "sitemap.xml",
+      changeTracker: opts.incremental.changeTracker,
+      autoTrack: opts.incremental.autoTrack,
+      shadow: opts.shadow
+    });
+    await incrementalGenerator.generateIncremental(since);
+    console.log(`[OrbitSitemap] Generated incremental sitemap in ${opts.outDir}`);
+  }
+  async generateAsync(options) {
+    if (this.mode !== "static") {
+      throw new Error("generateAsync() can only be called in static mode");
+    }
+    const opts = this.options;
+    const jobId = import_node_crypto.randomUUID();
+    let storage = opts.storage;
+    if (!storage) {
+      const { DiskSitemapStorage: DiskSitemapStorage2 } = await Promise.resolve().then(() => (init_DiskSitemapStorage(), exports_DiskSitemapStorage));
+      storage = new DiskSitemapStorage2(opts.outDir, opts.baseUrl);
+    }
+    let providers = opts.providers;
+    if (opts.redirect?.enabled && opts.redirect.manager) {
+      const handler = new RedirectHandler({
+        manager: opts.redirect.manager,
+        strategy: opts.redirect.strategy || "remove_old_add_new",
+        followChains: opts.redirect.followChains,
+        maxChainLength: opts.redirect.maxChainLength
+      });
+      providers = opts.providers.map((provider) => ({
+        getEntries: async () => {
+          const entries = await provider.getEntries();
+          const entriesArray = Array.isArray(entries) ? entries : await this.toArray(entries);
+          return handler.processEntries(entriesArray);
+        }
+      }));
+    }
+    let progressTracker;
+    if (opts.progressStorage) {
+      progressTracker = new ProgressTracker({
+        storage: opts.progressStorage
+      });
+    }
+    const job = new GenerateSitemapJob({
+      jobId,
+      generatorOptions: {
+        ...opts,
+        providers,
+        storage,
+        filename: opts.filename || "sitemap.xml",
+        shadow: opts.shadow
+      },
+      progressTracker,
+      onProgress: options?.onProgress,
+      onComplete: options?.onComplete,
+      onError: options?.onError
+    });
+    job.handle().catch((error) => {
+      if (options?.onError) {
+        options.onError(error);
+      }
+    });
+    return jobId;
+  }
+  installApiEndpoints(core, basePath = "/admin/sitemap") {
+    const opts = this.options;
+    core.router.post(`${basePath}/generate`, async (ctx) => {
+      try {
+        const body = await ctx.req.json().catch(() => ({}));
+        const jobId = await this.generateAsync({
+          incremental: body.incremental,
+          since: body.since ? new Date(body.since) : undefined
+        });
+        return ctx.json({ jobId, status: "started" });
+      } catch (error) {
+        return ctx.json({ error: error instanceof Error ? error.message : String(error) }, 500);
+      }
+    });
+    core.router.get(`${basePath}/status/:jobId`, async (ctx) => {
+      const jobId = ctx.req.param("jobId");
+      if (!opts.progressStorage) {
+        return ctx.json({ error: "Progress tracking is not enabled" }, 400);
+      }
+      const progress = await opts.progressStorage.get(jobId);
+      if (!progress) {
+        return ctx.json({ error: "Job not found" }, 404);
+      }
+      return ctx.json(progress);
+    });
+    core.router.get(`${basePath}/history`, async (ctx) => {
+      if (!opts.progressStorage) {
+        return ctx.json({ error: "Progress tracking is not enabled" }, 400);
+      }
+      const limit = Number.parseInt(ctx.req.query("limit") || "10", 10);
+      const history = await opts.progressStorage.list(limit);
+      return ctx.json(history);
+    });
+  }
+  async toArray(iterable) {
+    const array = [];
+    for await (const item of iterable) {
+      array.push(item);
+    }
+    return array;
+  }
+}
+// src/providers/RouteScanner.ts
+function matchGlob(str, pattern) {
+  const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(str);
+}
+
+class RouteScanner {
+  router;
+  options;
+  constructor(router, options = {}) {
+    this.router = router;
+    this.options = {
+      defaultChangefreq: "weekly",
+      defaultPriority: 0.5,
+      ...options
+    };
+  }
+  getEntries() {
+    const entries = [];
+    const routes = this.extractRoutes(this.router);
+    for (const route of routes) {
+      if (route.method !== "GET") {
+        continue;
+      }
+      if (route.path.includes(":") || route.path.includes("*")) {
+        continue;
+      }
+      if (this.shouldInclude(route.path)) {
+        entries.push({
+          url: route.path,
+          changefreq: this.options.defaultChangefreq,
+          priority: this.options.defaultPriority
+        });
+      }
+    }
+    return entries;
+  }
+  extractRoutes(router) {
+    const routes = [];
+    if (router.routes) {
+      return router.routes;
+    }
+    return routes;
+  }
+  shouldInclude(path2) {
+    if (this.options.exclude) {
+      for (const pattern of this.options.exclude) {
+        if (matchGlob(path2, pattern)) {
+          return false;
+        }
+      }
+    }
+    if (this.options.include) {
+      let matched = false;
+      for (const pattern of this.options.include) {
+        if (matchGlob(path2, pattern)) {
+          matched = true;
+          break;
+        }
+      }
+      return matched;
+    }
+    return true;
+  }
+}
+function routeScanner(router, options) {
+  return new RouteScanner(router, options);
+}
+// src/redirect/RedirectDetector.ts
+class RedirectDetector {
+  options;
+  cache = new Map;
+  constructor(options) {
+    this.options = options;
+  }
+  async detect(url) {
+    if (this.options.autoDetect?.cache) {
+      const cached = this.cache.get(url);
+      if (cached && cached.expires > Date.now()) {
+        return cached.rule;
+      }
+    }
+    let rule = null;
+    if (this.options.database?.enabled) {
+      rule = await this.detectFromDatabase(url);
+      if (rule) {
+        this.cacheResult(url, rule);
+        return rule;
+      }
+    }
+    if (this.options.config?.enabled) {
+      rule = await this.detectFromConfig(url);
+      if (rule) {
+        this.cacheResult(url, rule);
+        return rule;
+      }
+    }
+    if (this.options.autoDetect?.enabled) {
+      rule = await this.detectAuto(url);
+      this.cacheResult(url, rule);
+      return rule;
+    }
+    return null;
+  }
+  async detectBatch(urls) {
+    const results = new Map;
+    const maxConcurrent = this.options.autoDetect?.maxConcurrent || 10;
+    const batches = [];
+    for (let i = 0;i < urls.length; i += maxConcurrent) {
+      batches.push(urls.slice(i, i + maxConcurrent));
+    }
+    for (const batch of batches) {
+      const promises = batch.map((url) => this.detect(url).then((rule) => {
+        results.set(url, rule);
+      }));
+      await Promise.all(promises);
+    }
+    return results;
+  }
+  async detectFromDatabase(url) {
+    const { database } = this.options;
+    if (!database?.enabled) {
+      return null;
+    }
+    try {
+      const { connection, table, columns } = database;
+      const query = `SELECT ${columns.from}, ${columns.to}, ${columns.type} FROM ${table} WHERE ${columns.from} = ? LIMIT 1`;
+      const results = await connection.query(query, [url]);
+      if (results.length === 0) {
+        return null;
+      }
+      const row = results[0];
+      return {
+        from: row[columns.from],
+        to: row[columns.to],
+        type: parseInt(row[columns.type], 10)
+      };
+    } catch {
+      return null;
+    }
+  }
+  async detectFromConfig(url) {
+    const { config } = this.options;
+    if (!config?.enabled) {
+      return null;
+    }
+    try {
+      const fs2 = await import("node:fs/promises");
+      const data = await fs2.readFile(config.path, "utf-8");
+      const redirects = JSON.parse(data);
+      const rule = redirects.find((r) => r.from === url);
+      return rule || null;
+    } catch {
+      return null;
+    }
+  }
+  async detectAuto(url) {
+    const { autoDetect, baseUrl } = this.options;
+    if (!autoDetect?.enabled) {
+      return null;
+    }
+    try {
+      const fullUrl = url.startsWith("http") ? url : `${baseUrl}${url}`;
+      const timeout = autoDetect.timeout || 5000;
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      try {
+        const response = await fetch(fullUrl, {
+          method: "HEAD",
+          signal: controller.signal,
+          redirect: "manual"
+        });
+        clearTimeout(timeoutId);
+        if (response.status === 301 || response.status === 302) {
+          const location = response.headers.get("Location");
+          if (location) {
+            return {
+              from: url,
+              to: location,
+              type: response.status
+            };
+          }
+        }
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error.name !== "AbortError") {
+          throw error;
+        }
+      }
+    } catch {}
+    return null;
+  }
+  cacheResult(url, rule) {
+    if (!this.options.autoDetect?.cache) {
+      return;
+    }
+    const ttl = (this.options.autoDetect.cacheTtl || 3600) * 1000;
+    this.cache.set(url, {
+      rule,
+      expires: Date.now() + ttl
+    });
+  }
+}
+// src/redirect/RedirectManager.ts
+class MemoryRedirectManager {
+  rules = new Map;
+  maxRules;
+  constructor(options = {}) {
+    this.maxRules = options.maxRules || 1e5;
+  }
+  async register(redirect) {
+    this.rules.set(redirect.from, redirect);
+    if (this.rules.size > this.maxRules) {
+      const firstKey = this.rules.keys().next().value;
+      if (firstKey) {
+        this.rules.delete(firstKey);
+      }
+    }
+  }
+  async registerBatch(redirects) {
+    for (const redirect of redirects) {
+      await this.register(redirect);
+    }
+  }
+  async get(from) {
+    return this.rules.get(from) || null;
+  }
+  async getAll() {
+    return Array.from(this.rules.values());
+  }
+  async resolve(url, followChains = false, maxChainLength = 5) {
+    let current = url;
+    let chainLength = 0;
+    while (chainLength < maxChainLength) {
+      const rule = await this.get(current);
+      if (!rule) {
+        return current;
+      }
+      current = rule.to;
+      chainLength++;
+      if (!followChains) {
+        return current;
+      }
+    }
+    return current;
+  }
+}
+
+class RedisRedirectManager {
+  client;
+  keyPrefix;
+  ttl;
+  constructor(options) {
+    this.client = options.client;
+    this.keyPrefix = options.keyPrefix || "sitemap:redirects:";
+    this.ttl = options.ttl;
+  }
+  getKey(from) {
+    return `${this.keyPrefix}${from}`;
+  }
+  getListKey() {
+    return `${this.keyPrefix}list`;
+  }
+  async register(redirect) {
+    const key = this.getKey(redirect.from);
+    const listKey = this.getListKey();
+    const data = JSON.stringify(redirect);
+    if (this.ttl) {
+      await this.client.set(key, data, "EX", this.ttl);
+    } else {
+      await this.client.set(key, data);
+    }
+    await this.client.sadd(listKey, redirect.from);
+  }
+  async registerBatch(redirects) {
+    for (const redirect of redirects) {
+      await this.register(redirect);
+    }
+  }
+  async get(from) {
+    try {
+      const key = this.getKey(from);
+      const data = await this.client.get(key);
+      if (!data) {
+        return null;
+      }
+      const rule = JSON.parse(data);
+      if (rule.createdAt) {
+        rule.createdAt = new Date(rule.createdAt);
+      }
+      return rule;
+    } catch {
+      return null;
+    }
+  }
+  async getAll() {
+    try {
+      const listKey = this.getListKey();
+      const froms = await this.client.smembers(listKey);
+      const rules = [];
+      for (const from of froms) {
+        const rule = await this.get(from);
+        if (rule) {
+          rules.push(rule);
+        }
+      }
+      return rules;
+    } catch {
+      return [];
+    }
+  }
+  async resolve(url, followChains = false, maxChainLength = 5) {
+    let current = url;
+    let chainLength = 0;
+    while (chainLength < maxChainLength) {
+      const rule = await this.get(current);
+      if (!rule) {
+        return current;
+      }
+      current = rule.to;
+      chainLength++;
+      if (!followChains) {
+        return current;
+      }
+    }
+    return current;
+  }
+}
+
+// src/index.ts
+init_DiskSitemapStorage();
+
+// src/storage/GCPSitemapStorage.ts
+class GCPSitemapStorage {
+  bucket;
+  prefix;
+  baseUrl;
+  shadowEnabled;
+  shadowMode;
+  storageClient;
+  bucketInstance;
+  constructor(options) {
+    this.bucket = options.bucket;
+    this.prefix = options.prefix || "";
+    this.baseUrl = options.baseUrl || `https://storage.googleapis.com/${options.bucket}`;
+    this.shadowEnabled = options.shadow?.enabled ?? false;
+    this.shadowMode = options.shadow?.mode || "atomic";
+  }
+  async getStorageClient() {
+    if (this.storageClient) {
+      return { client: this.storageClient, bucket: this.bucketInstance };
+    }
+    try {
+      const { Storage } = await import("@google-cloud/storage");
+      const clientOptions = {};
+      if (this.constructor.name === "GCPSitemapStorage") {}
+      this.storageClient = new Storage(clientOptions);
+      this.bucketInstance = this.storageClient.bucket(this.bucket);
+      return { client: this.storageClient, bucket: this.bucketInstance };
+    } catch (error) {
+      throw new Error(`Failed to load Google Cloud Storage. Please install @google-cloud/storage: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  getKey(filename) {
+    const cleanPrefix = this.prefix.endsWith("/") ? this.prefix.slice(0, -1) : this.prefix;
+    return cleanPrefix ? `${cleanPrefix}/${filename}` : filename;
+  }
+  async write(filename, content) {
+    const { bucket } = await this.getStorageClient();
+    const key = this.getKey(filename);
+    const file = bucket.file(key);
+    await file.save(content, {
+      contentType: "application/xml",
+      metadata: {
+        cacheControl: "public, max-age=3600"
+      }
+    });
+  }
+  async read(filename) {
+    try {
+      const { bucket } = await this.getStorageClient();
+      const key = this.getKey(filename);
+      const file = bucket.file(key);
+      const [exists] = await file.exists();
+      if (!exists) {
+        return null;
+      }
+      const [content] = await file.download();
+      return content.toString("utf-8");
+    } catch (error) {
+      if (error.code === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async exists(filename) {
+    try {
+      const { bucket } = await this.getStorageClient();
+      const key = this.getKey(filename);
+      const file = bucket.file(key);
+      const [exists] = await file.exists();
+      return exists;
+    } catch {
+      return false;
+    }
+  }
+  getUrl(filename) {
+    const key = this.getKey(filename);
+    const base = this.baseUrl.endsWith("/") ? this.baseUrl.slice(0, -1) : this.baseUrl;
+    return `${base}/${key}`;
+  }
+  async writeShadow(filename, content, shadowId) {
+    if (!this.shadowEnabled) {
+      return this.write(filename, content);
+    }
+    const { bucket } = await this.getStorageClient();
+    const id = shadowId || `shadow-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+    const shadowKey = this.getKey(`${filename}.shadow.${id}`);
+    const file = bucket.file(shadowKey);
+    await file.save(content, {
+      contentType: "application/xml",
+      metadata: {
+        cacheControl: "public, max-age=3600"
+      }
+    });
+  }
+  async commitShadow(shadowId) {
+    if (!this.shadowEnabled) {
+      return;
+    }
+    const { bucket } = await this.getStorageClient();
+    const prefix = this.prefix ? `${this.prefix}/` : "";
+    const [files] = await bucket.getFiles({ prefix });
+    const shadowFiles = files.filter((file) => {
+      const name = file.name;
+      return name.includes(`.shadow.${shadowId}`);
+    });
+    for (const shadowFile of shadowFiles) {
+      const originalKey = shadowFile.name.replace(/\.shadow\.[^/]+$/, "");
+      const _originalFilename = originalKey.replace(prefix, "");
+      if (this.shadowMode === "atomic") {
+        await shadowFile.copy(bucket.file(originalKey));
+        await shadowFile.delete();
+      } else {
+        const version = shadowId;
+        const versionedKey = `${originalKey}.v${version}`;
+        await shadowFile.copy(bucket.file(versionedKey));
+        await shadowFile.copy(bucket.file(originalKey));
+        await shadowFile.delete();
+      }
+    }
+  }
+  async listVersions(filename) {
+    if (this.shadowMode !== "versioned") {
+      return [];
+    }
+    try {
+      const { bucket } = await this.getStorageClient();
+      const key = this.getKey(filename);
+      const prefix = key.replace(/\.xml$/, "");
+      const [files] = await bucket.getFiles({ prefix });
+      const versions = [];
+      for (const file of files) {
+        const match = file.name.match(/\.v([^/]+)$/);
+        if (match) {
+          versions.push(match[1]);
+        }
+      }
+      return versions.sort();
+    } catch {
+      return [];
+    }
+  }
+  async switchVersion(filename, version) {
+    if (this.shadowMode !== "versioned") {
+      throw new Error("Version switching is only available in versioned mode");
+    }
+    const { bucket } = await this.getStorageClient();
+    const key = this.getKey(filename);
+    const versionedKey = `${key}.v${version}`;
+    const versionedFile = bucket.file(versionedKey);
+    const [exists] = await versionedFile.exists();
+    if (!exists) {
+      throw new Error(`Version ${version} not found for ${filename}`);
+    }
+    await versionedFile.copy(bucket.file(key));
+  }
+}
+// src/storage/MemoryProgressStorage.ts
+class MemoryProgressStorage {
+  storage = new Map;
+  async get(jobId) {
+    const progress = this.storage.get(jobId);
+    return progress ? { ...progress } : null;
+  }
+  async set(jobId, progress) {
+    this.storage.set(jobId, { ...progress });
+  }
+  async update(jobId, updates) {
+    const existing = this.storage.get(jobId);
+    if (existing) {
+      this.storage.set(jobId, { ...existing, ...updates });
+    }
+  }
+  async delete(jobId) {
+    this.storage.delete(jobId);
+  }
+  async list(limit) {
+    const all = Array.from(this.storage.values());
+    const sorted = all.sort((a, b) => {
+      const aTime = a.startTime?.getTime() || 0;
+      const bTime = b.startTime?.getTime() || 0;
+      return bTime - aTime;
+    });
+    return limit ? sorted.slice(0, limit) : sorted;
+  }
+}
+// src/storage/RedisProgressStorage.ts
+class RedisProgressStorage {
+  client;
+  keyPrefix;
+  ttl;
+  constructor(options) {
+    this.client = options.client;
+    this.keyPrefix = options.keyPrefix || "sitemap:progress:";
+    this.ttl = options.ttl || 86400;
+  }
+  getKey(jobId) {
+    return `${this.keyPrefix}${jobId}`;
+  }
+  getListKey() {
+    return `${this.keyPrefix}list`;
+  }
+  async get(jobId) {
+    try {
+      const key = this.getKey(jobId);
+      const data = await this.client.get(key);
+      if (!data) {
+        return null;
+      }
+      const progress = JSON.parse(data);
+      if (progress.startTime) {
+        progress.startTime = new Date(progress.startTime);
+      }
+      if (progress.endTime) {
+        progress.endTime = new Date(progress.endTime);
+      }
+      return progress;
+    } catch {
+      return null;
+    }
+  }
+  async set(jobId, progress) {
+    const key = this.getKey(jobId);
+    const listKey = this.getListKey();
+    const data = JSON.stringify(progress);
+    await this.client.set(key, data, "EX", this.ttl);
+    await this.client.zadd(listKey, Date.now(), jobId);
+    await this.client.expire(listKey, this.ttl);
+  }
+  async update(jobId, updates) {
+    const existing = await this.get(jobId);
+    if (existing) {
+      await this.set(jobId, { ...existing, ...updates });
+    }
+  }
+  async delete(jobId) {
+    const key = this.getKey(jobId);
+    const listKey = this.getListKey();
+    await this.client.del(key);
+    await this.client.zrem(listKey, jobId);
+  }
+  async list(limit) {
+    try {
+      const listKey = this.getListKey();
+      const jobIds = await this.client.zrevrange(listKey, 0, (limit || 100) - 1);
+      const results = [];
+      for (const jobId of jobIds) {
+        const progress = await this.get(jobId);
+        if (progress) {
+          results.push(progress);
+        }
+      }
+      return results;
+    } catch {
+      return [];
+    }
+  }
+}
+// src/storage/S3SitemapStorage.ts
+class S3SitemapStorage {
+  bucket;
+  region;
+  prefix;
+  baseUrl;
+  shadowEnabled;
+  shadowMode;
+  s3Client;
+  constructor(options) {
+    this.bucket = options.bucket;
+    this.region = options.region || "us-east-1";
+    this.prefix = options.prefix || "";
+    this.baseUrl = options.baseUrl || `https://${options.bucket}.s3.${this.region}.amazonaws.com`;
+    this.shadowEnabled = options.shadow?.enabled ?? false;
+    this.shadowMode = options.shadow?.mode || "atomic";
+  }
+  async getS3Client() {
+    if (this.s3Client) {
+      return this.s3Client;
+    }
+    try {
+      const {
+        S3Client,
+        PutObjectCommand,
+        GetObjectCommand,
+        HeadObjectCommand,
+        ListObjectsV2Command,
+        CopyObjectCommand,
+        DeleteObjectCommand
+      } = await import("@aws-sdk/client-s3");
+      const clientOptions = {
+        region: this.region
+      };
+      if (this.constructor.name === "S3SitemapStorage") {}
+      this.s3Client = {
+        S3Client,
+        PutObjectCommand,
+        GetObjectCommand,
+        HeadObjectCommand,
+        ListObjectsV2Command,
+        CopyObjectCommand,
+        DeleteObjectCommand,
+        client: new S3Client(clientOptions)
+      };
+      return this.s3Client;
+    } catch (error) {
+      throw new Error(`Failed to load AWS SDK. Please install @aws-sdk/client-s3: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  getKey(filename) {
+    const cleanPrefix = this.prefix.endsWith("/") ? this.prefix.slice(0, -1) : this.prefix;
+    return cleanPrefix ? `${cleanPrefix}/${filename}` : filename;
+  }
+  async write(filename, content) {
+    const s3 = await this.getS3Client();
+    const key = this.getKey(filename);
+    await s3.client.send(new s3.PutObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+      Body: content,
+      ContentType: "application/xml"
+    }));
+  }
+  async read(filename) {
+    try {
+      const s3 = await this.getS3Client();
+      const key = this.getKey(filename);
+      const response = await s3.client.send(new s3.GetObjectCommand({
+        Bucket: this.bucket,
+        Key: key
+      }));
+      if (!response.Body) {
+        return null;
+      }
+      const chunks = [];
+      for await (const chunk of response.Body) {
+        chunks.push(chunk);
+      }
+      const buffer = Buffer.concat(chunks);
+      return buffer.toString("utf-8");
+    } catch (error) {
+      if (error.name === "NoSuchKey" || error.$metadata?.httpStatusCode === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async exists(filename) {
+    try {
+      const s3 = await this.getS3Client();
+      const key = this.getKey(filename);
+      await s3.client.send(new s3.HeadObjectCommand({
+        Bucket: this.bucket,
+        Key: key
+      }));
+      return true;
+    } catch (error) {
+      if (error.name === "NotFound" || error.$metadata?.httpStatusCode === 404) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  getUrl(filename) {
+    const key = this.getKey(filename);
+    const base = this.baseUrl.endsWith("/") ? this.baseUrl.slice(0, -1) : this.baseUrl;
+    return `${base}/${key}`;
+  }
+  async writeShadow(filename, content, shadowId) {
+    if (!this.shadowEnabled) {
+      return this.write(filename, content);
+    }
+    const s3 = await this.getS3Client();
+    const id = shadowId || `shadow-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+    const shadowKey = this.getKey(`${filename}.shadow.${id}`);
+    await s3.client.send(new s3.PutObjectCommand({
+      Bucket: this.bucket,
+      Key: shadowKey,
+      Body: content,
+      ContentType: "application/xml"
+    }));
+  }
+  async commitShadow(shadowId) {
+    if (!this.shadowEnabled) {
+      return;
+    }
+    const s3 = await this.getS3Client();
+    const prefix = this.prefix ? `${this.prefix}/` : "";
+    const listResponse = await s3.client.send(new s3.ListObjectsV2Command({
+      Bucket: this.bucket,
+      Prefix: prefix
+    }));
+    if (!listResponse.Contents) {
+      return;
+    }
+    const shadowFiles = listResponse.Contents.filter((obj) => obj.Key?.includes(`.shadow.${shadowId}`));
+    for (const shadowFile of shadowFiles) {
+      if (!shadowFile.Key) {
+        continue;
+      }
+      const originalKey = shadowFile.Key.replace(/\.shadow\.[^/]+$/, "");
+      const _originalFilename = originalKey.replace(prefix, "");
+      if (this.shadowMode === "atomic") {
+        await s3.client.send(new s3.CopyObjectCommand({
+          Bucket: this.bucket,
+          CopySource: `${this.bucket}/${shadowFile.Key}`,
+          Key: originalKey,
+          ContentType: "application/xml"
+        }));
+        await s3.client.send(new s3.DeleteObjectCommand({
+          Bucket: this.bucket,
+          Key: shadowFile.Key
+        }));
+      } else {
+        const version = shadowId;
+        const versionedKey = `${originalKey}.v${version}`;
+        await s3.client.send(new s3.CopyObjectCommand({
+          Bucket: this.bucket,
+          CopySource: `${this.bucket}/${shadowFile.Key}`,
+          Key: versionedKey,
+          ContentType: "application/xml"
+        }));
+        await s3.client.send(new s3.CopyObjectCommand({
+          Bucket: this.bucket,
+          CopySource: `${this.bucket}/${shadowFile.Key}`,
+          Key: originalKey,
+          ContentType: "application/xml"
+        }));
+        await s3.client.send(new s3.DeleteObjectCommand({
+          Bucket: this.bucket,
+          Key: shadowFile.Key
+        }));
+      }
+    }
+  }
+  async listVersions(filename) {
+    if (this.shadowMode !== "versioned") {
+      return [];
+    }
+    try {
+      const s3 = await this.getS3Client();
+      const key = this.getKey(filename);
+      const prefix = key.replace(/\.xml$/, "");
+      const listResponse = await s3.client.send(new s3.ListObjectsV2Command({
+        Bucket: this.bucket,
+        Prefix: prefix
+      }));
+      if (!listResponse.Contents) {
+        return [];
+      }
+      const versions = [];
+      for (const obj of listResponse.Contents) {
+        if (!obj.Key) {
+          continue;
+        }
+        const match = obj.Key.match(/\.v([^/]+)$/);
+        if (match) {
+          versions.push(match[1]);
+        }
+      }
+      return versions.sort();
+    } catch {
+      return [];
+    }
+  }
+  async switchVersion(filename, version) {
+    if (this.shadowMode !== "versioned") {
+      throw new Error("Version switching is only available in versioned mode");
+    }
+    const s3 = await this.getS3Client();
+    const key = this.getKey(filename);
+    const versionedKey = `${key}.v${version}`;
+    const exists = await this.exists(versionedKey.replace(this.prefix ? `${this.prefix}/` : "", ""));
+    if (!exists) {
+      throw new Error(`Version ${version} not found for ${filename}`);
+    }
+    await s3.client.send(new s3.CopyObjectCommand({
+      Bucket: this.bucket,
+      CopySource: `${this.bucket}/${versionedKey}`,
+      Key: key,
+      ContentType: "application/xml"
+    }));
+  }
+}