uomtiles 0.1.1 → 0.1.3

package/dist/src/cli.js

@@ -9,10 +9,12 @@ import { isSea } from 'node:sea';
 import { defineCommand, runMain } from 'citty';
 import { accountFile, uomtilesDataDir, workspaceDirectory } from "./core/paths.js";
 import { DEFAULT_GRID_CRAWL_OPTIONS, runGridCrawl } from "./grid-crawl.js";
+import { DEFAULT_DJI_CONCURRENCY, updateMapLayers } from "./map-layer-update.js";
 import { FETCH_PROCESS_ENV } from "./core/fetch-process.js";
 import { shellEnvironmentHint } from "./core/shell.js";
 import { diffUomtiles, exportTiles, inspectUomtiles, migrateToUomtiles } from "./core/uomtiles.js";
 import { SPACE_APP_ID, UOM_BASE, LOCATION_SSO_PATH, UOMTILES_VERSION } from "./config.js";
+import { DEFAULT_EXPORT_MAX_ZOOM, DEFAULT_EXPORT_MIN_ZOOM } from "../shared/export.js";
 const sea = isSea();
 const cliPath = sea ? null : fileURLToPath(import.meta.url);
 const compiled = cliPath ? extname(cliPath) === '.js' : false;
@@ -145,16 +147,22 @@ function openUrl(url) {
     child.unref();
 }
 function loadWebEnvironment() {
-    const environmentFile = resolve(process.cwd(), '.env');
-    if (existsSync(environmentFile))
-        loadEnvFile(environmentFile);
+    loadProjectEnvironment();
     if (process.env.NUXT_TIANDITU_TOKEN?.trim())
         return;
     const shell = shellEnvironmentHint(process.platform, process.env);
     console.warn('天地图令牌未配置，工作台将使用 OSM，天地图选项不可用。');
-    console.warn(`持久配置：在 ${environmentFile} 中添加 NUXT_TIANDITU_TOKEN=你的天地图令牌`);
+    console.warn(`持久配置：在 ${projectEnvironmentFile()} 中添加 NUXT_TIANDITU_TOKEN=你的天地图令牌`);
     console.warn(`当前 ${shell.name} 临时配置：${shell.command}`);
 }
+function projectEnvironmentFile() {
+    return resolve(process.cwd(), '.env');
+}
+function loadProjectEnvironment() {
+    const environmentFile = projectEnvironmentFile();
+    if (existsSync(environmentFile))
+        loadEnvFile(environmentFile);
+}
 async function web() {
     loadWebEnvironment();
     const entry = resolve(root, '.output/server/index.mjs');
@@ -214,9 +222,11 @@ const exportCommand = defineCommand({
     args: {
         input: { type: 'positional', description: '输入 .uomtiles 文件', required: true },
         output: { type: 'positional', description: '输出 .mbtiles 或 .pmtiles 文件', required: true },
+        'min-zoom': { type: 'string', description: '最小导出层级', default: String(DEFAULT_EXPORT_MIN_ZOOM) },
+        'max-zoom': { type: 'string', description: '最大导出层级', default: String(DEFAULT_EXPORT_MAX_ZOOM) },
     },
     run: async ({ args }) => {
-        await exportTiles(args.input, args.output);
+        await exportTiles(args.input, args.output, { minZoom: Number(args['min-zoom']), maxZoom: Number(args['max-zoom']) });
         console.log(`已导出：${resolve(args.output)}`);
     },
 });
@@ -248,6 +258,51 @@ const migrateCommand = defineCommand({
         console.log(JSON.stringify(migrateToUomtiles(args.input, args.output, account?.username || null), null, 2));
     },
 });
+const mapLayersUpdateCommand = defineCommand({
+    meta: { name: 'map-layers-update', description: '在线更新 DJI Flysafe 与 Antigravity 图层快照' },
+    args: () => {
+        loadProjectEnvironment();
+        return {
+            output: {
+                type: 'string',
+                description: '快照输出目录',
+                valueHint: 'PATH',
+                default: resolve(uomtilesDataDir(), 'map-layers'),
+            },
+            'dji-raw-dir': {
+                type: 'string',
+                description: '用于断点续传的 DJI 原始响应目录',
+                valueHint: 'PATH',
+                required: false,
+            },
+            'dji-concurrency': {
+                type: 'string',
+                description: 'DJI 并发请求数',
+                valueHint: 'N',
+                default: String(DEFAULT_DJI_CONCURRENCY),
+            },
+            'dji-resume': {
+                type: 'boolean',
+                description: '复用当前更新会话中已验证的 DJI 原始响应',
+                negativeDescription: '忽略当前 DJI 更新会话并重新下载',
+                default: true,
+            },
+        };
+    },
+    run: async ({ args }) => {
+        const djiConcurrency = Number(args['dji-concurrency']);
+        if (!Number.isInteger(djiConcurrency) || djiConcurrency <= 0) {
+            throw new Error('--dji-concurrency 必须是正整数');
+        }
+        const result = await updateMapLayers({
+            outputDirectory: args.output,
+            djiRawDirectory: args['dji-raw-dir'],
+            djiConcurrency,
+            djiResume: args['dji-resume'],
+        });
+        console.log(JSON.stringify(result, null, 2));
+    },
+});
 const mainCommand = defineCommand({
     meta: {
         name: 'uomtiles',
@@ -264,6 +319,12 @@ const mainCommand = defineCommand({
         export: exportCommand,
         diff: diffCommand,
         migrate: migrateCommand,
+        'map-layers-update': mapLayersUpdateCommand,
     },
 });
-await runMain(mainCommand);
+function cliArguments(arguments_) {
+    if (arguments_[0] !== 'map-layers-update')
+        return arguments_;
+    return arguments_.filter(argument => argument !== '--');
+}
+await runMain(mainCommand, { rawArgs: cliArguments(process.argv.slice(2)) });

package/dist/src/core/dji-snapshot.js

@@ -0,0 +1,135 @@
+import { createHash } from 'node:crypto';
+import { DJI_COVERAGE, DJI_ENDPOINT, DJI_LEVELS, DJI_MAX_SPLIT_DEPTH, DJI_OVERLAP_DEGREES, DJI_ROW_DEGREES, DJI_SATURATION_LIMIT, DJI_TARGET_DIAGONAL_KM, djiBoundsEqual, makeDjiBaseGrid, splitDjiCell, } from "../../shared/dji-grid.js";
+/**
+ * Parse and fully validate a downloaded DJI snapshot.
+ *
+ * This is intentionally kept independent from Nitro/server runtime code so
+ * the updater and the runtime renderer cannot disagree about snapshot validity.
+ */
+export function parseDjiSnapshot(contents) {
+    const parsed = JSON.parse(contents);
+    if (!isRecord(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(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(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 = 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 !== undefined || !djiBoundsEqual(actual.bounds, expected.bounds))
+            invalidSnapshot();
+    }
+    for (const summary of summaries) {
+        if (summary.depth === 0)
+            continue;
+        const parent = summary.parentId ? summariesById.get(summary.parentId) : undefined;
+        if (!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 = new Set();
+    for (const area of parsed.areas) {
+        if (!isRecord(area) || area.area_id === null || area.area_id === undefined || 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(value) || typeof value.id !== 'string' || !value.id || !nonNegativeInteger(value.depth) || !nonNegativeInteger(value.resultCount) || typeof value.saturated !== 'boolean')
+        return false;
+    if (value.parentId !== undefined && (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(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function invalidSnapshot() {
+    throw new Error('DJI Flysafe 快照格式或完整性校验失败');
+}

package/dist/src/core/grid-renderer.js

@@ -120,30 +120,44 @@ export class GeographicGridRenderer {
             return;
         }
         const scale = 2 ** (z - SOURCE_ZOOM);
-        for (const root of this.roots.values())
+        const worldMax = 2 ** z - 1;
+        const roots = [...this.roots.values()].sort((left, right) => left.x - right.x || left.y - right.y);
+        for (const root of roots) {
+            const rows = new Map();
+            const sourceX0 = root.x * sourceRootSize;
+            const sourceY0 = root.y * sourceRootSize;
             for (const rect of root.rects) {
-                const sourceX0 = root.x * sourceRootSize;
-                const sourceY0 = root.y * sourceRootSize;
                 const pixelX0 = Math.round((sourceX0 + root.xLines[rect.col0]) * scale);
                 const pixelY0 = Math.round((sourceY0 + root.yLines[rect.row0]) * scale);
                 const pixelX1 = Math.round((sourceX0 + root.xLines[rect.col1]) * scale);
                 const pixelY1 = Math.round((sourceY0 + root.yLines[rect.row1]) * scale);
                 if (pixelX0 >= pixelX1 || pixelY0 >= pixelY1)
                     continue;
-                const x0 = Math.floor(pixelX0 / 256), y0 = Math.floor(pixelY0 / 256);
-                const x1 = Math.floor((pixelX1 - 1) / 256), y1 = Math.floor((pixelY1 - 1) / 256);
-                const worldMax = 2 ** z - 1;
-                for (let tileY = Math.max(0, y0); tileY <= Math.min(worldMax, y1); tileY++) {
-                    for (let tileX = Math.max(0, x0); tileX <= Math.min(worldMax, x1); tileX++)
-                        coordinates.add(`${tileX}/${tileY}`);
+                const x0 = Math.max(0, Math.floor(pixelX0 / 256));
+                const y0 = Math.max(0, Math.floor(pixelY0 / 256));
+                const x1 = Math.min(worldMax, Math.floor((pixelX1 - 1) / 256));
+                const y1 = Math.min(worldMax, Math.floor((pixelY1 - 1) / 256));
+                for (let tileY = y0; tileY <= y1; tileY++) {
+                    const intervals = rows.get(tileY) || [];
+                    intervals.push([x0, x1]);
+                    rows.set(tileY, intervals);
+                }
+            }
+            for (const tileY of [...rows.keys()].sort((left, right) => left - right)) {
+                const intervals = rows.get(tileY).sort((left, right) => left[0] - right[0] || left[1] - right[1]);
+                let [start, end] = intervals[0];
+                for (let index = 1; index <= intervals.length; index++) {
+                    const next = intervals[index];
+                    if (next && next[0] <= end + 1) {
+                        end = Math.max(end, next[1]);
+                        continue;
+                    }
+                    for (let tileX = start; tileX <= end; tileX++)
+                        yield { z, x: tileX, y: tileY };
+                    if (next)
+                        [start, end] = next;
                 }
             }
-        for (const coordinate of [...coordinates].sort((left, right) => {
-            const [leftX, leftY] = left.split('/').map(Number), [rightX, rightY] = right.split('/').map(Number);
-            return leftX - rightX || leftY - rightY;
-        })) {
-            const [x, y] = coordinate.split('/').map(Number);
-            yield { z, x: x, y: y };
         }
     }
 }

package/dist/src/core/map-layer-paths.js

@@ -0,0 +1,11 @@
+import { resolve } from 'node:path';
+export const MAP_LAYER_SNAPSHOT_FILENAMES = {
+    dji: 'dji-nfz.json',
+    antigravity: 'antigravity-nfz.sqlite',
+};
+export function resolveMapLayerSnapshotPath(options) {
+    const explicitPath = options.explicitPath?.trim();
+    if (explicitPath)
+        return resolve(explicitPath);
+    return resolve(options.dataDir, 'map-layers', options.filename);
+}

package/dist/src/core/png.js

@@ -167,20 +167,73 @@ export function decodeUomAlphaMask(png, expectedWidth, expectedHeight = expected
 export function decodeCanonicalAlphaMask(png, expectedWidth, expectedHeight = expectedWidth) {
     return alphaMask(decodeIndexedPng(png, true), expectedWidth, expectedHeight);
 }
+function paeth(left, up, upLeft) {
+    const estimate = left + up - upLeft;
+    const leftDistance = Math.abs(estimate - left);
+    const upDistance = Math.abs(estimate - up);
+    const cornerDistance = Math.abs(estimate - upLeft);
+    return leftDistance <= upDistance && leftDistance <= cornerDistance ? left : upDistance <= cornerDistance ? up : upLeft;
+}
+function filterRows(rows, rowBytes, height) {
+    const output = Buffer.allocUnsafe((rowBytes + 1) * height);
+    for (let y = 0; y < height; y++) {
+        const rowOffset = y * rowBytes;
+        const outputOffset = y * (rowBytes + 1);
+        let bestFilter = 0;
+        let bestScore = Number.POSITIVE_INFINITY;
+        let best = Buffer.allocUnsafe(rowBytes);
+        for (let filter = 0; filter <= 4; filter++) {
+            const candidate = Buffer.allocUnsafe(rowBytes);
+            let score = 0;
+            for (let x = 0; x < rowBytes; x++) {
+                const current = rows[rowOffset + x];
+                const left = x > 0 ? rows[rowOffset + x - 1] : 0;
+                const up = y > 0 ? rows[rowOffset - rowBytes + x] : 0;
+                const upLeft = x > 0 && y > 0 ? rows[rowOffset - rowBytes + x - 1] : 0;
+                const prediction = filter === 0 ? 0
+                    : filter === 1 ? left
+                        : filter === 2 ? up
+                            : filter === 3 ? Math.floor((left + up) / 2)
+                                : paeth(left, up, upLeft);
+                const value = (current - prediction) & 0xff;
+                candidate[x] = value;
+                score += value < 128 ? value : 256 - value;
+            }
+            if (score < bestScore) {
+                bestFilter = filter;
+                bestScore = score;
+                best = candidate;
+            }
+        }
+        output[outputOffset] = bestFilter;
+        best.copy(output, outputOffset + 1);
+    }
+    return output;
+}
 export function encodeIndexedPng(width, height, indexes, palette, alpha) {
     if (indexes.length !== width * height)
         throw new RangeError('indexed PNG dimensions do not match pixels');
     if (palette.length === 0 || palette.length % 3 !== 0 || palette.length / 3 > 256)
         throw new RangeError('invalid indexed PNG palette');
-    const raw = Buffer.allocUnsafe((width + 1) * height);
-    for (let y = 0; y < height; y++) {
-        raw[y * (width + 1)] = 0;
-        raw.set(indexes.subarray(y * width, (y + 1) * width), y * (width + 1) + 1);
-    }
+    const paletteEntries = palette.length / 3;
+    const bitDepth = paletteEntries <= 2 ? 1 : paletteEntries <= 4 ? 2 : paletteEntries <= 16 ? 4 : 8;
+    const rowBytes = Math.ceil(width * bitDepth / 8);
+    const pixelsPerByte = 8 / bitDepth;
+    const rows = Buffer.alloc(rowBytes * height);
+    for (let y = 0; y < height; y++)
+        for (let x = 0; x < width; x++) {
+            const index = indexes[y * width + x];
+            if (index >= paletteEntries)
+                throw new RangeError('indexed PNG pixel exceeds palette');
+            const byte = y * rowBytes + Math.floor(x / pixelsPerByte);
+            const shift = 8 - bitDepth * (x % pixelsPerByte + 1);
+            rows[byte] = rows[byte] | index << shift;
+        }
+    const raw = filterRows(rows, rowBytes, height);
     const ihdr = Buffer.alloc(13);
     ihdr.writeUInt32BE(width, 0);
     ihdr.writeUInt32BE(height, 4);
-    ihdr[8] = 8;
+    ihdr[8] = bitDepth;
     ihdr[9] = 3;
     ihdr[10] = 0;
     ihdr[11] = 0;

package/dist/src/core/uomtiles.js

@@ -5,12 +5,14 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { DatabaseSync } from 'node:sqlite';
 import { UOMTILES_VERSION } from "../config.js";
+import { DEFAULT_EXPORT_MAX_ZOOM, DEFAULT_EXPORT_MIN_ZOOM, EXPORT_MAX_ZOOM, EXPORT_MIN_ZOOM, } from "../../shared/export.js";
 import { acquireSqliteLease } from "./lease.js";
 import { decodeCanonicalAlphaMask } from "./png.js";
-import { GeographicGridRenderer, PUBLISH_MAX_ZOOM } from "./grid-renderer.js";
+import { GeographicGridRenderer } from "./grid-renderer.js";
 import { xyzYToTmsY } from "../bbox.js";
 const execFileAsync = promisify(execFile);
 const UOMTILES_SCHEMA_VERSION = 1;
+const MIN_NONEMPTY_PNG_BYTES = 120;
 function tables(db) {
     return new Set(db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map(row => row.name));
 }
@@ -19,6 +21,63 @@ function metadata(db) {
         return {};
     return Object.fromEntries(db.prepare('SELECT name,value FROM metadata').all().map(row => [row.name, row.value]));
 }
+export function exportZoomRange(options = {}) {
+    const minZoom = options.minZoom ?? DEFAULT_EXPORT_MIN_ZOOM;
+    const maxZoom = options.maxZoom ?? DEFAULT_EXPORT_MAX_ZOOM;
+    if (!Number.isInteger(minZoom) || minZoom < EXPORT_MIN_ZOOM || minZoom > EXPORT_MAX_ZOOM) {
+        throw new RangeError(`最小导出层级必须是 z${EXPORT_MIN_ZOOM}–z${EXPORT_MAX_ZOOM} 的整数`);
+    }
+    if (!Number.isInteger(maxZoom) || maxZoom < EXPORT_MIN_ZOOM || maxZoom > EXPORT_MAX_ZOOM) {
+        throw new RangeError(`最大导出层级必须是 z${EXPORT_MIN_ZOOM}–z${EXPORT_MAX_ZOOM} 的整数`);
+    }
+    if (minZoom > maxZoom)
+        throw new RangeError('最小导出层级不能大于最大导出层级');
+    return { minZoom, maxZoom };
+}
+function projectedLevel(summary, zoom) {
+    const reencodedPngRatio = zoom <= 8 ? 0.93 : Math.max(0.58, 0.93 - (zoom - 8) * 0.075);
+    const known = new Map(summary.tiles.map(level => [level.z, level]));
+    const exact = known.get(zoom);
+    if (exact)
+        return {
+            tileCount: exact.count,
+            pngBytes: Math.max(exact.count * MIN_NONEMPTY_PNG_BYTES, Math.round(exact.bytes * reencodedPngRatio)),
+            tileCountExact: true,
+        };
+    const levels = [...known.values()].sort((left, right) => left.z - right.z);
+    const base = levels.reduce((nearest, level) => Math.abs(level.z - zoom) < Math.abs(nearest.z - zoom) ? level : nearest, levels[0]);
+    if (!base)
+        return { tileCount: 0, pngBytes: 0, tileCountExact: false };
+    const baseRatio = base.z <= 8 ? 0.93 : Math.max(0.58, 0.93 - (base.z - 8) * 0.075);
+    const baseAverage = Math.max(MIN_NONEMPTY_PNG_BYTES, base.bytes / Math.max(1, base.count) * baseRatio);
+    const distance = Math.abs(zoom - base.z);
+    if (zoom > base.z) {
+        const tileCount = Math.max(1, Math.round(base.count * 3.75 ** distance));
+        const average = MIN_NONEMPTY_PNG_BYTES + (baseAverage - MIN_NONEMPTY_PNG_BYTES) * 0.55 ** distance;
+        return { tileCount, pngBytes: Math.round(tileCount * average), tileCountExact: false };
+    }
+    const tileCount = Math.max(1, Math.round(base.count / 3.5 ** distance));
+    const average = Math.min(1_600, baseAverage * 1.25 ** distance);
+    return { tileCount, pngBytes: Math.round(tileCount * average), tileCountExact: false };
+}
+export function estimateExport(source, format, options = {}) {
+    const range = exportZoomRange(options);
+    const summary = inspectUomtiles(source);
+    const levels = [];
+    let tileCount = 0;
+    let pngBytes = 0;
+    for (let zoom = range.minZoom; zoom <= range.maxZoom; zoom++) {
+        const level = projectedLevel(summary, zoom);
+        tileCount += level.tileCount;
+        pngBytes += level.pngBytes;
+        levels.push({ zoom, tileCount: level.tileCount, estimatedBytes: level.pngBytes, tileCountExact: level.tileCountExact });
+    }
+    // Fresh MBTiles files pay for SQLite B-trees; PMTiles deduplicates PNG blobs and has compact varint directories.
+    const estimatedBytes = format === 'mbtiles'
+        ? pngBytes + tileCount * 80 + 128 * 1024
+        : Math.round(pngBytes * 0.82 + tileCount * 16 + 64 * 1024);
+    return { ...range, format, estimatedBytes, tileCount, levels, omitsEmptyTiles: true };
+}
 export function initializeUomtiles(path, publisher) {
     mkdirSync(dirname(path), { recursive: true });
     const db = new DatabaseSync(path);
@@ -131,9 +190,10 @@ export function inspectUomtiles(path) {
         db.close();
     }
 }
-export function exportMbtiles(source, target) {
+export function exportMbtiles(source, target, options = {}) {
     const input = resolve(source);
     const output = resolve(target);
+    const range = exportZoomRange(options);
     if (extname(output).toLowerCase() !== '.mbtiles')
         throw new Error('MBTiles 输出文件必须使用 .mbtiles 扩展名');
     const lock = acquireSqliteLease(input, 'writer');
@@ -143,29 +203,45 @@ export function exportMbtiles(source, target) {
     mkdirSync(dirname(output), { recursive: true });
     const sourceDb = new DatabaseSync(input, { readOnly: true });
     const outputDb = new DatabaseSync(temporary);
+    let complete = false;
     try {
         outputDb.exec(`PRAGMA journal_mode=OFF; PRAGMA synchronous=OFF;
       CREATE TABLE metadata(name TEXT PRIMARY KEY,value TEXT NOT NULL);
       CREATE TABLE tiles(zoom_level INTEGER NOT NULL,tile_column INTEGER NOT NULL,tile_row INTEGER NOT NULL,tile_data BLOB NOT NULL,
         PRIMARY KEY(zoom_level,tile_column,tile_row));`);
         const insertMeta = outputDb.prepare('INSERT INTO metadata(name,value) VALUES(?,?)');
-        const standard = new Set(['name', 'type', 'version', 'description', 'format', 'bounds', 'center', 'minzoom', 'attribution']);
         const meta = metadata(sourceDb);
         outputDb.exec('BEGIN');
-        for (const name of standard)
-            if (meta[name])
-                insertMeta.run(name, meta[name]);
         const summary = inspectUomtiles(input);
+        const bounds = meta.bounds || '73,17.5,135.5,54';
+        const [west, south, east, north] = bounds.split(',').map(Number);
+        const sourceCenter = meta.center?.split(',').map(Number);
+        const centerZoom = Math.min(range.maxZoom, Math.max(range.minZoom, Number.isFinite(sourceCenter?.[2]) ? sourceCenter[2] : 9));
+        const center = `${Number.isFinite(sourceCenter?.[0]) ? sourceCenter[0] : (west + east) / 2},${Number.isFinite(sourceCenter?.[1]) ? sourceCenter[1] : (south + north) / 2},${centerZoom}`;
+        const standard = {
+            name: meta.name || 'UOM适飞地图',
+            format: 'png',
+            bounds,
+            center,
+            minzoom: String(range.minZoom),
+            maxzoom: String(range.maxZoom),
+            type: 'overlay',
+            version: UOMTILES_VERSION,
+            description: meta.description || 'UOM适飞空域',
+            attribution: meta.attribution || 'CAAC UOM',
+        };
+        for (const [name, value] of Object.entries(standard))
+            insertMeta.run(name, value);
         insertMeta.run('uomtiles:publisher', summary.publisher || 'unknown');
         insertMeta.run('uomtiles:fetched_at', summary.finishedAt || summary.startedAt || 'unknown');
         insertMeta.run('uomtiles:source_zoom', String(summary.sourceZoom ?? 'unknown'));
         insertMeta.run('uomtiles:grid_level', String(summary.gridLevel ?? 'unknown'));
+        insertMeta.run('uomtiles:tool_version', UOMTILES_VERSION);
         const renderer = new GeographicGridRenderer(input);
-        insertMeta.run('maxzoom', String(renderer.available ? PUBLISH_MAX_ZOOM : Math.max(0, ...summary.tiles.map(tile => tile.z))));
         const insertTile = outputDb.prepare('INSERT INTO tiles VALUES(?,?,?,?)');
         let copied = 0;
         if (renderer.available) {
-            for (let z = 0; z <= PUBLISH_MAX_ZOOM; z++)
+            for (let z = range.minZoom; z <= range.maxZoom; z++)
                 for (const coordinate of renderer.contentCoordinates(z)) {
                     const tile = renderer.renderTile(z, coordinate.x, coordinate.y);
                     if (!tile)
@@ -177,7 +253,10 @@ export function exportMbtiles(source, target) {
                 }
         }
         else {
-            for (const row of sourceDb.prepare('SELECT zoom_level,tile_column,tile_row,tile_data FROM tiles ORDER BY zoom_level,tile_column,tile_row').iterate()) {
+            for (const row of sourceDb.prepare(`SELECT zoom_level,tile_column,tile_row,tile_data FROM tiles
+        WHERE zoom_level BETWEEN ? AND ? ORDER BY zoom_level,tile_column,tile_row`).iterate(range.minZoom, range.maxZoom)) {
+                if (!decodeCanonicalAlphaMask(row.tile_data, 256).some(Boolean))
+                    continue;
                 insertTile.run(row.zoom_level, row.tile_column, row.tile_row, row.tile_data);
                 copied++;
                 if (copied % 1_000 === 0)
@@ -186,7 +265,8 @@ export function exportMbtiles(source, target) {
         }
         lock.heartbeat();
         outputDb.exec('COMMIT');
-        outputDb.exec('CREATE UNIQUE INDEX tile_index ON tiles(zoom_level,tile_column,tile_row); PRAGMA optimize;');
+        outputDb.exec('PRAGMA optimize;');
+        complete = true;
     }
     catch (error) {
         try {
@@ -199,23 +279,26 @@ export function exportMbtiles(source, target) {
         outputDb.close();
         sourceDb.close();
         lock.release();
+        if (!complete && existsSync(temporary))
+            unlinkSync(temporary);
     }
     if (existsSync(output))
         unlinkSync(output);
     renameSync(temporary, output);
     return inspectUomtiles(output);
 }
-export async function exportTiles(source, target, pmtilesCommand = process.env.UOMTILES_PMTILES_COMMAND || 'pmtiles') {
+export async function exportTiles(source, target, options = {}) {
     const extension = extname(target).toLowerCase();
     if (extension === '.mbtiles') {
-        exportMbtiles(source, target);
+        exportMbtiles(source, target, options);
         return;
     }
     if (extension !== '.pmtiles')
         throw new Error('输出文件必须使用 .mbtiles 或 .pmtiles 扩展名');
     const intermediate = `${resolve(target)}.${process.pid}.mbtiles`;
+    const pmtilesCommand = options.pmtilesCommand || process.env.UOMTILES_PMTILES_COMMAND || 'pmtiles';
     try {
-        exportMbtiles(source, intermediate);
+        exportMbtiles(source, intermediate, options);
         await execFileAsync(pmtilesCommand, ['convert', intermediate, resolve(target), '--force', '--quiet'], { timeout: 30 * 60_000 });
     }
     catch (error) {