uomtiles 0.1.2 → 0.1.3

package/.output/server/chunks/_/map-layer-update-manager.mjs

@@ -0,0 +1,770 @@
+import { c as createError, u as useRuntimeConfig } from '../nitro/nitro.mjs';
+import { createHash, randomUUID } from 'node:crypto';
+import { resolve, dirname } from 'node:path';
+import { m as makeDjiBaseGrid, s as splitDjiCell, D as DJI_MAX_SPLIT_DEPTH, b as DJI_SATURATION_LIMIT, c as DJI_OVERLAP_DEGREES, d as DJI_TARGET_DIAGONAL_KM, e as DJI_ROW_DEGREES, f as DJI_LEVELS, h as DJI_ENDPOINT, i as DJI_COVERAGE, p as parseDjiSnapshot, j as assertAntigravityDatabaseSchema, k as getDjiNfzInfo, l as getAntigravityNfzInfo, M as MAP_LAYER_SNAPSHOT_FILENAMES } from './antigravity-nfz.mjs';
+import { mkdir, stat, writeFile, rename, unlink, readFile, rm, readdir } from 'node:fs/promises';
+import { DatabaseSync } from 'node:sqlite';
+import { ProxyAgent, fetch } from 'undici';
+import { s as serverDataDirectory } from './data-directory.mjs';
+
+const DEFAULT_DJI_CONCURRENCY = 12;
+const DJI_RESUME_MAX_AGE_MS = 6 * 60 * 60 * 1e3;
+const ANTIGRAVITY_VERSION_ENDPOINT = "https://service.aerovista360.com/geo/open/getGeoDBInfo";
+const ANTIGRAVITY_DOWNLOAD_HOST = "static.aerovista360.com";
+const ANTIGRAVITY_SNAPSHOT_TYPE = 0;
+const MAX_ANTIGRAVITY_MANIFEST_BYTES = 1024 * 1024;
+const MAX_ANTIGRAVITY_SNAPSHOT_BYTES = 64 * 1024 * 1024;
+async function updateDjiSnapshot(options) {
+  const context = createUpdateContext(options);
+  try {
+    await mkdir(context.outputDirectory, { recursive: true });
+    return await downloadDjiSnapshot(context, snapshotDestination(context.outputDirectory, options.destinationPath, "dji-nfz.json"));
+  } finally {
+    await closeUpdateContext(context);
+  }
+}
+async function updateAntigravitySnapshot(options) {
+  const context = createUpdateContext(options);
+  try {
+    await mkdir(context.outputDirectory, { recursive: true });
+    return await downloadAntigravitySnapshot(context, snapshotDestination(context.outputDirectory, options.destinationPath, "antigravity-nfz.sqlite"));
+  } finally {
+    await closeUpdateContext(context);
+  }
+}
+function createUpdateContext(options) {
+  var _a, _b;
+  if (!options || typeof options.outputDirectory !== "string" || !options.outputDirectory.trim()) {
+    throw new RangeError("Map layer output directory cannot be empty");
+  }
+  const outputDirectory = resolve(options.outputDirectory);
+  const djiConcurrency = (_a = options.djiConcurrency) != null ? _a : DEFAULT_DJI_CONCURRENCY;
+  const djiResume = (_b = options.djiResume) != null ? _b : true;
+  if (!Number.isInteger(djiConcurrency) || djiConcurrency <= 0) throw new RangeError("DJI concurrency must be a positive integer");
+  const proxy = process.env.HTTPS_PROXY || process.env.HTTP_PROXY || process.env.https_proxy || process.env.http_proxy;
+  return {
+    outputDirectory,
+    djiRawDirectory: resolve(options.djiRawDirectory || resolve(outputDirectory, "dji-raw")),
+    djiConcurrency,
+    djiResume,
+    onProgress: options.onProgress,
+    ...proxy ? { dispatcher: new ProxyAgent(proxy) } : {}
+  };
+}
+async function closeUpdateContext(context) {
+  var _a;
+  await ((_a = context.dispatcher) == null ? void 0 : _a.close());
+}
+async function downloadDjiSnapshot(context, destination = resolve(context.outputDirectory, "dji-nfz.json")) {
+  await mkdir(dirname(destination), { recursive: true });
+  const cells = makeDjiBaseGrid().map(queryCell);
+  reportProgress(context, "dji-nfz", "checking", 0, 1, "\u6B63\u5728\u8FDE\u63A5 DJI Flysafe");
+  const rawRootDirectory = context.djiRawDirectory;
+  await mkdir(rawRootDirectory, { recursive: true });
+  const session = await openDjiUpdateSession(rawRootDirectory, context.djiResume);
+  const rawDirectory = session.directory;
+  await mkdir(rawDirectory, { recursive: true });
+  reportProgress(context, "dji-nfz", "downloading", 0, cells.length, "\u6B63\u5728\u68C0\u67E5 DJI Flysafe \u533A\u57DF\u5206\u7247");
+  const areas = /* @__PURE__ */ new Map();
+  const serializedAreas = /* @__PURE__ */ new Map();
+  let completed = 0;
+  let queryCount = 0;
+  let occurrenceCount = 0;
+  let conflictingDuplicateCount = 0;
+  let resumedQueryCount = 0;
+  let saturatedQueryCount = 0;
+  let maximumLeafResultCount = 0;
+  const querySummaries = [];
+  const startedAtMilliseconds = Date.now();
+  const startedAt = session.startedAt;
+  async function processBatch(batch) {
+    const saturated = new Array(batch.length);
+    const workerCount = Math.min(context.djiConcurrency, batch.length);
+    const workers = Array.from({ length: workerCount }, async (_, worker) => {
+      for (let index = worker; index < batch.length; index += workerCount) {
+        const cell = batch[index];
+        const result = await readOrFetchDjiCell(cell, rawDirectory, context.djiResume, context.dispatcher);
+        if (result.resumed) resumedQueryCount++;
+        occurrenceCount += result.areas.length;
+        for (const area of result.areas) {
+          const key = djiAreaKey(area);
+          const serialized = JSON.stringify(area);
+          if (!areas.has(key)) {
+            areas.set(key, area);
+            serializedAreas.set(key, serialized);
+          } else if (serializedAreas.get(key) !== serialized) {
+            conflictingDuplicateCount++;
+          }
+        }
+        const isSaturated = result.areas.length >= DJI_SATURATION_LIMIT;
+        querySummaries.push({
+          id: djiCellName(cell),
+          ...cell.parentId ? { parentId: cell.parentId } : {},
+          depth: cell.depth,
+          bounds: [cell.west, cell.south, cell.east, cell.north],
+          resultCount: result.areas.length,
+          saturated: isSaturated
+        });
+        if (isSaturated) {
+          if (cell.depth >= DJI_MAX_SPLIT_DEPTH) throw new Error(`DJI saturated cell reached maximum split depth: ${djiCellName(cell)}`);
+          saturated[index] = cell;
+          saturatedQueryCount++;
+        } else {
+          maximumLeafResultCount = Math.max(maximumLeafResultCount, result.areas.length);
+        }
+        completed++;
+        queryCount++;
+        reportProgress(
+          context,
+          "dji-nfz",
+          "downloading",
+          completed,
+          cells.length + saturatedQueryCount * 4,
+          `\u5DF2\u68C0\u67E5 ${completed} \u4E2A DJI Flysafe \u533A\u57DF\u5206\u7247`
+        );
+        if (completed % 20 === 0) {
+          const seconds = ((Date.now() - startedAtMilliseconds) / 1e3).toFixed(1);
+          process.stderr.write(`DJI FlySafe: ${completed} queries, ${areas.size} unique areas, ${seconds}s
+`);
+        }
+      }
+    });
+    await Promise.all(workers);
+    return saturated.filter((cell) => Boolean(cell));
+  }
+  let frontier = cells;
+  while (frontier.length) {
+    const saturated = await processBatch(frontier);
+    frontier = saturated.flatMap((cell) => splitDjiCell(queryCell(cell)).map(queryCell));
+    if (frontier.length) process.stderr.write(`DJI FlySafe: splitting ${saturated.length} saturated queries into ${frontier.length} children
+`);
+  }
+  if (conflictingDuplicateCount) throw new Error(`DJI returned ${conflictingDuplicateCount} conflicting duplicate areas`);
+  reportProgress(context, "dji-nfz", "validating", 0, 1, "\u6B63\u5728\u6821\u9A8C DJI Flysafe \u6570\u636E");
+  const sortedAreas = [...areas.values()].sort((left, right) => {
+    var _a, _b;
+    return String((_a = left == null ? void 0 : left.area_id) != null ? _a : "").localeCompare(String((_b = right == null ? void 0 : right.area_id) != null ? _b : ""), "en", { numeric: true });
+  });
+  const areasJson = JSON.stringify(sortedAreas);
+  const areasSha256 = createHash("sha256").update(areasJson).digest("hex");
+  const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const snapshot = {
+    formatVersion: 2,
+    source: "DJI FlySafe",
+    scope: "global",
+    startedAt,
+    completedAt,
+    fetchedAt: completedAt,
+    coverage: DJI_COVERAGE,
+    query: {
+      algorithmVersion: "global-adaptive-grid-v1",
+      endpoint: DJI_ENDPOINT,
+      zonesMode: "flysafe_website",
+      drone: "dji-mavic-3",
+      levels: DJI_LEVELS,
+      rowDegrees: DJI_ROW_DEGREES,
+      targetDiagonalKm: DJI_TARGET_DIAGONAL_KM,
+      overlapDegrees: DJI_OVERLAP_DEGREES,
+      saturationLimit: DJI_SATURATION_LIMIT,
+      maxSplitDepth: DJI_MAX_SPLIT_DEPTH,
+      queryCount,
+      baseQueryCount: cells.length,
+      recursiveQueryCount: queryCount - cells.length,
+      saturatedQueryCount,
+      maximumLeafResultCount,
+      allLeafQueriesBelowSaturationLimit: true,
+      occurrenceCount,
+      uniqueAreaCount: sortedAreas.length,
+      duplicateOccurrences: occurrenceCount - sortedAreas.length,
+      conflictingDuplicateCount,
+      resumedQueryCount,
+      queries: querySummaries.sort((left, right) => left.id.localeCompare(right.id, "en", { numeric: true }))
+    },
+    areasSha256,
+    areas: sortedAreas
+  };
+  const contents = `${JSON.stringify(snapshot)}
+`;
+  const existing = await readDjiSnapshotIdentity(destination);
+  if ((existing == null ? void 0 : existing.areasSha256) === areasSha256) {
+    reportProgress(context, "dji-nfz", "writing", 0, 1, "\u6B63\u5728\u8BB0\u5F55 DJI Flysafe \u68C0\u67E5\u65F6\u95F4");
+    await atomicWrite(destination, contents);
+    await completeDjiUpdateSession(session);
+    reportProgress(context, "dji-nfz", "writing", 1, 1, "\u5DF2\u68C0\u67E5\uFF0C\u533A\u57DF\u6570\u636E\u672A\u53D8\u5316");
+    return {
+      path: destination,
+      rawDirectory: rawRootDirectory,
+      queries: queryCount,
+      areas: sortedAreas.length,
+      bytes: Buffer.byteLength(contents),
+      sha256: createHash("sha256").update(contents).digest("hex"),
+      areasSha256,
+      fetchedAt: completedAt,
+      updated: false,
+      noUpdate: true
+    };
+  }
+  reportProgress(context, "dji-nfz", "writing", 0, 1, "\u6B63\u5728\u5199\u5165 DJI Flysafe \u5FEB\u7167");
+  await atomicWrite(destination, contents);
+  await completeDjiUpdateSession(session);
+  reportProgress(context, "dji-nfz", "writing", 1, 1, "DJI Flysafe \u66F4\u65B0\u5B8C\u6210");
+  return {
+    path: destination,
+    rawDirectory: rawRootDirectory,
+    queries: queryCount,
+    areas: snapshot.areas.length,
+    bytes: (await stat(destination)).size,
+    sha256: createHash("sha256").update(contents).digest("hex"),
+    areasSha256,
+    fetchedAt: completedAt,
+    updated: true,
+    noUpdate: false
+  };
+}
+async function readOrFetchDjiCell(cell, rawDirectory, resume, dispatcher) {
+  const url = djiRequestUrl(cell);
+  const requestHash = createHash("sha256").update(url.href).digest("hex").slice(0, 16);
+  const rawPath = resolve(rawDirectory, `${djiCellName(cell)}_${requestHash}.json`);
+  if (resume) {
+    try {
+      const payload = JSON.parse(await readFile(rawPath, "utf8"));
+      return { areas: djiResponseAreas(payload), resumed: true };
+    } catch {
+    }
+  }
+  let lastError;
+  for (let attempt = 1; attempt <= 7; attempt++) {
+    try {
+      const response = await fetch(url, {
+        signal: AbortSignal.timeout(6e4),
+        headers: { accept: "application/json", "user-agent": "Mozilla/5.0 uomtiles-map-layer-updater/1.0" },
+        ...dispatcher ? { dispatcher } : {}
+      });
+      if (!response.ok) {
+        const error = new Error(`HTTP ${response.status}`);
+        error.retryAfterMilliseconds = retryAfterMilliseconds(response.headers.get("retry-after"));
+        throw error;
+      }
+      const declaredLength = Number(response.headers.get("content-length") || 0);
+      if (declaredLength > 16 * 1024 * 1024) throw new Error("DJI response is unexpectedly large");
+      const body = await response.text();
+      if (Buffer.byteLength(body) > 16 * 1024 * 1024) throw new Error("DJI response is unexpectedly large");
+      const payload = JSON.parse(body);
+      const responseAreas = djiResponseAreas(payload);
+      await atomicWrite(rawPath, body);
+      return { areas: responseAreas, resumed: false };
+    } catch (error) {
+      lastError = error;
+      if (attempt < 7) {
+        const backoff = Math.min(2e4, 600 * 2 ** (attempt - 1)) + Math.floor(Math.random() * 500);
+        const retryAfter = error instanceof Error && "retryAfterMilliseconds" in error ? Number(error.retryAfterMilliseconds || 0) : 0;
+        const delay = Math.max(backoff, retryAfter);
+        await new Promise((resolvePromise) => setTimeout(resolvePromise, delay));
+      }
+    }
+  }
+  throw new Error(`DJI cell ${djiCellName(cell)} failed: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
+}
+function djiRequestUrl(cell) {
+  const url = new URL(DJI_ENDPOINT);
+  url.searchParams.set("ltlat", String(cell.north));
+  url.searchParams.set("ltlng", String(cell.west));
+  url.searchParams.set("rblat", String(cell.south));
+  url.searchParams.set("rblng", String(cell.east));
+  url.searchParams.set("zones_mode", "flysafe_website");
+  url.searchParams.set("drone", "dji-mavic-3");
+  url.searchParams.set("level", DJI_LEVELS);
+  return url;
+}
+function retryAfterMilliseconds(value) {
+  if (!value) return 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+  const date = Date.parse(value);
+  return Number.isFinite(date) ? Math.max(0, date - Date.now()) : 0;
+}
+function djiResponseAreas(payload) {
+  if (!isRecord(payload) || payload.code !== 0 || !isRecord(payload.data) || !Array.isArray(payload.data.areas)) {
+    throw new Error(djiResponseError(payload));
+  }
+  if (!payload.data.areas.every(isRecord)) throw new Error("invalid DJI response areas");
+  return payload.data.areas;
+}
+function djiResponseError(payload) {
+  if (!isRecord(payload)) return "invalid DJI response";
+  if (payload.data !== void 0 && payload.data !== null) return String(payload.data);
+  if (isRecord(payload.message) && typeof payload.message.english === "string") return payload.message.english;
+  return "invalid DJI response";
+}
+function djiCellName(cell) {
+  return cell.id;
+}
+function djiAreaKey(area) {
+  if ((area == null ? void 0 : area.area_id) === void 0 || (area == null ? void 0 : area.area_id) === null || String(area.area_id).trim() === "") {
+    throw new Error("DJI response area is missing area_id");
+  }
+  return `id:${area.area_id}`;
+}
+async function downloadAntigravitySnapshot(context, destination = resolve(context.outputDirectory, "antigravity-nfz.sqlite")) {
+  await mkdir(dirname(destination), { recursive: true });
+  const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+  reportProgress(context, "antigravity-nfz", "checking", 0, 1, "\u6B63\u5728\u68C0\u67E5 Antigravity \u5728\u7EBF\u7248\u672C");
+  const manifest = await fetchAntigravityManifest(context);
+  const current = await inspectAntigravitySnapshot(destination).catch(() => null);
+  if ((current == null ? void 0 : current.version) === manifest.versionCode) {
+    reportProgress(context, "antigravity-nfz", "checking", 1, 1, "\u65E0\u65B0\u7248\u672C");
+    return {
+      path: destination,
+      bytes: current.bytes,
+      sha256: current.sha256,
+      sqliteSha256: current.sha256,
+      fences: current.fences,
+      version: current.version,
+      releasedAt: current.releasedAt,
+      expiresAt: current.expiresAt,
+      fetchedAt,
+      updated: false,
+      noUpdate: true
+    };
+  }
+  const wrapped = await downloadAntigravityFile(context, manifest);
+  reportProgress(context, "antigravity-nfz", "validating", 0, 1, "\u6B63\u5728\u6821\u9A8C Antigravity \u6570\u636E");
+  const databaseBytes = extractAntigravitySqlite(wrapped, manifest);
+  const temporary = `${destination}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await writeFile(temporary, databaseBytes, { mode: 420 });
+    const candidate = await inspectAntigravitySnapshot(temporary);
+    if (candidate.version !== manifest.versionCode) {
+      throw new Error(`Antigravity \u7248\u672C\u6821\u9A8C\u5931\u8D25\uFF1A\u9884\u671F ${manifest.versionCode}\uFF0C\u5B9E\u9645 ${candidate.version || "\u672A\u77E5"}`);
+    }
+    reportProgress(context, "antigravity-nfz", "writing", 0, 1, "\u6B63\u5728\u5199\u5165 Antigravity \u5FEB\u7167");
+    await rename(temporary, destination);
+    reportProgress(context, "antigravity-nfz", "writing", 1, 1, "Antigravity \u66F4\u65B0\u5B8C\u6210");
+    return {
+      path: destination,
+      bytes: candidate.bytes,
+      sha256: candidate.sha256,
+      sqliteSha256: candidate.sha256,
+      fences: candidate.fences,
+      version: candidate.version,
+      releasedAt: candidate.releasedAt || manifest.releasedAt,
+      expiresAt: candidate.expiresAt || manifest.expiresAt,
+      fetchedAt,
+      updated: (current == null ? void 0 : current.sha256) !== candidate.sha256,
+      noUpdate: (current == null ? void 0 : current.sha256) === candidate.sha256
+    };
+  } finally {
+    await unlink(temporary).catch(() => {
+    });
+  }
+}
+async function fetchAntigravityManifest(context) {
+  const response = await fetch(ANTIGRAVITY_VERSION_ENDPOINT, {
+    method: "POST",
+    redirect: "error",
+    signal: AbortSignal.timeout(3e4),
+    headers: {
+      accept: "application/json",
+      "content-type": "application/json",
+      "user-agent": "uomtiles-map-layer-updater/1.0"
+    },
+    body: JSON.stringify({ snapshotType: ANTIGRAVITY_SNAPSHOT_TYPE }),
+    ...context.dispatcher ? { dispatcher: context.dispatcher } : {}
+  });
+  if (!response.ok) throw new Error(`Antigravity \u7248\u672C\u68C0\u67E5\u5931\u8D25\uFF1AHTTP ${response.status}`);
+  const declaredLength = Number(response.headers.get("content-length") || 0);
+  if (declaredLength > MAX_ANTIGRAVITY_MANIFEST_BYTES) throw new Error("Antigravity \u7248\u672C\u54CD\u5E94\u8FC7\u5927");
+  const body = await response.text();
+  if (Buffer.byteLength(body) > MAX_ANTIGRAVITY_MANIFEST_BYTES) throw new Error("Antigravity \u7248\u672C\u54CD\u5E94\u8FC7\u5927");
+  let payload;
+  try {
+    payload = JSON.parse(body);
+  } catch {
+    throw new Error("Antigravity \u7248\u672C\u54CD\u5E94\u683C\u5F0F\u65E0\u6548");
+  }
+  return parseAntigravityVersionManifest(payload);
+}
+function parseAntigravityVersionManifest(payload) {
+  var _a, _b, _c;
+  if (!isRecord(payload) || payload.code !== 0 || !isRecord(payload.data)) {
+    const message = isRecord(payload) && typeof payload.msg === "string" ? payload.msg : "\u54CD\u5E94\u683C\u5F0F\u65E0\u6548";
+    throw new Error(`Antigravity \u7248\u672C\u68C0\u67E5\u5931\u8D25\uFF1A${message}`);
+  }
+  const versionCode = (_a = optionalString(payload.data.versionCode)) == null ? void 0 : _a.trim();
+  const fileUrl = (_b = optionalString(payload.data.fileUrl)) == null ? void 0 : _b.trim();
+  const fileSize = Number(payload.data.fileSize);
+  const verifyToken = (_c = optionalString(payload.data.verifyToken)) == null ? void 0 : _c.trim().toLowerCase();
+  if (!versionCode || !/^[0-9][0-9A-Za-z._-]{1,63}$/.test(versionCode)) throw new Error("Antigravity \u7248\u672C\u53F7\u65E0\u6548");
+  if (!fileUrl) throw new Error("Antigravity \u4E0B\u8F7D\u5730\u5740\u7F3A\u5931");
+  validateAntigravityDownloadUrl(fileUrl);
+  if (!Number.isSafeInteger(fileSize) || fileSize < 4096 || fileSize > MAX_ANTIGRAVITY_SNAPSHOT_BYTES) {
+    throw new Error("Antigravity \u6587\u4EF6\u5927\u5C0F\u65E0\u6548");
+  }
+  if (!verifyToken || !/^[0-9a-f]{32}$/.test(verifyToken)) throw new Error("Antigravity \u6821\u9A8C\u4EE4\u724C\u65E0\u6548");
+  return {
+    versionCode,
+    fileUrl,
+    fileSize,
+    verifyToken,
+    releasedAt: optionalString(payload.data.releasedTime),
+    expiresAt: optionalString(payload.data.expiredTime)
+  };
+}
+function extractAntigravitySqlite(contents, manifest) {
+  const wrapped = Buffer.from(contents);
+  if (wrapped.length !== manifest.fileSize) throw new Error("Antigravity \u4E0B\u8F7D\u6587\u4EF6\u5927\u5C0F\u4E0E\u7248\u672C\u4FE1\u606F\u4E0D\u7B26");
+  const wrappedMd5 = createHash("md5").update(wrapped).digest("hex");
+  if (wrappedMd5 !== manifest.verifyToken.toLowerCase()) throw new Error("Antigravity \u4E0B\u8F7D\u6587\u4EF6\u6821\u9A8C\u5931\u8D25");
+  const marker = wrapped.indexOf(Buffer.from("SQLite format 3\0", "ascii"));
+  if (marker < 0) throw new Error("Antigravity \u6570\u636E\u4E2D\u672A\u627E\u5230 SQLite \u5FEB\u7167");
+  const databaseBytes = wrapped.subarray(marker);
+  if (databaseBytes.length < 4096 || databaseBytes.length % 4096 !== 0) {
+    throw new Error("Antigravity SQLite \u5FEB\u7167\u957F\u5EA6\u5F02\u5E38");
+  }
+  return Buffer.from(databaseBytes);
+}
+async function downloadAntigravityFile(context, manifest) {
+  let url = new URL(manifest.fileUrl);
+  let response;
+  for (let redirects = 0; ; redirects++) {
+    validateAntigravityDownloadUrl(url.href);
+    response = await fetch(url, {
+      redirect: "manual",
+      signal: AbortSignal.timeout(6e4),
+      headers: { accept: "application/octet-stream", "user-agent": "uomtiles-map-layer-updater/1.0" },
+      ...context.dispatcher ? { dispatcher: context.dispatcher } : {}
+    });
+    if (response.status < 300 || response.status >= 400) break;
+    if (redirects >= 3) throw new Error("Antigravity \u4E0B\u8F7D\u91CD\u5B9A\u5411\u8FC7\u591A");
+    const location = response.headers.get("location");
+    if (!location) throw new Error("Antigravity \u4E0B\u8F7D\u91CD\u5B9A\u5411\u65E0\u6548");
+    url = new URL(location, url);
+  }
+  if (!response.ok) throw new Error(`Antigravity \u4E0B\u8F7D\u5931\u8D25\uFF1AHTTP ${response.status}`);
+  const declaredLength = Number(response.headers.get("content-length") || 0);
+  if (declaredLength && declaredLength !== manifest.fileSize) throw new Error("Antigravity \u4E0B\u8F7D\u6587\u4EF6\u5927\u5C0F\u4E0E\u7248\u672C\u4FE1\u606F\u4E0D\u7B26");
+  if (!response.body) throw new Error("Antigravity \u4E0B\u8F7D\u54CD\u5E94\u4E3A\u7A7A");
+  const chunks = [];
+  let completed = 0;
+  reportProgress(context, "antigravity-nfz", "downloading", 0, manifest.fileSize, "\u6B63\u5728\u4E0B\u8F7D Antigravity \u6570\u636E");
+  for await (const chunk of response.body) {
+    const bytes = Buffer.from(chunk);
+    completed += bytes.length;
+    if (completed > manifest.fileSize || completed > MAX_ANTIGRAVITY_SNAPSHOT_BYTES) {
+      throw new Error("Antigravity \u4E0B\u8F7D\u6587\u4EF6\u8FC7\u5927");
+    }
+    chunks.push(bytes);
+    reportProgress(context, "antigravity-nfz", "downloading", completed, manifest.fileSize, "\u6B63\u5728\u4E0B\u8F7D Antigravity \u6570\u636E");
+  }
+  if (completed !== manifest.fileSize) throw new Error("Antigravity \u4E0B\u8F7D\u6587\u4EF6\u4E0D\u5B8C\u6574");
+  return Buffer.concat(chunks, completed);
+}
+function validateAntigravityDownloadUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("Antigravity \u4E0B\u8F7D\u5730\u5740\u4E0D\u53D7\u4FE1\u4EFB");
+  }
+  if (url.protocol !== "https:" || url.hostname !== ANTIGRAVITY_DOWNLOAD_HOST || url.port || url.username || url.password || !url.pathname.endsWith(".InstaCry")) {
+    throw new Error("Antigravity \u4E0B\u8F7D\u5730\u5740\u4E0D\u53D7\u4FE1\u4EFB");
+  }
+}
+async function inspectAntigravitySnapshot(path) {
+  var _a;
+  const contents = await readFile(path);
+  const database = new DatabaseSync(path, { readOnly: true });
+  try {
+    const integrity = (_a = database.prepare("PRAGMA integrity_check").get()) == null ? void 0 : _a.integrity_check;
+    if (integrity !== "ok") throw new Error(`Antigravity SQLite \u5B8C\u6574\u6027\u6821\u9A8C\u5931\u8D25\uFF1A${integrity}`);
+    assertAntigravityDatabaseSchema(database);
+    const version = database.prepare(`
+      SELECT version_code, released_time, expired_time
+      FROM version
+      WHERE COALESCE(is_deleted, 0) = 0
+      ORDER BY id DESC LIMIT 1
+    `).get();
+    const countRow = database.prepare("SELECT COUNT(*) AS count FROM fences WHERE is_valid = 1 AND is_deleted = 0").get();
+    const fences = Number((countRow == null ? void 0 : countRow.count) || 0);
+    if (!Number.isSafeInteger(fences) || fences <= 0) throw new Error("Antigravity \u6709\u6548\u533A\u57DF\u6570\u91CF\u65E0\u6548");
+    return {
+      bytes: contents.length,
+      sha256: createHash("sha256").update(contents).digest("hex"),
+      fences,
+      version: optionalString(version == null ? void 0 : version.version_code),
+      releasedAt: optionalString(version == null ? void 0 : version.released_time),
+      expiresAt: optionalString(version == null ? void 0 : version.expired_time)
+    };
+  } finally {
+    database.close();
+  }
+}
+function queryCell(cell) {
+  const [west, south, east, north] = cell.bounds;
+  return { ...cell, west, south, east, north };
+}
+const DJI_UPDATE_FINGERPRINT = createHash("sha256").update(JSON.stringify({
+  algorithmVersion: "global-adaptive-grid-v1",
+  endpoint: DJI_ENDPOINT,
+  coverage: DJI_COVERAGE,
+  levels: DJI_LEVELS,
+  rowDegrees: DJI_ROW_DEGREES,
+  targetDiagonalKm: DJI_TARGET_DIAGONAL_KM,
+  overlapDegrees: DJI_OVERLAP_DEGREES,
+  saturationLimit: DJI_SATURATION_LIMIT,
+  maxSplitDepth: DJI_MAX_SPLIT_DEPTH
+})).digest("hex");
+async function openDjiUpdateSession(rawRootDirectory, resume = true) {
+  await mkdir(rawRootDirectory, { recursive: true });
+  const manifestPath = resolve(rawRootDirectory, "active-session.json");
+  if (resume) {
+    try {
+      const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+      if (isDjiSessionManifest(manifest) && manifest.fingerprint === DJI_UPDATE_FINGERPRINT && isRecentDjiSession(manifest.startedAt)) {
+        const session = {
+          manifestPath,
+          sessionId: manifest.sessionId,
+          startedAt: manifest.startedAt,
+          directory: resolve(rawRootDirectory, manifest.sessionId)
+        };
+        await pruneDjiUpdateSessions(rawRootDirectory, session.sessionId);
+        return session;
+      }
+    } catch {
+    }
+  }
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const sessionId = `${startedAt.replace(/[:.]/g, "-")}-${randomUUID()}`;
+  await atomicWrite(manifestPath, `${JSON.stringify({ fingerprint: DJI_UPDATE_FINGERPRINT, sessionId, startedAt })}
+`);
+  await pruneDjiUpdateSessions(rawRootDirectory, sessionId);
+  return { manifestPath, sessionId, startedAt, directory: resolve(rawRootDirectory, sessionId) };
+}
+async function completeDjiUpdateSession(session) {
+  await rm(session.directory, { recursive: true, force: true }).catch(() => {
+  });
+  try {
+    const manifest = JSON.parse(await readFile(session.manifestPath, "utf8"));
+    if (isDjiSessionManifest(manifest) && manifest.sessionId === session.sessionId) await unlink(session.manifestPath);
+  } catch (error) {
+    if ((error == null ? void 0 : error.code) !== "ENOENT") throw error;
+  }
+}
+async function pruneDjiUpdateSessions(rawRootDirectory, keepSessionId) {
+  const entries = await readdir(rawRootDirectory, { withFileTypes: true }).catch(() => []);
+  await Promise.all(entries.filter((entry) => entry.isDirectory() && entry.name !== keepSessionId && isDjiSessionId(entry.name)).map((entry) => rm(resolve(rawRootDirectory, entry.name), { recursive: true, force: true }).catch(() => {
+  })));
+}
+function isRecentDjiSession(startedAt) {
+  const age = Date.now() - Date.parse(startedAt);
+  return Number.isFinite(age) && age >= 0 && age <= DJI_RESUME_MAX_AGE_MS;
+}
+function isDjiSessionId(value) {
+  return /^[0-9TZa-f-]+$/.test(value);
+}
+function isDjiSessionManifest(value) {
+  return isRecord(value) && typeof value.fingerprint === "string" && typeof value.sessionId === "string" && isDjiSessionId(value.sessionId) && typeof value.startedAt === "string" && Number.isFinite(Date.parse(value.startedAt));
+}
+async function atomicWrite(destination, data) {
+  const temporary = `${destination}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(temporary, data, { mode: 420 });
+  await rename(temporary, destination);
+}
+function snapshotDestination(outputDirectory, configuredPath, filename) {
+  const configured = configuredPath == null ? void 0 : configuredPath.trim();
+  return configured ? resolve(configured) : resolve(outputDirectory, filename);
+}
+async function readDjiSnapshotIdentity(path) {
+  try {
+    const contents = await readFile(path, "utf8");
+    const snapshot = parseDjiSnapshot(contents);
+    const areasSha256 = snapshot.areasSha256;
+    return {
+      areasSha256,
+      sha256: createHash("sha256").update(contents).digest("hex"),
+      bytes: Buffer.byteLength(contents),
+      fetchedAt: snapshot.fetchedAt
+    };
+  } catch {
+    return null;
+  }
+}
+function reportProgress(context, source, phase, completed, total, message) {
+  var _a;
+  (_a = context.onProgress) == null ? void 0 : _a.call(context, { source, phase, completed, total, message });
+}
+function optionalString(value) {
+  return value === void 0 || value === null ? void 0 : String(value);
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+const VALID_SOURCES = ["dji-nfz", "antigravity-nfz"];
+const tasks = /* @__PURE__ */ new Map();
+const running = /* @__PURE__ */ new Map();
+function isSource(value) {
+  return typeof value === "string" && VALID_SOURCES.includes(value);
+}
+function assertMapLayerUpdateSource(value) {
+  if (!isSource(value)) throw createError({ statusCode: 404, message: "\u5730\u56FE\u53E0\u52A0\u5C42\u4E0D\u5B58\u5728" });
+  return value;
+}
+function idleTask(source) {
+  return {
+    source,
+    taskId: null,
+    status: "idle",
+    phase: null,
+    completed: 0,
+    total: 0,
+    percent: null,
+    message: "\u5C1A\u672A\u66F4\u65B0",
+    startedAt: null,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    finishedAt: null
+  };
+}
+function view(task, source) {
+  if (!task) return idleTask(source);
+  return {
+    source: task.source,
+    taskId: task.taskId,
+    status: task.status,
+    phase: task.phase,
+    completed: task.completed,
+    total: task.total,
+    percent: task.percent,
+    message: task.message,
+    startedAt: task.startedAt,
+    updatedAt: task.updatedAt,
+    finishedAt: task.finishedAt,
+    ...task.version ? { version: task.version } : {},
+    ...task.contentHash ? { contentHash: task.contentHash } : {},
+    ...task.error ? { error: task.error } : {}
+  };
+}
+function getMapLayerUpdate(source) {
+  return view(tasks.get(source), source);
+}
+function startMapLayerUpdate(source) {
+  const active = running.get(source);
+  if (active) return view(active, source);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const task = {
+    source,
+    taskId: randomUUID(),
+    status: "running",
+    phase: "checking",
+    completed: 0,
+    total: 0,
+    percent: null,
+    message: source === "dji-nfz" ? "\u6B63\u5728\u68C0\u67E5 DJI Flysafe \u5728\u7EBF\u6570\u636E" : "\u6B63\u5728\u68C0\u67E5 Antigravity \u5728\u7EBF\u6570\u636E",
+    startedAt: now,
+    updatedAt: now,
+    finishedAt: null
+  };
+  tasks.set(source, task);
+  running.set(source, task);
+  void execute(task);
+  return view(task, source);
+}
+function updateProgress(task, progress) {
+  const phase = progress.phase;
+  const completed = nonNegativeNumber(progress.completed);
+  const total = nonNegativeNumber(progress.total);
+  task.phase = phase;
+  task.completed = completed;
+  task.total = total;
+  task.percent = total > 0 ? Math.min(100, Math.max(0, Math.round(completed / total * 100))) : null;
+  task.message = progress.message.trim() || phaseMessage(task.source, phase);
+  task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+}
+async function execute(task) {
+  const before = await sourceIdentity(task.source);
+  try {
+    const result = task.source === "dji-nfz" ? await runDji(task) : await runAntigravity(task);
+    const after = await sourceIdentity(task.source);
+    if (result.updated !== true && result.noUpdate !== true) {
+      throw new Error(`${mapLayerSourceLabel(task.source)} \u66F4\u65B0\u5668\u672A\u8FD4\u56DE\u6709\u6548\u5B8C\u6210\u72B6\u6001`);
+    }
+    const resultContentHash = snapshotResultContentHash(result);
+    if (resultContentHash && (after == null ? void 0 : after.contentHash) && resultContentHash !== after.contentHash) {
+      throw new Error(`${mapLayerSourceLabel(task.source)} \u5FEB\u7167\u5199\u5165\u540E\u6821\u9A8C\u5931\u8D25`);
+    }
+    const unchanged = result.noUpdate === true || result.updated === false || Boolean((before == null ? void 0 : before.contentHash) && resultContentHash && before.contentHash === resultContentHash);
+    task.version = ("version" in result ? result.version : void 0) || result.fetchedAt || (after == null ? void 0 : after.version);
+    task.contentHash = resultContentHash || (after == null ? void 0 : after.contentHash) || result.sha256;
+    task.completed = task.total > 0 ? task.total : 1;
+    task.total = task.total > 0 ? task.total : 1;
+    task.percent = 100;
+    task.phase = "writing";
+    task.status = unchanged ? "no-update" : "completed";
+    task.message = unchanged ? "\u5DF2\u68C0\u67E5\uFF0C\u533A\u57DF\u6570\u636E\u672A\u53D8\u5316" : before ? "\u66F4\u65B0\u5B8C\u6210" : "\u4E0B\u8F7D\u5B8C\u6210";
+    task.error = void 0;
+  } catch (error) {
+    task.status = "failed";
+    task.phase = null;
+    task.percent = null;
+    task.error = error instanceof Error ? error.message : String(error);
+    task.message = "\u66F4\u65B0\u5931\u8D25";
+  } finally {
+    task.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    task.updatedAt = task.finishedAt;
+    if (running.get(task.source) === task) running.delete(task.source);
+  }
+}
+function snapshotResultContentHash(result) {
+  return "areasSha256" in result ? result.areasSha256 : result.sha256;
+}
+function mapLayerSourceLabel(source) {
+  return source === "dji-nfz" ? "DJI Flysafe" : "Antigravity";
+}
+async function runDji(task) {
+  const location = updateLocation("dji-nfz");
+  return updateDjiSnapshot({
+    ...location,
+    djiRawDirectory: resolve(location.outputDirectory, "dji-raw"),
+    onProgress: (progress) => updateProgress(task, progress)
+  });
+}
+async function runAntigravity(task) {
+  return updateAntigravitySnapshot({
+    ...updateLocation("antigravity-nfz"),
+    onProgress: (progress) => updateProgress(task, progress)
+  });
+}
+async function sourceIdentity(source) {
+  try {
+    if (source === "dji-nfz") {
+      const info2 = await getDjiNfzInfo();
+      return { version: info2.version, contentHash: info2.areasSha256 };
+    }
+    const info = await getAntigravityNfzInfo();
+    return { version: info.version, contentHash: info.sqliteSha256 };
+  } catch {
+    return null;
+  }
+}
+function updateLocation(source) {
+  const config = useRuntimeConfig();
+  const configured = source === "dji-nfz" ? String(config.djiNfzPath || "").trim() : String(config.antigravityNfzPath || "").trim();
+  if (configured) {
+    const destinationPath = resolve(configured);
+    return { outputDirectory: dirname(destinationPath), destinationPath };
+  }
+  const filename = source === "dji-nfz" ? MAP_LAYER_SNAPSHOT_FILENAMES.dji : MAP_LAYER_SNAPSHOT_FILENAMES.antigravity;
+  const outputDirectory = resolve(serverDataDirectory(), "map-layers");
+  return { outputDirectory, destinationPath: resolve(outputDirectory, filename) };
+}
+function phaseMessage(source, phase) {
+  const name = source === "dji-nfz" ? "DJI Flysafe" : "Antigravity";
+  return phase === "checking" ? `\u6B63\u5728\u68C0\u67E5 ${name} \u5728\u7EBF\u7248\u672C` : phase === "downloading" ? `\u6B63\u5728\u4E0B\u8F7D ${name} \u6570\u636E` : phase === "validating" ? `\u6B63\u5728\u6821\u9A8C ${name} \u6570\u636E` : `\u6B63\u5728\u5199\u5165 ${name} \u5FEB\u7167`;
+}
+function nonNegativeNumber(value) {
+  const number = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(number) && number >= 0 ? Math.floor(number) : 0;
+}
+
+export { assertMapLayerUpdateSource as a, getMapLayerUpdate as g, startMapLayerUpdate as s };
+//# sourceMappingURL=map-layer-update-manager.mjs.map