uomtiles 0.1.2 → 0.1.3

package/dist/src/map-layer-update.js

@@ -0,0 +1,646 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, readdir, rename, rm, stat, unlink, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { fetch as undiciFetch, ProxyAgent } from 'undici';
+import { assertAntigravityDatabaseSchema } from "../shared/antigravity-schema.js";
+import { DJI_COVERAGE, DJI_ENDPOINT, DJI_LEVELS, DJI_MAX_SPLIT_DEPTH, DJI_OVERLAP_DEGREES, DJI_ROW_DEGREES, DJI_SATURATION_LIMIT, DJI_TARGET_DIAGONAL_KM, makeDjiBaseGrid, splitDjiCell, } from "../shared/dji-grid.js";
+import { parseDjiSnapshot } from "./core/dji-snapshot.js";
+export const DEFAULT_DJI_CONCURRENCY = 12;
+export const DJI_RESUME_MAX_AGE_MS = 6 * 60 * 60 * 1000;
+export 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;
+export async function updateMapLayers(options) {
+    const context = createUpdateContext(options);
+    try {
+        await mkdir(context.outputDirectory, { recursive: true });
+        const dji = await downloadDjiSnapshot(context);
+        const antigravity = await downloadAntigravitySnapshot(context);
+        return { dji, antigravity };
+    }
+    finally {
+        await closeUpdateContext(context);
+    }
+}
+export 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);
+    }
+}
+export 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) {
+    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 = options.djiConcurrency ?? DEFAULT_DJI_CONCURRENCY;
+    const djiResume = options.djiResume ?? 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) {
+    await context.dispatcher?.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, '正在连接 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, '正在检查 DJI Flysafe 区域分片');
+    const areas = new Map();
+    const serializedAreas = 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, `已检查 ${completed} 个 DJI Flysafe 区域分片`);
+                if (completed % 20 === 0) {
+                    const seconds = ((Date.now() - startedAtMilliseconds) / 1000).toFixed(1);
+                    process.stderr.write(`DJI FlySafe: ${completed} queries, ${areas.size} unique areas, ${seconds}s\n`);
+                }
+            }
+        });
+        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\n`);
+    }
+    if (conflictingDuplicateCount)
+        throw new Error(`DJI returned ${conflictingDuplicateCount} conflicting duplicate areas`);
+    reportProgress(context, 'dji-nfz', 'validating', 0, 1, '正在校验 DJI Flysafe 数据');
+    const sortedAreas = [...areas.values()].sort((left, right) => String(left?.area_id ?? '').localeCompare(String(right?.area_id ?? ''), 'en', { numeric: true }));
+    const areasJson = JSON.stringify(sortedAreas);
+    const areasSha256 = createHash('sha256').update(areasJson).digest('hex');
+    const completedAt = 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)}\n`;
+    const existing = await readDjiSnapshotIdentity(destination);
+    if (existing?.areasSha256 === areasSha256) {
+        // DJI exposes no release manifest. Keep the content hash stable, but
+        // refresh the snapshot timestamp so the catalog records this successful
+        // full check instead of making the data appear stale indefinitely.
+        reportProgress(context, 'dji-nfz', 'writing', 0, 1, '正在记录 DJI Flysafe 检查时间');
+        await atomicWrite(destination, contents);
+        await completeDjiUpdateSession(session);
+        reportProgress(context, 'dji-nfz', 'writing', 1, 1, '已检查，区域数据未变化');
+        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, '正在写入 DJI Flysafe 快照');
+    await atomicWrite(destination, contents);
+    await completeDjiUpdateSession(session);
+    reportProgress(context, 'dji-nfz', 'writing', 1, 1, 'DJI Flysafe 更新完成');
+    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 undiciFetch(url, {
+                signal: AbortSignal.timeout(60_000),
+                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(20_000, 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 * 1000);
+    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 !== undefined && 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?.area_id === undefined || 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 = new Date().toISOString();
+    reportProgress(context, 'antigravity-nfz', 'checking', 0, 1, '正在检查 Antigravity 在线版本');
+    const manifest = await fetchAntigravityManifest(context);
+    const current = await inspectAntigravitySnapshot(destination).catch(() => null);
+    if (current?.version === manifest.versionCode) {
+        reportProgress(context, 'antigravity-nfz', 'checking', 1, 1, '无新版本');
+        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, '正在校验 Antigravity 数据');
+    const databaseBytes = extractAntigravitySqlite(wrapped, manifest);
+    const temporary = `${destination}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        await writeFile(temporary, databaseBytes, { mode: 0o644 });
+        const candidate = await inspectAntigravitySnapshot(temporary);
+        if (candidate.version !== manifest.versionCode) {
+            throw new Error(`Antigravity 版本校验失败：预期 ${manifest.versionCode}，实际 ${candidate.version || '未知'}`);
+        }
+        reportProgress(context, 'antigravity-nfz', 'writing', 0, 1, '正在写入 Antigravity 快照');
+        await rename(temporary, destination);
+        reportProgress(context, 'antigravity-nfz', 'writing', 1, 1, 'Antigravity 更新完成');
+        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?.sha256 !== candidate.sha256,
+            noUpdate: current?.sha256 === candidate.sha256,
+        };
+    }
+    finally {
+        await unlink(temporary).catch(() => { });
+    }
+}
+async function fetchAntigravityManifest(context) {
+    const response = await undiciFetch(ANTIGRAVITY_VERSION_ENDPOINT, {
+        method: 'POST',
+        redirect: 'error',
+        signal: AbortSignal.timeout(30_000),
+        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 版本检查失败：HTTP ${response.status}`);
+    const declaredLength = Number(response.headers.get('content-length') || 0);
+    if (declaredLength > MAX_ANTIGRAVITY_MANIFEST_BYTES)
+        throw new Error('Antigravity 版本响应过大');
+    const body = await response.text();
+    if (Buffer.byteLength(body) > MAX_ANTIGRAVITY_MANIFEST_BYTES)
+        throw new Error('Antigravity 版本响应过大');
+    let payload;
+    try {
+        payload = JSON.parse(body);
+    }
+    catch {
+        throw new Error('Antigravity 版本响应格式无效');
+    }
+    return parseAntigravityVersionManifest(payload);
+}
+export function parseAntigravityVersionManifest(payload) {
+    if (!isRecord(payload) || payload.code !== 0 || !isRecord(payload.data)) {
+        const message = isRecord(payload) && typeof payload.msg === 'string' ? payload.msg : '响应格式无效';
+        throw new Error(`Antigravity 版本检查失败：${message}`);
+    }
+    const versionCode = optionalString(payload.data.versionCode)?.trim();
+    const fileUrl = optionalString(payload.data.fileUrl)?.trim();
+    const fileSize = Number(payload.data.fileSize);
+    const verifyToken = optionalString(payload.data.verifyToken)?.trim().toLowerCase();
+    if (!versionCode || !/^[0-9][0-9A-Za-z._-]{1,63}$/.test(versionCode))
+        throw new Error('Antigravity 版本号无效');
+    if (!fileUrl)
+        throw new Error('Antigravity 下载地址缺失');
+    validateAntigravityDownloadUrl(fileUrl);
+    if (!Number.isSafeInteger(fileSize) || fileSize < 4096 || fileSize > MAX_ANTIGRAVITY_SNAPSHOT_BYTES) {
+        throw new Error('Antigravity 文件大小无效');
+    }
+    if (!verifyToken || !/^[0-9a-f]{32}$/.test(verifyToken))
+        throw new Error('Antigravity 校验令牌无效');
+    return {
+        versionCode,
+        fileUrl,
+        fileSize,
+        verifyToken,
+        releasedAt: optionalString(payload.data.releasedTime),
+        expiresAt: optionalString(payload.data.expiredTime),
+    };
+}
+export function extractAntigravitySqlite(contents, manifest) {
+    const wrapped = Buffer.from(contents);
+    if (wrapped.length !== manifest.fileSize)
+        throw new Error('Antigravity 下载文件大小与版本信息不符');
+    const wrappedMd5 = createHash('md5').update(wrapped).digest('hex');
+    if (wrappedMd5 !== manifest.verifyToken.toLowerCase())
+        throw new Error('Antigravity 下载文件校验失败');
+    const marker = wrapped.indexOf(Buffer.from('SQLite format 3\0', 'ascii'));
+    if (marker < 0)
+        throw new Error('Antigravity 数据中未找到 SQLite 快照');
+    const databaseBytes = wrapped.subarray(marker);
+    if (databaseBytes.length < 4096 || databaseBytes.length % 4096 !== 0) {
+        throw new Error('Antigravity SQLite 快照长度异常');
+    }
+    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 undiciFetch(url, {
+            redirect: 'manual',
+            signal: AbortSignal.timeout(60_000),
+            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 下载重定向过多');
+        const location = response.headers.get('location');
+        if (!location)
+            throw new Error('Antigravity 下载重定向无效');
+        url = new URL(location, url);
+    }
+    if (!response.ok)
+        throw new Error(`Antigravity 下载失败：HTTP ${response.status}`);
+    const declaredLength = Number(response.headers.get('content-length') || 0);
+    if (declaredLength && declaredLength !== manifest.fileSize)
+        throw new Error('Antigravity 下载文件大小与版本信息不符');
+    if (!response.body)
+        throw new Error('Antigravity 下载响应为空');
+    const chunks = [];
+    let completed = 0;
+    reportProgress(context, 'antigravity-nfz', 'downloading', 0, manifest.fileSize, '正在下载 Antigravity 数据');
+    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 下载文件过大');
+        }
+        chunks.push(bytes);
+        reportProgress(context, 'antigravity-nfz', 'downloading', completed, manifest.fileSize, '正在下载 Antigravity 数据');
+    }
+    if (completed !== manifest.fileSize)
+        throw new Error('Antigravity 下载文件不完整');
+    return Buffer.concat(chunks, completed);
+}
+function validateAntigravityDownloadUrl(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error('Antigravity 下载地址不受信任');
+    }
+    if (url.protocol !== 'https:' || url.hostname !== ANTIGRAVITY_DOWNLOAD_HOST || url.port || url.username || url.password || !url.pathname.endsWith('.InstaCry')) {
+        throw new Error('Antigravity 下载地址不受信任');
+    }
+}
+async function inspectAntigravitySnapshot(path) {
+    const contents = await readFile(path);
+    const database = new DatabaseSync(path, { readOnly: true });
+    try {
+        const integrity = database.prepare('PRAGMA integrity_check').get()?.integrity_check;
+        if (integrity !== 'ok')
+            throw new Error(`Antigravity SQLite 完整性校验失败：${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?.count || 0);
+        if (!Number.isSafeInteger(fences) || fences <= 0)
+            throw new Error('Antigravity 有效区域数量无效');
+        return {
+            bytes: contents.length,
+            sha256: createHash('sha256').update(contents).digest('hex'),
+            fences,
+            version: optionalString(version?.version_code),
+            releasedAt: optionalString(version?.released_time),
+            expiresAt: optionalString(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');
+export 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 = new Date().toISOString();
+    const sessionId = `${startedAt.replace(/[:.]/g, '-')}-${randomUUID()}`;
+    await atomicWrite(manifestPath, `${JSON.stringify({ fingerprint: DJI_UPDATE_FINGERPRINT, sessionId, startedAt })}\n`);
+    await pruneDjiUpdateSessions(rawRootDirectory, sessionId);
+    return { manifestPath, sessionId, startedAt, directory: resolve(rawRootDirectory, sessionId) };
+}
+export 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?.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: 0o644 });
+    await rename(temporary, destination);
+}
+function snapshotDestination(outputDirectory, configuredPath, filename) {
+    const configured = 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) {
+    context.onProgress?.({ source, phase, completed, total, message });
+}
+function optionalString(value) {
+    return value === undefined || value === null ? undefined : String(value);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uomtiles",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "UOM 适飞地图预览、下载、对比与 MBTiles/PMTiles 发布工具",
   "keywords": [
     "uom",
@@ -16,7 +16,7 @@
   },
   "type": "module",
   "private": false,
-  "license": "SEE LICENSE IN LICENSE",
+  "license": "Apache-2.0",
   "bin": {
     "uomtiles": "dist/src/cli.js"
   },
@@ -37,6 +37,7 @@
     "dev": "pnpm build:cli && nuxt dev",
     "build:cli": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.cli.json",
     "build": "pnpm build:cli && nuxt build",
+    "map-layers:update": "node --experimental-strip-types --no-warnings src/cli.ts map-layers-update",
     "test": "vitest run",
     "prepack": "pnpm build",
     "preview": "nuxt preview",