@gravito/constellation 3.0.1 → 3.0.2

package/dist/index.cjs

@@ -50,10 +50,11 @@ function sanitizeFilename(filename) {
   }
   return filename;
 }
-var import_promises, import_node_path, DiskSitemapStorage;
+var import_node_fs, import_promises, import_node_path, DiskSitemapStorage;
 var init_DiskSitemapStorage = __esm({
   "src/storage/DiskSitemapStorage.ts"() {
     "use strict";
+    import_node_fs = require("fs");
     import_promises = __toESM(require("fs/promises"), 1);
     import_node_path = __toESM(require("path"), 1);
     DiskSitemapStorage = class {
@@ -74,6 +75,17 @@ var init_DiskSitemapStorage = __esm({
           return null;
         }
       }
+      async readStream(filename) {
+        try {
+          const safeName = sanitizeFilename(filename);
+          const fullPath = import_node_path.default.join(this.outDir, safeName);
+          await import_promises.default.access(fullPath);
+          const stream = (0, import_node_fs.createReadStream)(fullPath, { encoding: "utf-8" });
+          return stream;
+        } catch {
+          return null;
+        }
+      }
       async exists(filename) {
         try {
           const safeName = sanitizeFilename(filename);
@@ -126,14 +138,30 @@ module.exports = __toCommonJS(index_exports);
 // src/core/ChangeTracker.ts
 var MemoryChangeTracker = class {
   changes = [];
+  urlIndex = /* @__PURE__ */ new Map();
   maxChanges;
   constructor(options = {}) {
     this.maxChanges = options.maxChanges || 1e5;
   }
   async track(change) {
     this.changes.push(change);
+    const urlChanges = this.urlIndex.get(change.url) || [];
+    urlChanges.push(change);
+    this.urlIndex.set(change.url, urlChanges);
     if (this.changes.length > this.maxChanges) {
-      this.changes = this.changes.slice(-this.maxChanges);
+      const removed = this.changes.shift();
+      if (removed) {
+        const changes = this.urlIndex.get(removed.url);
+        if (changes) {
+          const index = changes.indexOf(removed);
+          if (index > -1) {
+            changes.splice(index, 1);
+          }
+          if (changes.length === 0) {
+            this.urlIndex.delete(removed.url);
+          }
+        }
+      }
     }
   }
   async getChanges(since) {
@@ -143,14 +171,21 @@ var MemoryChangeTracker = class {
     return this.changes.filter((change) => change.timestamp >= since);
   }
   async getChangesByUrl(url) {
-    return this.changes.filter((change) => change.url === url);
+    return this.urlIndex.get(url) || [];
   }
   async clear(since) {
     if (!since) {
       this.changes = [];
+      this.urlIndex.clear();
       return;
     }
     this.changes = this.changes.filter((change) => change.timestamp < since);
+    this.urlIndex.clear();
+    for (const change of this.changes) {
+      const urlChanges = this.urlIndex.get(change.url) || [];
+      urlChanges.push(change);
+      this.urlIndex.set(change.url, urlChanges);
+    }
   }
 };
 var RedisChangeTracker = class {
@@ -325,52 +360,72 @@ var DiffCalculator = class {
   }
 };
 
+// src/utils/Mutex.ts
+var Mutex = class {
+  queue = Promise.resolve();
+  async runExclusive(fn) {
+    const next = this.queue.then(() => fn());
+    this.queue = next.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    return next;
+  }
+};
+
 // src/core/ShadowProcessor.ts
 var ShadowProcessor = class {
   options;
   shadowId;
   operations = [];
+  mutex = new Mutex();
   constructor(options) {
     this.options = options;
-    this.shadowId = `shadow-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+    this.shadowId = `shadow-${Date.now()}-${crypto.randomUUID()}`;
   }
   /**
    * 添加一個影子操作
    */
   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
+    return this.mutex.runExclusive(async () => {
+      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);
+      }
     });
-    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);
+    return this.mutex.runExclusive(async () => {
+      if (!this.options.enabled) {
+        return;
       }
-    } else {
-      for (const operation of this.operations) {
+      if (this.options.mode === "atomic") {
         if (this.options.storage.commitShadow) {
-          await this.options.storage.commitShadow(operation.shadowId || this.shadowId);
+          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 = [];
+      this.operations = [];
+    });
   }
   /**
    * 取消所有影子操作
@@ -456,6 +511,12 @@ var SitemapIndex = class {
 var SitemapStream = class {
   options;
   entries = [];
+  flags = {
+    hasImages: false,
+    hasVideos: false,
+    hasNews: false,
+    hasAlternates: false
+  };
   constructor(options) {
     this.options = { ...options };
     if (this.options.baseUrl.endsWith("/")) {
@@ -463,10 +524,19 @@ var SitemapStream = class {
     }
   }
   add(entry) {
-    if (typeof entry === "string") {
-      this.entries.push({ url: entry });
-    } else {
-      this.entries.push(entry);
+    const e = typeof entry === "string" ? { url: entry } : entry;
+    this.entries.push(e);
+    if (e.images && e.images.length > 0) {
+      this.flags.hasImages = true;
+    }
+    if (e.videos && e.videos.length > 0) {
+      this.flags.hasVideos = true;
+    }
+    if (e.news) {
+      this.flags.hasNews = true;
+    }
+    if (e.alternates && e.alternates.length > 0) {
+      this.flags.hasAlternates = true;
     }
     return this;
   }
@@ -478,33 +548,33 @@ var SitemapStream = class {
   }
   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"`;
+    const parts = [];
+    parts.push('<?xml version="1.0" encoding="UTF-8"?>\n');
+    parts.push('<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"');
+    if (this.flags.hasImages) {
+      parts.push(' 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.flags.hasVideos) {
+      parts.push(' 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.flags.hasNews) {
+      parts.push(' xmlns:news="http://www.google.com/schemas/sitemap-news/0.9"');
     }
-    if (this.hasAlternates()) {
-      xml += ` xmlns:xhtml="http://www.w3.org/1999/xhtml"`;
+    if (this.flags.hasAlternates) {
+      parts.push(' xmlns:xhtml="http://www.w3.org/1999/xhtml"');
     }
-    xml += `>
-`;
+    parts.push(">\n");
     for (const entry of this.entries) {
-      xml += this.renderUrl(entry, baseUrl, pretty);
+      parts.push(this.renderUrl(entry, baseUrl, pretty));
     }
-    xml += `</urlset>`;
-    return xml;
+    parts.push("</urlset>");
+    return parts.join("");
   }
   renderUrl(entry, baseUrl, pretty) {
     const indent = pretty ? "  " : "";
     const subIndent = pretty ? "    " : "";
     const nl = pretty ? "\n" : "";
+    const parts = [];
     let loc = entry.url;
     if (!loc.startsWith("http")) {
       if (!loc.startsWith("/")) {
@@ -512,17 +582,17 @@ var SitemapStream = class {
       }
       loc = baseUrl + loc;
     }
-    let item = `${indent}<url>${nl}`;
-    item += `${subIndent}<loc>${this.escape(loc)}</loc>${nl}`;
+    parts.push(`${indent}<url>${nl}`);
+    parts.push(`${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}`;
+      parts.push(`${subIndent}<lastmod>${date.toISOString().split("T")[0]}</lastmod>${nl}`);
     }
     if (entry.changefreq) {
-      item += `${subIndent}<changefreq>${entry.changefreq}</changefreq>${nl}`;
+      parts.push(`${subIndent}<changefreq>${entry.changefreq}</changefreq>${nl}`);
     }
     if (entry.priority !== void 0) {
-      item += `${subIndent}<priority>${entry.priority.toFixed(1)}</priority>${nl}`;
+      parts.push(`${subIndent}<priority>${entry.priority.toFixed(1)}</priority>${nl}`);
     }
     if (entry.alternates) {
       for (const alt of entry.alternates) {
@@ -533,7 +603,9 @@ var SitemapStream = class {
           }
           altLoc = baseUrl + altLoc;
         }
-        item += `${subIndent}<xhtml:link rel="alternate" hreflang="${alt.lang}" href="${this.escape(altLoc)}"/>${nl}`;
+        parts.push(
+          `${subIndent}<xhtml:link rel="alternate" hreflang="${alt.lang}" href="${this.escape(altLoc)}"/>${nl}`
+        );
       }
     }
     if (entry.redirect?.canonical) {
@@ -544,10 +616,14 @@ var SitemapStream = class {
         }
         canonicalUrl = baseUrl + canonicalUrl;
       }
-      item += `${subIndent}<xhtml:link rel="canonical" href="${this.escape(canonicalUrl)}"/>${nl}`;
+      parts.push(
+        `${subIndent}<xhtml:link rel="canonical" href="${this.escape(canonicalUrl)}"/>${nl}`
+      );
     }
     if (entry.redirect && !entry.redirect.canonical) {
-      item += `${subIndent}<!-- Redirect: ${entry.redirect.from} \u2192 ${entry.redirect.to} (${entry.redirect.type}) -->${nl}`;
+      parts.push(
+        `${subIndent}<!-- Redirect: ${entry.redirect.from} \u2192 ${entry.redirect.to} (${entry.redirect.type}) -->${nl}`
+      );
     }
     if (entry.images) {
       for (const img of entry.images) {
@@ -558,91 +634,110 @@ var SitemapStream = class {
           }
           loc2 = baseUrl + loc2;
         }
-        item += `${subIndent}<image:image>${nl}`;
-        item += `${subIndent}  <image:loc>${this.escape(loc2)}</image:loc>${nl}`;
+        parts.push(`${subIndent}<image:image>${nl}`);
+        parts.push(`${subIndent}  <image:loc>${this.escape(loc2)}</image:loc>${nl}`);
         if (img.title) {
-          item += `${subIndent}  <image:title>${this.escape(img.title)}</image:title>${nl}`;
+          parts.push(`${subIndent}  <image:title>${this.escape(img.title)}</image:title>${nl}`);
         }
         if (img.caption) {
-          item += `${subIndent}  <image:caption>${this.escape(img.caption)}</image:caption>${nl}`;
+          parts.push(
+            `${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}`;
+          parts.push(
+            `${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}`;
+          parts.push(
+            `${subIndent}  <image:license>${this.escape(img.license)}</image:license>${nl}`
+          );
         }
-        item += `${subIndent}</image:image>${nl}`;
+        parts.push(`${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}`;
+        parts.push(`${subIndent}<video:video>${nl}`);
+        parts.push(
+          `${subIndent}  <video:thumbnail_loc>${this.escape(video.thumbnail_loc)}</video:thumbnail_loc>${nl}`
+        );
+        parts.push(`${subIndent}  <video:title>${this.escape(video.title)}</video:title>${nl}`);
+        parts.push(
+          `${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}`;
+          parts.push(
+            `${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}`;
+          parts.push(
+            `${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}`;
+          parts.push(`${subIndent}  <video:duration>${video.duration}</video:duration>${nl}`);
         }
         if (video.view_count) {
-          item += `${subIndent}  <video:view_count>${video.view_count}</video:view_count>${nl}`;
+          parts.push(`${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}`;
+          parts.push(
+            `${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}`;
+          parts.push(
+            `${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}`;
+            parts.push(`${subIndent}  <video:tag>${this.escape(tag)}</video:tag>${nl}`);
           }
         }
-        item += `${subIndent}</video:video>${nl}`;
+        parts.push(`${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}`;
+      parts.push(`${subIndent}<news:news>${nl}`);
+      parts.push(`${subIndent}  <news:publication>${nl}`);
+      parts.push(
+        `${subIndent}    <news:name>${this.escape(entry.news.publication.name)}</news:name>${nl}`
+      );
+      parts.push(
+        `${subIndent}    <news:language>${this.escape(entry.news.publication.language)}</news:language>${nl}`
+      );
+      parts.push(`${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}`;
+      parts.push(
+        `${subIndent}  <news:publication_date>${pubDate.toISOString()}</news:publication_date>${nl}`
+      );
+      parts.push(`${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}`;
+        parts.push(
+          `${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}`;
+        parts.push(
+          `${subIndent}  <news:keywords>${entry.news.keywords.map((k) => this.escape(k)).join(", ")}</news:keywords>${nl}`
+        );
       }
-      item += `${subIndent}</news:news>${nl}`;
+      parts.push(`${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);
+    parts.push(`${indent}</url>${nl}`);
+    return parts.join("");
   }
   escape(str) {
     return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
   }
+  getEntries() {
+    return this.entries;
+  }
 };
 
 // src/core/SitemapGenerator.ts
@@ -674,12 +769,21 @@ var SitemapGenerator = class {
       baseUrl: this.options.baseUrl,
       pretty: this.options.pretty
     });
+    const shards = [];
     let isMultiFile = false;
     const flushShard = async () => {
       isMultiFile = true;
       const baseName = this.options.filename?.replace(/\.xml$/, "");
       const filename = `${baseName}-${shardIndex}.xml`;
       const xml = currentStream.toXML();
+      const entries = currentStream.getEntries();
+      shards.push({
+        filename,
+        from: this.normalizeUrl(entries[0].url),
+        to: this.normalizeUrl(entries[entries.length - 1].url),
+        count: entries.length,
+        lastmod: /* @__PURE__ */ new Date()
+      });
       if (this.shadowProcessor) {
         await this.shadowProcessor.addOperation({ filename, content: xml });
       } else {
@@ -717,16 +821,44 @@ var SitemapGenerator = class {
         }
       }
     }
+    const writeManifest = async () => {
+      if (!this.options.generateManifest) return;
+      const manifest = {
+        version: 1,
+        generatedAt: /* @__PURE__ */ new Date(),
+        baseUrl: this.options.baseUrl,
+        maxEntriesPerShard: this.options.maxEntriesPerFile,
+        sort: "url-lex",
+        shards
+      };
+      const manifestFilename = this.options.filename?.replace(/\.xml$/, "-manifest.json") || "sitemap-manifest.json";
+      const content = JSON.stringify(manifest, null, this.options.pretty ? 2 : 0);
+      if (this.shadowProcessor) {
+        await this.shadowProcessor.addOperation({ filename: manifestFilename, content });
+      } else {
+        await this.options.storage.write(manifestFilename, content);
+      }
+    };
     if (!isMultiFile) {
       const xml = currentStream.toXML();
+      const entries = currentStream.getEntries();
+      shards.push({
+        filename: this.options.filename,
+        from: entries[0] ? this.normalizeUrl(entries[0].url) : "",
+        to: entries[entries.length - 1] ? this.normalizeUrl(entries[entries.length - 1].url) : "",
+        count: entries.length,
+        lastmod: /* @__PURE__ */ new Date()
+      });
       if (this.shadowProcessor) {
         await this.shadowProcessor.addOperation({
           filename: this.options.filename,
           content: xml
         });
+        await writeManifest();
         await this.shadowProcessor.commit();
       } else {
         await this.options.storage.write(this.options.filename, xml);
+        await writeManifest();
       }
       return;
     }
@@ -739,11 +871,22 @@ var SitemapGenerator = class {
         filename: this.options.filename,
         content: indexXml
       });
+      await writeManifest();
       await this.shadowProcessor.commit();
     } else {
       await this.options.storage.write(this.options.filename, indexXml);
+      await writeManifest();
     }
   }
+  normalizeUrl(url) {
+    if (url.startsWith("http")) {
+      return url;
+    }
+    const { baseUrl } = this.options;
+    const normalizedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    const normalizedPath = url.startsWith("/") ? url : `/${url}`;
+    return normalizedBase + normalizedPath;
+  }
   /**
    * 獲取影子處理器（如果啟用）
    */
@@ -752,22 +895,104 @@ var SitemapGenerator = class {
   }
 };
 
+// src/core/SitemapParser.ts
+var SitemapParser = class {
+  static parse(xml) {
+    const entries = [];
+    const urlRegex = /<url>([\s\S]*?)<\/url>/g;
+    let match;
+    while ((match = urlRegex.exec(xml)) !== null) {
+      const entry = this.parseEntry(match[1]);
+      if (entry) {
+        entries.push(entry);
+      }
+    }
+    return entries;
+  }
+  static async *parseStream(stream) {
+    let buffer = "";
+    const urlRegex = /<url>([\s\S]*?)<\/url>/g;
+    for await (const chunk of stream) {
+      buffer += chunk;
+      let match;
+      while ((match = urlRegex.exec(buffer)) !== null) {
+        const entry = this.parseEntry(match[1]);
+        if (entry) {
+          yield entry;
+        }
+        buffer = buffer.slice(match.index + match[0].length);
+        urlRegex.lastIndex = 0;
+      }
+      if (buffer.length > 1024 * 1024) {
+        const lastUrlStart = buffer.lastIndexOf("<url>");
+        buffer = lastUrlStart !== -1 ? buffer.slice(lastUrlStart) : "";
+      }
+    }
+  }
+  static parseEntry(urlContent) {
+    const entry = { url: "" };
+    const locMatch = /<loc>(.*?)<\/loc>/.exec(urlContent);
+    if (locMatch) {
+      entry.url = this.unescape(locMatch[1]);
+    } else {
+      return null;
+    }
+    const lastmodMatch = /<lastmod>(.*?)<\/lastmod>/.exec(urlContent);
+    if (lastmodMatch) {
+      entry.lastmod = new Date(lastmodMatch[1]);
+    }
+    const priorityMatch = /<priority>(.*?)<\/priority>/.exec(urlContent);
+    if (priorityMatch) {
+      entry.priority = parseFloat(priorityMatch[1]);
+    }
+    const changefreqMatch = /<changefreq>(.*?)<\/changefreq>/.exec(urlContent);
+    if (changefreqMatch) {
+      entry.changefreq = changefreqMatch[1];
+    }
+    return entry;
+  }
+  static parseIndex(xml) {
+    const urls = [];
+    const sitemapRegex = /<sitemap>([\s\S]*?)<\/sitemap>/g;
+    let match;
+    while ((match = sitemapRegex.exec(xml)) !== null) {
+      const content = match[1];
+      const locMatch = /<loc>(.*?)<\/loc>/.exec(content);
+      if (locMatch) {
+        urls.push(this.unescape(locMatch[1]));
+      }
+    }
+    return urls;
+  }
+  static unescape(str) {
+    return str.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'");
+  }
+};
+
 // src/core/IncrementalGenerator.ts
 var IncrementalGenerator = class {
   options;
   changeTracker;
   diffCalculator;
   generator;
+  mutex = new Mutex();
   constructor(options) {
-    this.options = options;
-    this.changeTracker = options.changeTracker;
-    this.diffCalculator = options.diffCalculator || new DiffCalculator();
-    this.generator = new SitemapGenerator(options);
+    this.options = {
+      autoTrack: true,
+      generateManifest: true,
+      ...options
+    };
+    this.changeTracker = this.options.changeTracker;
+    this.diffCalculator = this.options.diffCalculator || new DiffCalculator();
+    this.generator = new SitemapGenerator(this.options);
   }
-  /**
-   * 生成完整的 sitemap（首次生成）
-   */
   async generateFull() {
+    return this.mutex.runExclusive(() => this.performFullGeneration());
+  }
+  async generateIncremental(since) {
+    return this.mutex.runExclusive(() => this.performIncrementalGeneration(since));
+  }
+  async performFullGeneration() {
     await this.generator.run();
     if (this.options.autoTrack) {
       const { providers } = this.options;
@@ -785,52 +1010,130 @@ var IncrementalGenerator = class {
       }
     }
   }
-  /**
-   * 增量生成（只更新變更的部分）
-   */
-  async generateIncremental(since) {
+  async performIncrementalGeneration(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);
+    const manifest = await this.loadManifest();
+    if (!manifest) {
+      await this.performFullGeneration();
+      return;
+    }
+    const totalCount = manifest.shards.reduce((acc, s) => acc + s.count, 0);
+    const changeRatio = totalCount > 0 ? changes.length / totalCount : 1;
+    if (changeRatio > 0.3) {
+      await this.performFullGeneration();
+      return;
+    }
+    const affectedShards = this.getAffectedShards(manifest, changes);
+    if (affectedShards.size / manifest.shards.length > 0.5) {
+      await this.performFullGeneration();
+      return;
+    }
+    await this.updateShards(manifest, affectedShards);
   }
-  /**
-   * 手動追蹤變更
-   */
-  async trackChange(change) {
-    await this.changeTracker.track(change);
+  normalizeUrl(url) {
+    if (url.startsWith("http")) {
+      return url;
+    }
+    const { baseUrl } = this.options;
+    const normalizedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    const normalizedPath = url.startsWith("/") ? url : `/${url}`;
+    return normalizedBase + normalizedPath;
   }
-  /**
-   * 獲取變更記錄
-   */
-  async getChanges(since) {
-    return this.changeTracker.getChanges(since);
+  async loadManifest() {
+    const filename = this.options.filename?.replace(/\.xml$/, "-manifest.json") || "sitemap-manifest.json";
+    const content = await this.options.storage.read(filename);
+    if (!content) {
+      return null;
+    }
+    try {
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
   }
-  /**
-   * 載入基礎 entries（從現有 sitemap）
-   */
-  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);
+  getAffectedShards(manifest, changes) {
+    const affected = /* @__PURE__ */ new Map();
+    for (const change of changes) {
+      const normalizedUrl = this.normalizeUrl(change.url);
+      let shard = manifest.shards.find((s) => {
+        return normalizedUrl >= s.from && normalizedUrl <= s.to;
+      });
+      if (!shard) {
+        shard = manifest.shards.find((s) => normalizedUrl <= s.to);
+        if (!shard) {
+          shard = manifest.shards[manifest.shards.length - 1];
+        }
+      }
+      if (shard) {
+        const shardChanges = affected.get(shard.filename) || [];
+        shardChanges.push(change);
+        affected.set(shard.filename, shardChanges);
+      }
     }
-    return entries;
+    return affected;
   }
-  /**
-   * 生成差異部分
-   */
-  async generateDiff(_diff) {
-    await this.generator.run();
+  async updateShards(manifest, affectedShards) {
+    for (const [filename, shardChanges] of affectedShards) {
+      const entries = [];
+      const stream = await this.options.storage.readStream?.(filename);
+      if (stream) {
+        for await (const entry of SitemapParser.parseStream(stream)) {
+          entries.push(entry);
+        }
+      } else {
+        const xml = await this.options.storage.read(filename);
+        if (!xml) {
+          continue;
+        }
+        entries.push(...SitemapParser.parse(xml));
+      }
+      const updatedEntries = this.applyChanges(entries, shardChanges);
+      const outStream = new SitemapStream({
+        baseUrl: this.options.baseUrl,
+        pretty: this.options.pretty
+      });
+      outStream.addAll(updatedEntries);
+      const newXml = outStream.toXML();
+      await this.options.storage.write(filename, newXml);
+      const shardInfo = manifest.shards.find((s) => s.filename === filename);
+      if (shardInfo) {
+        shardInfo.count = updatedEntries.length;
+        shardInfo.lastmod = /* @__PURE__ */ new Date();
+        shardInfo.from = this.normalizeUrl(updatedEntries[0].url);
+        shardInfo.to = this.normalizeUrl(updatedEntries[updatedEntries.length - 1].url);
+      }
+    }
+    const manifestFilename = this.options.filename?.replace(/\.xml$/, "-manifest.json") || "sitemap-manifest.json";
+    await this.options.storage.write(
+      manifestFilename,
+      JSON.stringify(manifest, null, this.options.pretty ? 2 : 0)
+    );
+  }
+  applyChanges(entries, changes) {
+    const entryMap = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      entryMap.set(this.normalizeUrl(entry.url), entry);
+    }
+    for (const change of changes) {
+      const normalizedUrl = this.normalizeUrl(change.url);
+      if (change.type === "add" || change.type === "update") {
+        if (change.entry) {
+          entryMap.set(normalizedUrl, {
+            ...change.entry,
+            url: normalizedUrl
+          });
+        }
+      } else if (change.type === "remove") {
+        entryMap.delete(normalizedUrl);
+      }
+    }
+    return Array.from(entryMap.values()).sort(
+      (a, b) => this.normalizeUrl(a.url).localeCompare(this.normalizeUrl(b.url))
+    );
   }
-  /**
-   * 將 AsyncIterable 轉換為陣列
-   */
   async toArray(iterable) {
     const array = [];
     for await (const item of iterable) {
@@ -1199,6 +1502,15 @@ var MemorySitemapStorage = class {
   async read(filename) {
     return this.files.get(filename) || null;
   }
+  async readStream(filename) {
+    const content = this.files.get(filename);
+    if (content === void 0) {
+      return null;
+    }
+    return (async function* () {
+      yield content;
+    })();
+  }
   async exists(filename) {
     return this.files.has(filename);
   }
@@ -1942,6 +2254,30 @@ var GCPSitemapStorage = class {
       throw error;
     }
   }
+  async readStream(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 stream = file.createReadStream();
+      return (async function* () {
+        const decoder = new TextDecoder();
+        for await (const chunk of stream) {
+          yield decoder.decode(chunk, { stream: true });
+        }
+        yield decoder.decode();
+      })();
+    } catch (error) {
+      if (error.code === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
   async exists(filename) {
     try {
       const { bucket } = await this.getStorageClient();
@@ -1964,7 +2300,7 @@ var GCPSitemapStorage = class {
       return this.write(filename, content);
     }
     const { bucket } = await this.getStorageClient();
-    const id = shadowId || `shadow-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+    const id = shadowId || `shadow-${Date.now()}-${crypto.randomUUID()}`;
     const shadowKey = this.getKey(`${filename}.shadow.${id}`);
     const file = bucket.file(shadowKey);
     await file.save(content, {
@@ -2236,6 +2572,34 @@ var S3SitemapStorage = class {
       throw error;
     }
   }
+  async readStream(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 body = response.Body;
+      return (async function* () {
+        const decoder = new TextDecoder();
+        for await (const chunk of body) {
+          yield decoder.decode(chunk, { stream: true });
+        }
+        yield decoder.decode();
+      })();
+    } catch (error) {
+      if (error.name === "NoSuchKey" || error.$metadata?.httpStatusCode === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
   async exists(filename) {
     try {
       const s3 = await this.getS3Client();
@@ -2265,7 +2629,7 @@ var S3SitemapStorage = class {
       return this.write(filename, content);
     }
     const s3 = await this.getS3Client();
-    const id = shadowId || `shadow-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+    const id = shadowId || `shadow-${Date.now()}-${crypto.randomUUID()}`;
     const shadowKey = this.getKey(`${filename}.shadow.${id}`);
     await s3.client.send(
       new s3.PutObjectCommand({