uomtiles 0.1.2 → 0.1.3

package/.output/server/chunks/_/antigravity-nfz.mjs

@@ -0,0 +1,629 @@
+import { u as useRuntimeConfig } from '../nitro/nitro.mjs';
+import { stat, readFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { s as serverDataDirectory } from './data-directory.mjs';
+import { DatabaseSync } from 'node:sqlite';
+import { resolve } from 'node:path';
+
+const MAP_LAYER_SNAPSHOT_FILENAMES = {
+  dji: "dji-nfz.json",
+  antigravity: "antigravity-nfz.sqlite"
+};
+function resolveMapLayerSnapshotPath(options) {
+  var _a;
+  const explicitPath = (_a = options.explicitPath) == null ? void 0 : _a.trim();
+  if (explicitPath) return resolve(explicitPath);
+  return resolve(options.dataDir, "map-layers", options.filename);
+}
+
+const DJI_ENDPOINT = "https://flysafe-api.dji.com/api/qep/geo/feedback/areas/in_rectangle";
+const DJI_LEVELS = "0,1,2,3,7,8,10";
+const DJI_COVERAGE = { west: -180, south: -90, east: 180, north: 90 };
+const DJI_ROW_DEGREES = 5;
+const DJI_TARGET_DIAGONAL_KM = 780;
+const DJI_OVERLAP_DEGREES = 0.01;
+const DJI_SATURATION_LIMIT = 1e3;
+const DJI_MAX_SPLIT_DEPTH = 8;
+function makeDjiBaseGrid() {
+  const cells = [];
+  let row = 0;
+  for (let south = DJI_COVERAGE.south; south < DJI_COVERAGE.north - 1e-10; south += DJI_ROW_DEGREES, row++) {
+    const north = Math.min(DJI_COVERAGE.north, south + DJI_ROW_DEGREES);
+    const verticalKm = (north - south) * 111.2;
+    const horizontalKm = Math.sqrt(Math.max(1, DJI_TARGET_DIAGONAL_KM ** 2 - verticalKm ** 2));
+    const maxCosine = Math.max(Math.cos(south * Math.PI / 180), Math.cos(north * Math.PI / 180), 0.02);
+    const longitudeDegrees = Math.min(60, horizontalKm / (111.32 * maxCosine));
+    let column = 0;
+    for (let west = DJI_COVERAGE.west; west < DJI_COVERAGE.east - 1e-10; west += longitudeDegrees, column++) {
+      const east = Math.min(DJI_COVERAGE.east, west + longitudeDegrees);
+      cells.push({
+        id: `r${String(row).padStart(3, "0")}_c${String(column).padStart(3, "0")}`,
+        depth: 0,
+        bounds: [
+          Math.max(DJI_COVERAGE.west, west - DJI_OVERLAP_DEGREES),
+          Math.max(DJI_COVERAGE.south, south - DJI_OVERLAP_DEGREES),
+          Math.min(DJI_COVERAGE.east, east + DJI_OVERLAP_DEGREES),
+          Math.min(DJI_COVERAGE.north, north + DJI_OVERLAP_DEGREES)
+        ]
+      });
+    }
+  }
+  return cells;
+}
+function splitDjiCell(cell) {
+  const [west, south, east, north] = cell.bounds;
+  const middleLongitude = (west + east) / 2;
+  const middleLatitude = (south + north) / 2;
+  if (middleLongitude === west || middleLongitude === east || middleLatitude === south || middleLatitude === north) {
+    throw new Error(`Cannot split saturated DJI cell: ${cell.id}`);
+  }
+  const quadrants = [
+    [west, south, middleLongitude, middleLatitude],
+    [middleLongitude, south, east, middleLatitude],
+    [west, middleLatitude, middleLongitude, north],
+    [middleLongitude, middleLatitude, east, north]
+  ];
+  return quadrants.map(([childWest, childSouth, childEast, childNorth], quadrant) => ({
+    id: cell.depth === 0 ? `${cell.id}_splitq${quadrant}` : `${cell.id}q${quadrant}`,
+    parentId: cell.id,
+    depth: cell.depth + 1,
+    bounds: [
+      Math.max(west, childWest - DJI_OVERLAP_DEGREES),
+      Math.max(south, childSouth - DJI_OVERLAP_DEGREES),
+      Math.min(east, childEast + DJI_OVERLAP_DEGREES),
+      Math.min(north, childNorth + DJI_OVERLAP_DEGREES)
+    ]
+  }));
+}
+function djiBoundsEqual(left, right, tolerance = 1e-10) {
+  return left.length === 4 && right.length === 4 && left.every((value, index) => Math.abs(value - right[index]) <= tolerance);
+}
+
+function parseDjiSnapshot(contents) {
+  const parsed = JSON.parse(contents);
+  if (!isRecord$1(parsed) || parsed.formatVersion !== 2 || parsed.source !== "DJI FlySafe" || parsed.scope !== "global") invalidSnapshot();
+  if (!isIsoDate(parsed.startedAt) || !isIsoDate(parsed.completedAt) || parsed.fetchedAt !== parsed.completedAt) invalidSnapshot();
+  if (Date.parse(parsed.startedAt) > Date.parse(parsed.completedAt)) invalidSnapshot();
+  const coverage = parsed.coverage;
+  if (!isRecord$1(coverage) || coverage.west !== DJI_COVERAGE.west || coverage.south !== DJI_COVERAGE.south || coverage.east !== DJI_COVERAGE.east || coverage.north !== DJI_COVERAGE.north) invalidSnapshot();
+  const query = parsed.query;
+  if (!isRecord$1(query) || query.algorithmVersion !== "global-adaptive-grid-v1" || query.endpoint !== DJI_ENDPOINT || query.zonesMode !== "flysafe_website" || query.drone !== "dji-mavic-3" || query.levels !== DJI_LEVELS) invalidSnapshot();
+  if (query.rowDegrees !== DJI_ROW_DEGREES || query.targetDiagonalKm !== DJI_TARGET_DIAGONAL_KM || query.overlapDegrees !== DJI_OVERLAP_DEGREES || query.saturationLimit !== DJI_SATURATION_LIMIT || query.maxSplitDepth !== DJI_MAX_SPLIT_DEPTH) invalidSnapshot();
+  if (!positiveInteger(query.queryCount) || !positiveInteger(query.baseQueryCount) || !nonNegativeInteger(query.recursiveQueryCount)) invalidSnapshot();
+  if (!nonNegativeInteger(query.saturatedQueryCount) || !nonNegativeInteger(query.maximumLeafResultCount) || query.allLeafQueriesBelowSaturationLimit !== true) invalidSnapshot();
+  if (!nonNegativeInteger(query.occurrenceCount) || !nonNegativeInteger(query.uniqueAreaCount) || !nonNegativeInteger(query.duplicateOccurrences) || query.conflictingDuplicateCount !== 0 || !nonNegativeInteger(query.resumedQueryCount) || query.resumedQueryCount > query.queryCount) invalidSnapshot();
+  if (!Array.isArray(query.queries) || query.queryCount !== query.queries.length || query.queryCount !== query.baseQueryCount + query.recursiveQueryCount) invalidSnapshot();
+  if (!Array.isArray(parsed.areas) || query.uniqueAreaCount !== parsed.areas.length || query.duplicateOccurrences !== query.occurrenceCount - query.uniqueAreaCount) invalidSnapshot();
+  if (typeof parsed.areasSha256 !== "string" || !/^[0-9a-f]{64}$/.test(parsed.areasSha256)) invalidSnapshot();
+  if (createHash("sha256").update(JSON.stringify(parsed.areas)).digest("hex") !== parsed.areasSha256) invalidSnapshot();
+  const queryIds = /* @__PURE__ */ new Set();
+  const summaries = [];
+  let saturatedCount = 0;
+  let maximumLeafResultCount = 0;
+  let baseQueryCount = 0;
+  let occurrenceCount = 0;
+  for (const summary of query.queries) {
+    if (!isQuerySummary(summary) || queryIds.has(summary.id) || summary.depth > DJI_MAX_SPLIT_DEPTH) invalidSnapshot();
+    queryIds.add(summary.id);
+    summaries.push(summary);
+    occurrenceCount += summary.resultCount;
+    if (summary.depth === 0) baseQueryCount++;
+    if (summary.saturated) {
+      if (summary.resultCount < query.saturationLimit) invalidSnapshot();
+      saturatedCount++;
+    } else {
+      if (summary.resultCount >= query.saturationLimit) invalidSnapshot();
+      maximumLeafResultCount = Math.max(maximumLeafResultCount, summary.resultCount);
+    }
+  }
+  if (baseQueryCount !== query.baseQueryCount || summaries.length - baseQueryCount !== query.recursiveQueryCount || occurrenceCount !== query.occurrenceCount) invalidSnapshot();
+  if (saturatedCount !== query.saturatedQueryCount || maximumLeafResultCount !== query.maximumLeafResultCount) invalidSnapshot();
+  const summariesById = new Map(summaries.map((summary) => [summary.id, summary]));
+  const expectedBaseCells = makeDjiBaseGrid();
+  if (query.baseQueryCount !== expectedBaseCells.length) invalidSnapshot();
+  for (const expected of expectedBaseCells) {
+    const actual = summariesById.get(expected.id);
+    if (!actual || actual.depth !== 0 || actual.parentId !== void 0 || !djiBoundsEqual(actual.bounds, expected.bounds)) invalidSnapshot();
+  }
+  for (const summary of summaries) {
+    if (summary.depth === 0) continue;
+    const parent = summary.parentId ? summariesById.get(summary.parentId) : void 0;
+    if (!(parent == null ? void 0 : parent.saturated) || parent.depth + 1 !== summary.depth) invalidSnapshot();
+  }
+  for (const parent of summaries) {
+    const children = summaries.filter((summary) => summary.parentId === parent.id);
+    if (!parent.saturated) {
+      if (children.length) invalidSnapshot();
+      continue;
+    }
+    const expectedChildren = splitDjiCell(parent);
+    if (children.length !== expectedChildren.length) invalidSnapshot();
+    for (const expected of expectedChildren) {
+      const actual = summariesById.get(expected.id);
+      if (!actual || actual.parentId !== parent.id || actual.depth !== expected.depth || !djiBoundsEqual(actual.bounds, expected.bounds)) invalidSnapshot();
+    }
+  }
+  const areaIds = /* @__PURE__ */ new Set();
+  for (const area of parsed.areas) {
+    if (!isRecord$1(area) || area.area_id === null || area.area_id === void 0 || String(area.area_id).trim() === "") invalidSnapshot();
+    const id = String(area.area_id);
+    if (areaIds.has(id)) invalidSnapshot();
+    areaIds.add(id);
+  }
+  return parsed;
+}
+function isQuerySummary(value) {
+  if (!isRecord$1(value) || typeof value.id !== "string" || !value.id || !nonNegativeInteger(value.depth) || !nonNegativeInteger(value.resultCount) || typeof value.saturated !== "boolean") return false;
+  if (value.parentId !== void 0 && (typeof value.parentId !== "string" || !value.parentId)) return false;
+  if (!Array.isArray(value.bounds) || value.bounds.length !== 4 || !value.bounds.every((item) => typeof item === "number" && Number.isFinite(item))) return false;
+  const [west, south, east, north] = value.bounds;
+  return west >= -180 && east <= 180 && south >= -90 && north <= 90 && west < east && south < north;
+}
+function isIsoDate(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value)) && new Date(value).toISOString() === value;
+}
+function positiveInteger(value) {
+  return Number.isInteger(value) && Number(value) > 0;
+}
+function nonNegativeInteger(value) {
+  return Number.isInteger(value) && Number(value) >= 0;
+}
+function isRecord$1(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function invalidSnapshot() {
+  throw new Error("DJI Flysafe \u5FEB\u7167\u683C\u5F0F\u6216\u5B8C\u6574\u6027\u6821\u9A8C\u5931\u8D25");
+}
+
+function djiAreaFeatureCounts(areas) {
+  let candidateCount = 0;
+  let featureCount = 0;
+  if (!Array.isArray(areas)) return { candidateCount, featureCount, droppedFeatureCount: candidateCount };
+  for (const rawArea of areas) {
+    if (!isRecord(rawArea)) continue;
+    const area = rawArea;
+    const subAreas = Array.isArray(area.sub_areas) && area.sub_areas.length ? area.sub_areas.filter(isRecord) : [area];
+    candidateCount += subAreas.length;
+    featureCount += subAreas.filter(hasDjiGeometry).length;
+  }
+  return { candidateCount, featureCount, droppedFeatureCount: candidateCount - featureCount };
+}
+function djiAreasToFeatureCollection(areas) {
+  var _a, _b, _c;
+  const features = [];
+  if (!Array.isArray(areas)) return collection("dji-nfz", features);
+  for (const rawArea of areas) {
+    if (!isRecord(rawArea)) continue;
+    const area = rawArea;
+    const subAreas = Array.isArray(area.sub_areas) && area.sub_areas.length ? area.sub_areas.filter(isRecord) : [area];
+    for (const [index, subArea] of subAreas.entries()) {
+      const coordinates = djiGeometry(subArea);
+      if (!coordinates) continue;
+      const level = (_a = finiteNumber(subArea.level)) != null ? _a : finiteNumber(area.level);
+      const height = finiteNumber(subArea.height);
+      const sourceAreaId = String((_b = area.area_id) != null ? _b : "unknown");
+      const time = timeProperties(area.begin_at, area.end_at);
+      const properties = {
+        id: `${sourceAreaId}:${index}`,
+        sourceAreaId,
+        source: "dji-nfz",
+        name: cleanText(area.name) || "DJI \u98DE\u884C\u9650\u5236\u533A",
+        category: djiCategory(level, height),
+        color: safeColor((_c = subArea.color) != null ? _c : area.color, djiColor(level, height)),
+        ...level === void 0 ? {} : { level },
+        ...finiteNumber(area.type) === void 0 ? {} : { sourceTypeCode: finiteNumber(area.type) },
+        ...cleanText(area.description) ? { description: cleanText(area.description) } : {},
+        ...cleanText(area.country) ? { countryCode: cleanText(area.country) } : {},
+        ...cleanText(area.city) ? { city: cleanText(area.city) } : {},
+        ...height === void 0 || height <= 0 ? {} : { upperLimit: height, upperReference: "AGL" },
+        isPermanent: !time.startsAt && !time.endsAt,
+        ...time
+      };
+      features.push({ type: "Feature", properties, geometry: { type: "Polygon", coordinates } });
+    }
+  }
+  return collection("dji-nfz", features);
+}
+function antigravityRowsToFeatureCollection(rows, version) {
+  var _a;
+  const features = [];
+  for (const row of rows) {
+    const coordinates = row.geometry_type === "Circle" ? circlePolygon(row.center_lon, row.center_lat, row.radius) : parsePolygon(row.coordinates);
+    if (!coordinates) continue;
+    const category = antigravityCategory(row.restriction_type);
+    const description = antigravityDescription(row.message, row.reason);
+    features.push({
+      type: "Feature",
+      properties: {
+        id: String(row.id),
+        sourceAreaId: String(row.id),
+        source: "antigravity-nfz",
+        name: ((_a = row.zone_name) == null ? void 0 : _a.trim()) || "Antigravity \u533A\u57DF",
+        category,
+        color: antigravityColor(category),
+        sourceTypeCode: row.restriction_type,
+        ...description ? { description } : {},
+        ...row.lower_limit === null ? {} : { lowerLimit: row.lower_limit },
+        ...row.upper_limit === null ? {} : { upperLimit: row.upper_limit },
+        ...row.lower_reference ? { lowerReference: row.lower_reference } : {},
+        ...row.upper_reference ? { upperReference: row.upper_reference } : {},
+        isPermanent: Boolean(row.is_permanent),
+        ...row.start_date_time ? { startsAt: row.start_date_time } : {},
+        ...row.end_date_time ? { endsAt: row.end_date_time } : {}
+      },
+      geometry: { type: "Polygon", coordinates }
+    });
+  }
+  return collection("antigravity-nfz", features, version);
+}
+function circlePolygon(longitude, latitude, radiusMeters, segments = 64) {
+  const lon = finiteNumber(longitude);
+  const lat = finiteNumber(latitude);
+  const radius = finiteNumber(radiusMeters);
+  if (lon === void 0 || lat === void 0 || radius === void 0 || radius <= 0 || Math.abs(lat) >= 89.9) return null;
+  const earthRadius = 63710088e-1;
+  const angularDistance = radius / earthRadius;
+  const latitudeRadians = lat * Math.PI / 180;
+  const longitudeRadians = lon * Math.PI / 180;
+  const ring = [];
+  for (let index = 0; index <= segments; index++) {
+    const bearing = index / segments * Math.PI * 2;
+    const pointLatitude = Math.asin(
+      Math.sin(latitudeRadians) * Math.cos(angularDistance) + Math.cos(latitudeRadians) * Math.sin(angularDistance) * Math.cos(bearing)
+    );
+    const pointLongitude = longitudeRadians + Math.atan2(
+      Math.sin(bearing) * Math.sin(angularDistance) * Math.cos(latitudeRadians),
+      Math.cos(angularDistance) - Math.sin(latitudeRadians) * Math.sin(pointLatitude)
+    );
+    ring.push([pointLongitude * 180 / Math.PI, pointLatitude * 180 / Math.PI]);
+  }
+  return [ring];
+}
+function djiGeometry(area) {
+  const polygon = parsePolygonValue(area.polygon_points);
+  if (polygon) return polygon;
+  return circlePolygon(area.lng, area.lat, area.radius);
+}
+function hasDjiGeometry(area) {
+  if (hasPolygonValue(area.polygon_points)) return true;
+  const lon = finiteNumber(area.lng);
+  const lat = finiteNumber(area.lat);
+  const radius = finiteNumber(area.radius);
+  return lon !== void 0 && lat !== void 0 && radius !== void 0 && radius > 0 && Math.abs(lat) < 89.9;
+}
+function parsePolygon(value) {
+  if (!value) return null;
+  try {
+    return parsePolygonValue(JSON.parse(value));
+  } catch {
+    return null;
+  }
+}
+function parsePolygonValue(value) {
+  if (!Array.isArray(value)) return null;
+  const rings = value.every(isPosition) ? [value] : value;
+  if (!Array.isArray(rings) || !rings.length) return null;
+  const normalized = [];
+  for (const candidate of rings) {
+    if (!Array.isArray(candidate)) return null;
+    const ring = candidate.filter(isPosition).map((position) => [Number(position[0]), Number(position[1])]);
+    if (ring.length < 3) continue;
+    const first = ring[0];
+    const last = ring.at(-1);
+    if (first[0] !== last[0] || first[1] !== last[1]) ring.push([...first]);
+    normalized.push(ring);
+  }
+  return normalized.length ? normalized : null;
+}
+function hasPolygonValue(value) {
+  if (!Array.isArray(value)) return false;
+  const rings = value.every(isPosition) ? [value] : value;
+  return Array.isArray(rings) && rings.some((candidate) => Array.isArray(candidate) && candidate.filter(isPosition).length >= 3);
+}
+function isPosition(value) {
+  return Array.isArray(value) && value.length >= 2 && [Number(value[0]), Number(value[1])].every(Number.isFinite);
+}
+function djiCategory(level, height) {
+  if (level === 0) return "warning";
+  if (level === 1) return "authorization";
+  if (level === 2) return height && height > 0 ? "altitude" : "restricted";
+  if (level === 3) return "enhanced-warning";
+  if (level === 5) return "recommended";
+  if (level === 7) return "regulatory-restricted";
+  if (level === 8) return "approved";
+  if (level === 10) return "special-altitude";
+  return "other";
+}
+function djiColor(level, height) {
+  if (level === 0) return "#ffcc00";
+  if (level === 1) return "#1088f2";
+  if (level === 2) return height && height > 0 ? "#979797" : "#de4329";
+  if (level === 3) return "#ee8815";
+  if (level === 5 || level === 8) return "#00be00";
+  if (level === 7) return "#37c4db";
+  if (level === 10) return "#377a26";
+  return "#6b7280";
+}
+function antigravityCategory(restrictionType) {
+  if (restrictionType === 1) return "altitude";
+  if (restrictionType === 2) return "warning";
+  if (restrictionType === 3) return "restricted";
+  return "other";
+}
+function antigravityColor(category) {
+  if (category === "restricted") return "#c83e43";
+  if (category === "altitude") return "#d89216";
+  if (category === "warning") return "#287bb5";
+  return "#6b7280";
+}
+function timeProperties(begin, end) {
+  const startsAt = timestamp(begin);
+  const endsAt = timestamp(end);
+  return { ...startsAt ? { startsAt } : {}, ...endsAt ? { endsAt } : {} };
+}
+function antigravityDescription(message, reason) {
+  var _a;
+  const fallback = cleanText(reason);
+  const raw = cleanText(message);
+  if (!raw) return fallback;
+  try {
+    const values = JSON.parse(raw);
+    if (!Array.isArray(values)) return fallback;
+    const localized = values.filter(isRecord).map((value) => {
+      var _a2;
+      return {
+        language: ((_a2 = cleanText(value.language_code)) == null ? void 0 : _a2.replace("_", "-").toLowerCase()) || "",
+        text: cleanText(value.template) || cleanText(value.content)
+      };
+    }).filter((value) => Boolean(value.text)).sort((left, right) => languagePriority(left.language) - languagePriority(right.language));
+    return ((_a = localized[0]) == null ? void 0 : _a.text) || fallback;
+  } catch {
+    return raw || fallback;
+  }
+}
+function languagePriority(language) {
+  if (language === "zh-cn") return 0;
+  if (language === "zh-tw") return 1;
+  if (language.startsWith("zh")) return 2;
+  if (language.startsWith("en")) return 3;
+  return 4;
+}
+function timestamp(value) {
+  const numeric = finiteNumber(value);
+  if (numeric === void 0 || numeric <= 0) return void 0;
+  const date = new Date(numeric < 1e12 ? numeric * 1e3 : numeric);
+  return Number.isFinite(date.valueOf()) ? date.toISOString() : void 0;
+}
+function finiteNumber(value) {
+  const numeric = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : NaN;
+  return Number.isFinite(numeric) ? numeric : void 0;
+}
+function cleanText(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function safeColor(value, fallback) {
+  return typeof value === "string" && /^#[0-9a-f]{6}$/i.test(value) ? value : fallback;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function collection(source, features, version) {
+  return {
+    type: "FeatureCollection",
+    features,
+    metadata: { source, fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), ...version ? { version } : {} }
+  };
+}
+
+let cache = null;
+let featureCache = null;
+async function getDjiNfzInfo() {
+  const snapshot = await loadSnapshot();
+  const counts = djiAreaFeatureCounts(snapshot.areas);
+  return {
+    areaCount: snapshot.areas.length,
+    featureCount: counts.featureCount,
+    droppedFeatureCount: counts.droppedFeatureCount,
+    areasSha256: snapshot.areasSha256,
+    version: djiSnapshotVersion(snapshot.fetchedAt),
+    releasedAt: snapshot.fetchedAt
+  };
+}
+async function getDjiNfz() {
+  return collectionFor(await loadSnapshot());
+}
+function collectionFor(snapshot) {
+  if (!featureCache || featureCache.snapshot !== snapshot) {
+    const collection = djiAreasToFeatureCollection(snapshot.areas);
+    collection.metadata = {
+      source: "dji-nfz",
+      fetchedAt: snapshot.fetchedAt,
+      version: djiSnapshotVersion(snapshot.fetchedAt)
+    };
+    featureCache = { snapshot, collection };
+  }
+  return featureCache.collection;
+}
+async function loadSnapshot() {
+  const config = useRuntimeConfig();
+  const path = resolveMapLayerSnapshotPath({
+    explicitPath: String(config.djiNfzPath || ""),
+    dataDir: serverDataDirectory(),
+    filename: MAP_LAYER_SNAPSHOT_FILENAMES.dji
+  });
+  const file = await stat(path, { bigint: true });
+  if (!file.isFile() || file.size <= BigInt(0) || file.size > BigInt(128 * 1024 * 1024)) throw new Error("DJI Flysafe \u5FEB\u7167\u6587\u4EF6\u5F02\u5E38");
+  if (!cache || cache.path !== path || cache.modifiedAtNanoseconds !== file.mtimeNs) {
+    const snapshot = readFile(path, "utf8").then(parseDjiSnapshot);
+    const next = { path, modifiedAtNanoseconds: file.mtimeNs, snapshot };
+    snapshot.catch(() => {
+      if (cache === next) cache = null;
+    });
+    cache = next;
+  }
+  return cache.snapshot;
+}
+function djiSnapshotVersion(fetchedAt) {
+  return fetchedAt;
+}
+
+const ANTIGRAVITY_VERSION_ROW_COLUMNS = [
+  "version_code",
+  "released_time",
+  "expired_time"
+];
+const ANTIGRAVITY_FENCE_ROW_COLUMNS = [
+  "id",
+  "zone_name",
+  "restriction_type",
+  "lower_limit",
+  "lower_reference",
+  "upper_limit",
+  "upper_reference",
+  "is_permanent",
+  "start_date_time",
+  "end_date_time",
+  "geometry_type",
+  "center_lat",
+  "center_lon",
+  "radius",
+  "coordinates",
+  "reason",
+  "message"
+];
+const ANTIGRAVITY_VERSION_SCHEMA_COLUMNS = [
+  "id",
+  ...ANTIGRAVITY_VERSION_ROW_COLUMNS,
+  "is_deleted"
+];
+const ANTIGRAVITY_FENCE_SCHEMA_COLUMNS = [
+  ...ANTIGRAVITY_FENCE_ROW_COLUMNS,
+  "is_valid",
+  "is_deleted"
+];
+const ANTIGRAVITY_VERSION_ROW_PROJECTION = ANTIGRAVITY_VERSION_ROW_COLUMNS.join(", ");
+const ANTIGRAVITY_FENCE_ROW_PROJECTION = ANTIGRAVITY_FENCE_ROW_COLUMNS.join(", ");
+function assertAntigravityDatabaseSchema(database) {
+  try {
+    database.prepare(`SELECT ${ANTIGRAVITY_VERSION_SCHEMA_COLUMNS.join(", ")} FROM version LIMIT 0`).all();
+    database.prepare(`SELECT ${ANTIGRAVITY_FENCE_SCHEMA_COLUMNS.join(", ")} FROM fences LIMIT 0`).all();
+  } catch (error) {
+    throw new Error("Antigravity \u6570\u636E\u5E93\u7ED3\u6784\u4E0D\u517C\u5BB9", { cause: error });
+  }
+}
+
+let cachedStore = null;
+let pendingStore = null;
+async function getAntigravityNfzInfo() {
+  var _a;
+  const store = await loadStore();
+  return {
+    featureCount: Number(((_a = store.database.prepare("SELECT COUNT(*) AS count FROM fences WHERE is_valid = 1 AND is_deleted = 0").get()) == null ? void 0 : _a.count) || 0),
+    sqliteSha256: store.sqliteSha256,
+    version: store.version.version_code || void 0,
+    releasedAt: store.version.released_time || void 0,
+    expiresAt: store.version.expired_time || void 0
+  };
+}
+async function getAntigravityNfz() {
+  const store = await loadStore();
+  const rows = store.database.prepare(`
+    SELECT ${ANTIGRAVITY_FENCE_ROW_PROJECTION}
+    FROM fences
+    WHERE is_valid = 1 AND is_deleted = 0
+    ORDER BY restriction_type DESC, id ASC
+  `).all();
+  return antigravityRowsToFeatureCollection(rows, store.version.version_code || void 0);
+}
+async function loadStore() {
+  const config = useRuntimeConfig();
+  const sourcePath = resolveMapLayerSnapshotPath({
+    explicitPath: String(config.antigravityNfzPath || ""),
+    dataDir: serverDataDirectory(),
+    filename: MAP_LAYER_SNAPSHOT_FILENAMES.antigravity
+  });
+  const identity = await sourceIdentity(sourcePath);
+  if (cachedStore && sameIdentity(cachedStore.identity, identity)) return cachedStore.store;
+  if (pendingStore) {
+    if (sameIdentity(pendingStore.identity, identity)) return pendingStore.promise;
+    try {
+      await pendingStore.promise;
+    } catch {
+    }
+    return loadStore();
+  }
+  const promise = replaceStore(identity);
+  const pending = { identity, promise };
+  pendingStore = pending;
+  try {
+    return await promise;
+  } finally {
+    if (pendingStore === pending) pendingStore = null;
+  }
+}
+async function replaceStore(identity) {
+  const store = await openStore(identity);
+  let currentIdentity;
+  try {
+    currentIdentity = await sourceIdentity(identity.path);
+  } catch (error) {
+    closeStore(store);
+    throw error;
+  }
+  if (!sameIdentity(identity, currentIdentity)) {
+    closeStore(store);
+    throw new Error("Antigravity \u6570\u636E\u6E90\u5728\u52A0\u8F7D\u671F\u95F4\u5DF2\u66F4\u65B0\uFF0C\u8BF7\u91CD\u8BD5");
+  }
+  const previous = cachedStore;
+  cachedStore = { identity, store };
+  if (previous && previous.store !== store) setImmediate(() => closeStore(previous.store));
+  return store;
+}
+async function openStore(identity) {
+  return openValidatedDatabase(identity.path);
+}
+async function openValidatedDatabase(databasePath) {
+  const sqliteContents = await readFile(databasePath);
+  const sqliteSha256 = createHash("sha256").update(sqliteContents).digest("hex");
+  const database = new DatabaseSync(databasePath, { readOnly: true });
+  try {
+    const integrity = database.prepare("PRAGMA quick_check").get();
+    if (integrity.quick_check !== "ok") throw new Error("Antigravity \u6570\u636E\u5E93\u6821\u9A8C\u5931\u8D25");
+    assertAntigravityDatabaseSchema(database);
+    const version = database.prepare(`
+      SELECT ${ANTIGRAVITY_VERSION_ROW_PROJECTION}
+      FROM version WHERE COALESCE(is_deleted, 0) = 0
+      ORDER BY id DESC LIMIT 1
+    `).get();
+    return { database, version: version || { version_code: null, released_time: null, expired_time: null }, sqliteSha256 };
+  } catch (error) {
+    closeStore({ database, version: { version_code: null, released_time: null, expired_time: null }, sqliteSha256 });
+    throw error;
+  }
+}
+async function sourceIdentity(path) {
+  const file = await stat(path, { bigint: true });
+  if (!file.isFile() || file.size <= BigInt(0) || file.size > BigInt(128 * 1024 * 1024)) {
+    throw new Error("Antigravity \u6570\u636E\u6E90\u6587\u4EF6\u5F02\u5E38");
+  }
+  return {
+    path,
+    device: file.dev,
+    inode: file.ino,
+    size: file.size,
+    modifiedAtNanoseconds: file.mtimeNs,
+    changedAtNanoseconds: file.ctimeNs
+  };
+}
+function sameIdentity(left, right) {
+  return left.path === right.path && left.device === right.device && left.inode === right.inode && left.size === right.size && left.modifiedAtNanoseconds === right.modifiedAtNanoseconds && left.changedAtNanoseconds === right.changedAtNanoseconds;
+}
+function closeStore(store) {
+  try {
+    store.database.close();
+  } catch {
+  }
+}
+
+export { DJI_MAX_SPLIT_DEPTH as D, MAP_LAYER_SNAPSHOT_FILENAMES as M, getAntigravityNfz as a, DJI_SATURATION_LIMIT as b, DJI_OVERLAP_DEGREES as c, DJI_TARGET_DIAGONAL_KM as d, DJI_ROW_DEGREES as e, DJI_LEVELS as f, getDjiNfz as g, DJI_ENDPOINT as h, DJI_COVERAGE as i, assertAntigravityDatabaseSchema as j, getDjiNfzInfo as k, getAntigravityNfzInfo as l, makeDjiBaseGrid as m, parseDjiSnapshot as p, splitDjiCell as s };
+//# sourceMappingURL=antigravity-nfz.mjs.map