uomtiles 0.1.0

package/.output/server/chunks/_/file-workspace.mjs

@@ -0,0 +1,910 @@
+import { c as createError, u as useRuntimeConfig } from '../nitro/nitro.mjs';
+import { open as open$1 } from 'node:fs/promises';
+import { statSync, existsSync, mkdirSync, unlinkSync, renameSync, createReadStream, mkdtempSync, rmSync, createWriteStream, chmodSync, openSync, readSync, closeSync, readdirSync } from 'node:fs';
+import { DatabaseSync } from 'node:sqlite';
+import { PMTiles, tileIdToZxy, bytesToHeader } from 'pmtiles';
+import { a as encodeCanonicalMask, b as tileRangeForBBox, C as CHINA_BBOX_LL, x as xyzYToTmsY } from './config.mjs';
+import { randomUUID } from 'node:crypto';
+import { dirname, extname, resolve, basename, sep } from 'node:path';
+import { hostname, tmpdir } from 'node:os';
+import { execFile, spawn } from 'node:child_process';
+import { pipeline } from 'node:stream/promises';
+import { promisify } from 'node:util';
+import { s as serverDataDirectory, w as workspaceDirectory, a as accountFile } from './data-directory.mjs';
+
+const GEOGRAPHIC_GRID_LEVEL = 18;
+const GEOGRAPHIC_GRID_STEP = 360 / 2 ** GEOGRAPHIC_GRID_LEVEL;
+function mercatorLatitude(globalY, worldSize) {
+  return 180 / Math.PI * Math.atan(Math.sinh(Math.PI - 2 * Math.PI * globalY / worldSize));
+}
+function mercatorY(latitude, worldSize) {
+  const radians = latitude * Math.PI / 180;
+  return worldSize * (1 - Math.log(Math.tan(radians) + 1 / Math.cos(radians)) / Math.PI) / 2;
+}
+function geographicGridLines(extent) {
+  const childrenPerSide = 2 ** (extent.sourceZ - extent.parentZ);
+  const worldSize = 256 * 2 ** extent.sourceZ;
+  const globalX0 = extent.parentX * childrenPerSide * 256;
+  const globalY0 = extent.parentY * childrenPerSide * 256;
+  const xPitch = worldSize / 2 ** GEOGRAPHIC_GRID_LEVEL;
+  const xLines = [];
+  for (let x = Math.floor(globalX0 / xPitch) * xPitch; x <= globalX0 + extent.width; x += xPitch) {
+    xLines.push(x - globalX0);
+  }
+  const latitudeTop = mercatorLatitude(globalY0, worldSize);
+  const latitudeBottom = mercatorLatitude(globalY0 + extent.width, worldSize);
+  const yLines = [];
+  for (let k = Math.ceil(latitudeTop / GEOGRAPHIC_GRID_STEP); k >= Math.floor(latitudeBottom / GEOGRAPHIC_GRID_STEP); k--) {
+    const y = mercatorY(k * GEOGRAPHIC_GRID_STEP, worldSize) - globalY0;
+    if (y >= -8 && y <= extent.width + 8) yLines.push(y);
+  }
+  yLines.sort((a, b) => a - b);
+  return { xLines, yLines };
+}
+function renderGeographicGridTile(model, extent, targetZ, tileX, tileY) {
+  if (targetZ < extent.parentZ) throw new RangeError("target tile must not be below the grid root zoom");
+  const rootScale = 2 ** (targetZ - extent.parentZ);
+  if (Math.floor(tileX / rootScale) !== extent.parentX || Math.floor(tileY / rootScale) !== extent.parentY) {
+    return new Uint8Array(256 * 256);
+  }
+  const scale = 2 ** (targetZ - extent.sourceZ);
+  const sourceRootSize = 256 * 2 ** (extent.sourceZ - extent.parentZ);
+  const sourceX0 = extent.parentX * sourceRootSize;
+  const sourceY0 = extent.parentY * sourceRootSize;
+  const tileX0 = tileX * 256;
+  const tileY0 = tileY * 256;
+  const output = new Uint8Array(256 * 256);
+  for (const rect of model.rects) {
+    const x0 = Math.max(0, Math.round((sourceX0 + model.xLines[rect.col0]) * scale) - tileX0);
+    const y0 = Math.max(0, Math.round((sourceY0 + model.yLines[rect.row0]) * scale) - tileY0);
+    const x1 = Math.min(256, Math.round((sourceX0 + model.xLines[rect.col1]) * scale) - tileX0);
+    const y1 = Math.min(256, Math.round((sourceY0 + model.yLines[rect.row1]) * scale) - tileY0);
+    if (x0 >= x1 || y0 >= y1) continue;
+    for (let y = y0; y < y1; y++) output.fill(1, y * 256 + x0, y * 256 + x1);
+  }
+  return output;
+}
+
+function deriveParentMask(children) {
+  if (children.length !== 4) throw new RangeError("exactly four children are required");
+  const big = new Uint8Array(512 * 512);
+  const offsets = [[0, 0], [256, 0], [0, 256], [256, 256]];
+  for (let index = 0; index < children.length; index++) {
+    const child = children[index];
+    if (!child) continue;
+    if (child.length !== 256 * 256) throw new RangeError("child mask must be 256x256");
+    const [offsetX, offsetY] = offsets[index];
+    for (let y = 0; y < 256; y++) {
+      big.set(child.subarray(y * 256, y * 256 + 256), (offsetY + y) * 512 + offsetX);
+    }
+  }
+  const parent = new Uint8Array(256 * 256);
+  for (let y = 0; y < 256; y++) {
+    for (let x = 0; x < 256; x++) {
+      const sx = x * 2;
+      const sy = y * 2;
+      parent[y * 256 + x] = big[sy * 512 + sx] | big[sy * 512 + sx + 1] | big[(sy + 1) * 512 + sx] | big[(sy + 1) * 512 + sx + 1];
+    }
+  }
+  return parent;
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const ROOT_ZOOM = 9;
+const SOURCE_ZOOM = 12;
+const DYNAMIC_MAX_ZOOM = 18;
+const PUBLISH_MAX_ZOOM = 14;
+const sourceRootSize = 256 * 2 ** (SOURCE_ZOOM - ROOT_ZOOM);
+function decodeRectangles(value) {
+  if (value.byteLength % 8 !== 0) throw new Error("invalid grid rectangle payload");
+  const buffer = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+  const rects = [];
+  for (let offset = 0; offset < buffer.length; offset += 8) {
+    rects.push({
+      col0: buffer.readUInt16LE(offset),
+      row0: buffer.readUInt16LE(offset + 2),
+      col1: buffer.readUInt16LE(offset + 4),
+      row1: buffer.readUInt16LE(offset + 6)
+    });
+  }
+  return rects;
+}
+function rootRange(z, coordinate) {
+  if (z >= ROOT_ZOOM) {
+    const root = Math.floor(coordinate / 2 ** (z - ROOT_ZOOM));
+    return [root, root];
+  }
+  const scale = 2 ** (ROOT_ZOOM - z);
+  return [coordinate * scale, (coordinate + 1) * scale - 1];
+}
+class GeographicGridRenderer {
+  constructor(path) {
+    __publicField(this, "roots", /* @__PURE__ */ new Map());
+    __publicField(this, "masks", /* @__PURE__ */ new Map());
+    const db = new DatabaseSync(path, { readOnly: true });
+    try {
+      const table = db.prepare("SELECT 1 ok FROM sqlite_master WHERE type='table' AND name='grid_roots'").get();
+      if (!table) return;
+      const columns = new Set(db.prepare("PRAGMA table_info(grid_roots)").all().map((column) => column.name));
+      if (!columns.has("rectangles")) return;
+      const rows = db.prepare(`SELECT root_x x,root_y y,rectangles FROM grid_roots
+        WHERE state='completed' AND rectangles IS NOT NULL AND length(rectangles)>0`).all();
+      for (const row of rows) {
+        const lines = geographicGridLines({ sourceZ: SOURCE_ZOOM, parentZ: ROOT_ZOOM, parentX: row.x, parentY: row.y, width: sourceRootSize });
+        this.roots.set(`${row.x}/${row.y}`, { x: row.x, y: row.y, rects: decodeRectangles(row.rectangles), ...lines });
+      }
+    } finally {
+      db.close();
+    }
+  }
+  get available() {
+    return this.roots.size > 0;
+  }
+  hasGeometry(z, x, y) {
+    const [rootX0, rootX1] = rootRange(z, x);
+    const [rootY0, rootY1] = rootRange(z, y);
+    for (let rootY = rootY0; rootY <= rootY1; rootY++) for (let rootX = rootX0; rootX <= rootX1; rootX++) {
+      if (this.roots.has(`${rootX}/${rootY}`)) return true;
+    }
+    return false;
+  }
+  renderMask(z, x, y) {
+    if (!Number.isInteger(z) || z < 0 || z > DYNAMIC_MAX_ZOOM) throw new RangeError(`unsupported dynamic zoom z${z}`);
+    const key = `${z}/${x}/${y}`;
+    const cached = this.masks.get(key);
+    if (cached) return cached;
+    if (!this.hasGeometry(z, x, y)) return new Uint8Array(256 * 256);
+    if (z < ROOT_ZOOM) {
+      const mask2 = deriveParentMask([
+        this.renderMask(z + 1, x * 2, y * 2),
+        this.renderMask(z + 1, x * 2 + 1, y * 2),
+        this.renderMask(z + 1, x * 2, y * 2 + 1),
+        this.renderMask(z + 1, x * 2 + 1, y * 2 + 1)
+      ]);
+      this.masks.set(key, mask2);
+      return mask2;
+    }
+    const mask = new Uint8Array(256 * 256);
+    const [rootX0, rootX1] = rootRange(z, x);
+    const [rootY0, rootY1] = rootRange(z, y);
+    for (let rootY = rootY0; rootY <= rootY1; rootY++) for (let rootX = rootX0; rootX <= rootX1; rootX++) {
+      const root = this.roots.get(`${rootX}/${rootY}`);
+      if (!root) continue;
+      const rendered = renderGeographicGridTile(
+        { rects: root.rects, xLines: root.xLines, yLines: root.yLines },
+        { sourceZ: SOURCE_ZOOM, parentZ: ROOT_ZOOM, parentX: rootX, parentY: rootY},
+        z,
+        x,
+        y
+      );
+      for (let pixel = 0; pixel < mask.length; pixel++) if (rendered[pixel]) mask[pixel] = 1;
+    }
+    if (this.masks.size < 512) this.masks.set(key, mask);
+    return mask;
+  }
+  renderTile(z, x, y) {
+    const mask = this.renderMask(z, x, y);
+    return mask.some(Boolean) ? encodeCanonicalMask(mask) : null;
+  }
+  *contentCoordinates(z) {
+    const coordinates = /* @__PURE__ */ new Set();
+    if (z < ROOT_ZOOM) {
+      const scale2 = 2 ** (ROOT_ZOOM - z);
+      for (const root of this.roots.values()) coordinates.add(`${Math.floor(root.x / scale2)}/${Math.floor(root.y / scale2)}`);
+      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, y };
+      }
+      return;
+    }
+    const scale = 2 ** (z - SOURCE_ZOOM);
+    for (const root of this.roots.values()) 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}`);
+      }
+    }
+    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, y };
+    }
+  }
+}
+
+const archives = /* @__PURE__ */ new Map();
+const geometry = /* @__PURE__ */ new Map();
+function cacheKey(path) {
+  var _a, _b;
+  const stat = statSync(path);
+  const walPath = `${path}-wal`;
+  const wal = existsSync(walPath) ? statSync(walPath) : null;
+  return `${path}:${stat.size}:${stat.mtimeMs}:${(_a = wal == null ? void 0 : wal.size) != null ? _a : 0}:${(_b = wal == null ? void 0 : wal.mtimeMs) != null ? _b : 0}`;
+}
+function taskTileProgress(path, z, x, y) {
+  var _a;
+  const db = new DatabaseSync(path, { readOnly: true });
+  try {
+    const tables = new Set(db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map((row) => row.name));
+    if (!tables.has("uomtiles_task")) return null;
+    const task = db.prepare("SELECT state FROM uomtiles_task LIMIT 1").get();
+    if (!task || task.state === "completed") return null;
+    const root = tables.has("grid_roots") ? db.prepare("SELECT MIN(root_z) z,COUNT(*) count FROM grid_roots").get() : { z: null, count: 0 };
+    const rootZoom = (_a = root.z) != null ? _a : 9;
+    const scale = 2 ** Math.abs(rootZoom - z);
+    let xMin = z < rootZoom ? x * scale : Math.floor(x / scale);
+    let xMax = z < rootZoom ? (x + 1) * scale - 1 : xMin;
+    let yMin = z < rootZoom ? y * scale : Math.floor(y / scale);
+    let yMax = z < rootZoom ? (y + 1) * scale - 1 : yMin;
+    if (root.count === 0) {
+      const china = tileRangeForBBox(rootZoom, CHINA_BBOX_LL.lonMin, CHINA_BBOX_LL.latMin, CHINA_BBOX_LL.lonMax, CHINA_BBOX_LL.latMax);
+      xMin = Math.max(xMin, china.xMin);
+      xMax = Math.min(xMax, china.xMax);
+      yMin = Math.max(yMin, china.yMin);
+      yMax = Math.min(yMax, china.yMax);
+      if (xMin > xMax || yMin > yMax) return null;
+      return { completed: 0, total: (xMax - xMin + 1) * (yMax - yMin + 1) };
+    }
+    const progress = db.prepare(`SELECT COUNT(*) total,
+      COALESCE(SUM(CASE WHEN state='completed' THEN 1 ELSE 0 END),0) completed
+      FROM grid_roots WHERE root_z=? AND root_x BETWEEN ? AND ? AND root_y BETWEEN ? AND ?`).get(rootZoom, xMin, xMax, yMin, yMax);
+    return progress.total > 0 ? { completed: Number(progress.completed), total: Number(progress.total) } : null;
+  } finally {
+    db.close();
+  }
+}
+function pmtiles(path) {
+  const key = cacheKey(path);
+  const cached = archives.get(key);
+  if (cached) return cached;
+  const source = {
+    path,
+    getKey: () => key,
+    async getBytes(offset, length) {
+      const file = await open$1(path, "r");
+      try {
+        const buffer = Buffer.allocUnsafe(length);
+        const { bytesRead } = await file.read(buffer, 0, length, offset);
+        return { data: buffer.subarray(0, bytesRead).buffer.slice(buffer.byteOffset, buffer.byteOffset + bytesRead) };
+      } finally {
+        await file.close();
+      }
+    }
+  };
+  const archive = new PMTiles(source);
+  archives.set(key, archive);
+  while (archives.size > 4) archives.delete(archives.keys().next().value);
+  return archive;
+}
+function renderer(path) {
+  const key = cacheKey(path);
+  const cached = geometry.get(key);
+  if (cached) return cached;
+  const created = new GeographicGridRenderer(path);
+  geometry.set(key, created);
+  while (geometry.size > 4) geometry.delete(geometry.keys().next().value);
+  return created;
+}
+async function readTileFile(file, z, x, y) {
+  var _a;
+  return (_a = (await readTileFiles(file, [{ z, x, y }]))[0]) != null ? _a : null;
+}
+async function readTileFiles(file, coordinates) {
+  if (file.kind === "pmtiles") {
+    const archive = pmtiles(file.path);
+    return await Promise.all(coordinates.map(async ({ z, x, y }) => {
+      const tile = await archive.getZxy(z, x, y);
+      return tile ? Buffer.from(tile.data) : null;
+    }));
+  }
+  const db = new DatabaseSync(file.path, { readOnly: true });
+  const tiles = [];
+  try {
+    const hasTiles = Boolean(db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='tiles'").get());
+    if (!hasTiles) return coordinates.map(() => null);
+    const select = db.prepare("SELECT tile_data FROM tiles WHERE zoom_level=? AND tile_column=? AND tile_row=?");
+    for (const { z, x, y } of coordinates) {
+      const row = select.get(z, x, xyzYToTmsY(z, y));
+      tiles.push(row ? Buffer.from(row.tile_data) : null);
+    }
+  } finally {
+    db.close();
+  }
+  if (file.kind !== "uomtiles") return tiles;
+  const dynamic = renderer(file.path);
+  if (!dynamic.available) return tiles;
+  return tiles.map((tile, index) => {
+    const coordinate = coordinates[index];
+    return tile || coordinate.z > DYNAMIC_MAX_ZOOM ? tile : dynamic.renderTile(coordinate.z, coordinate.x, coordinate.y);
+  });
+}
+async function tileFileCoordinates(file) {
+  if (file.kind !== "pmtiles") {
+    const db = new DatabaseSync(file.path, { readOnly: true });
+    try {
+      const hasTiles = Boolean(db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='tiles'").get());
+      if (!hasTiles) return [];
+      const rows = db.prepare(`SELECT zoom_level z,tile_column x,((1 << zoom_level)-1-tile_row) y
+        FROM tiles ORDER BY zoom_level,tile_column,((1 << zoom_level)-1-tile_row)`).all();
+      return rows.map(({ z, x, y }) => ({ z, x, y }));
+    } finally {
+      db.close();
+    }
+  }
+  const archive = pmtiles(file.path);
+  const header = await archive.getHeader();
+  const coordinates = [];
+  const visit = async (offset, length) => {
+    const entries = await archive.cache.getDirectory(archive.source, offset, length, header);
+    for (const entry of entries) {
+      if (entry.runLength === 0) {
+        await visit(header.leafDirectoryOffset + entry.offset, entry.length);
+        continue;
+      }
+      for (let index = 0; index < entry.runLength; index++) {
+        const [z, x, y] = tileIdToZxy(entry.tileId + index);
+        coordinates.push({ z, x, y });
+      }
+    }
+  };
+  await visit(header.rootDirectoryOffset, header.rootDirectoryLength);
+  coordinates.sort((left, right) => left.z - right.z || left.x - right.x || left.y - right.y);
+  return coordinates;
+}
+async function tileFileCoordinatesAtZoom(file, zoom) {
+  if (file.kind === "uomtiles") {
+    const dynamic = renderer(file.path);
+    if (dynamic.available) return [...dynamic.contentCoordinates(zoom)];
+  }
+  if (file.kind !== "pmtiles") {
+    const db = new DatabaseSync(file.path, { readOnly: true });
+    try {
+      const hasTiles = Boolean(db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='tiles'").get());
+      if (!hasTiles) return [];
+      return db.prepare(`SELECT zoom_level z,tile_column x,((1 << zoom_level)-1-tile_row) y
+        FROM tiles WHERE zoom_level=? ORDER BY tile_column,((1 << zoom_level)-1-tile_row)`).all(zoom).map(({ z, x, y }) => ({ z, x, y }));
+    } finally {
+      db.close();
+    }
+  }
+  return (await tileFileCoordinates(file)).filter((coordinate) => coordinate.z === zoom);
+}
+
+const DEFAULT_LEASE_MS = 3e4;
+function getSqliteLease(databasePath, resource, now = Date.now()) {
+  if (!existsSync(databasePath)) return null;
+  let db;
+  try {
+    db = new DatabaseSync(databasePath, { readOnly: true });
+  } catch {
+    return null;
+  }
+  try {
+    const table = db.prepare("SELECT 1 present FROM sqlite_master WHERE type='table' AND name='uomtiles_leases'").get();
+    if (!table) return null;
+    const row = db.prepare(`SELECT resource,owner,pid,hostname,acquired_at,heartbeat_at,expires_at
+      FROM uomtiles_leases WHERE resource=?`).get(resource);
+    if (!row || row.expires_at <= now) return null;
+    return {
+      resource: row.resource,
+      owner: row.owner,
+      pid: row.pid,
+      hostname: row.hostname,
+      acquiredAt: row.acquired_at,
+      heartbeatAt: row.heartbeat_at,
+      expiresAt: row.expires_at
+    };
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}
+function hasActiveSqliteLease(databasePath, resource, now = Date.now()) {
+  return Boolean(getSqliteLease(databasePath, resource, now));
+}
+function open(path) {
+  mkdirSync(dirname(path), { recursive: true });
+  const db = new DatabaseSync(path);
+  db.exec(`PRAGMA busy_timeout=5000;
+    CREATE TABLE IF NOT EXISTS uomtiles_leases(
+      resource TEXT PRIMARY KEY,
+      owner TEXT NOT NULL,
+      pid INTEGER NOT NULL,
+      hostname TEXT NOT NULL,
+      acquired_at INTEGER NOT NULL,
+      heartbeat_at INTEGER NOT NULL,
+      expires_at INTEGER NOT NULL);`);
+  return db;
+}
+function acquireSqliteLease(databasePath, resource, leaseMs = DEFAULT_LEASE_MS) {
+  if (!Number.isSafeInteger(leaseMs) || leaseMs <= 0) throw new RangeError("SQLite lease duration must be a positive integer");
+  const db = open(databasePath);
+  const owner = randomUUID();
+  const now = Date.now();
+  try {
+    db.exec("BEGIN IMMEDIATE");
+    const current = db.prepare("SELECT owner,pid,hostname,expires_at FROM uomtiles_leases WHERE resource=?").get(resource);
+    if (current && current.expires_at > now) {
+      throw new Error(`SQLite \u8D44\u6E90\u6B63\u88AB\u5360\u7528\uFF1A${resource} (pid ${current.pid} on ${current.hostname})`);
+    }
+    db.prepare(`INSERT OR REPLACE INTO uomtiles_leases(resource,owner,pid,hostname,acquired_at,heartbeat_at,expires_at)
+      VALUES(?,?,?,?,?,?,?)`).run(resource, owner, process.pid, hostname(), now, now, now + leaseMs);
+    db.exec("COMMIT");
+  } catch (error) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {
+    }
+    db.close();
+    throw error;
+  }
+  let released = false;
+  return {
+    resource,
+    owner,
+    heartbeat() {
+      if (released) return;
+      const heartbeatAt = Date.now();
+      const result = db.prepare("UPDATE uomtiles_leases SET heartbeat_at=?,expires_at=? WHERE resource=? AND owner=?").run(heartbeatAt, heartbeatAt + leaseMs, resource, owner);
+      if (result.changes !== 1) throw new Error(`SQLite lease \u5DF2\u4E22\u5931\uFF1A${resource}`);
+    },
+    release() {
+      if (released) return;
+      released = true;
+      try {
+        db.prepare("DELETE FROM uomtiles_leases WHERE resource=? AND owner=?").run(resource, owner);
+      } finally {
+        db.close();
+      }
+    }
+  };
+}
+
+const execFileAsync = promisify(execFile);
+const UOMTILES_SCHEMA_VERSION = 1;
+function tables(db) {
+  return new Set(db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map((row) => row.name));
+}
+function metadata(db) {
+  if (!tables(db).has("metadata")) return {};
+  return Object.fromEntries(db.prepare("SELECT name,value FROM metadata").all().map((row) => [row.name, row.value]));
+}
+function initializeUomtiles(path, publisher) {
+  mkdirSync(dirname(path), { recursive: true });
+  const db = new DatabaseSync(path);
+  try {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS metadata(name TEXT PRIMARY KEY,value TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS uomtiles_task(
+        id TEXT PRIMARY KEY,
+        schema_version INTEGER NOT NULL,
+        state TEXT NOT NULL,
+        publisher TEXT,
+        created_at TEXT NOT NULL,
+        started_at TEXT,
+        finished_at TEXT,
+        tool_version TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS uomtiles_review(
+        kind TEXT NOT NULL,
+        object_key TEXT NOT NULL,
+        state TEXT NOT NULL,
+        note TEXT,
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY(kind,object_key));
+      CREATE TABLE IF NOT EXISTS uomtiles_leases(
+        resource TEXT PRIMARY KEY,
+        owner TEXT NOT NULL,
+        pid INTEGER NOT NULL,
+        hostname TEXT NOT NULL,
+        acquired_at INTEGER NOT NULL,
+        heartbeat_at INTEGER NOT NULL,
+        expires_at INTEGER NOT NULL);
+    `);
+    const existing = db.prepare("SELECT id FROM uomtiles_task LIMIT 1").get();
+    if (!existing) {
+      const meta = metadata(db);
+      const createdAt = meta.crawl_started_at || (/* @__PURE__ */ new Date()).toISOString();
+      const finishedAt = meta.crawl_finished_at || null;
+      db.prepare(`INSERT INTO uomtiles_task(id,schema_version,state,publisher,created_at,started_at,finished_at,tool_version)
+        VALUES(?,?,?,?,?,?,?,?)`).run(
+        randomUUID(),
+        UOMTILES_SCHEMA_VERSION,
+        finishedAt ? "completed" : "incomplete",
+        publisher || null,
+        createdAt,
+        meta.crawl_started_at || null,
+        finishedAt,
+        process.env.npm_package_version || "0.1.0"
+      );
+    }
+    const upsert = db.prepare("INSERT OR REPLACE INTO metadata(name,value) VALUES(?,?)");
+    upsert.run("uomtiles_schema_version", String(UOMTILES_SCHEMA_VERSION));
+    if (publisher) upsert.run("publisher", publisher);
+  } finally {
+    db.close();
+  }
+}
+function inspectUomtiles(path) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const absolute = resolve(path);
+  const db = new DatabaseSync(absolute, { readOnly: true });
+  try {
+    const knownTables = tables(db);
+    const meta = metadata(db);
+    const task = knownTables.has("uomtiles_task") ? db.prepare("SELECT * FROM uomtiles_task LIMIT 1").get() : null;
+    const roots = knownTables.has("grid_roots") ? Object.fromEntries(db.prepare("SELECT state,COUNT(*) count FROM grid_roots GROUP BY state").all().map((row) => [row.state, row.count])) : {};
+    const tiles = knownTables.has("tiles") ? db.prepare("SELECT zoom_level z,COUNT(*) count,COALESCE(SUM(length(tile_data)),0) bytes FROM tiles GROUP BY zoom_level ORDER BY zoom_level").all() : [];
+    return {
+      path: absolute,
+      bytes: statSync(absolute).size,
+      schemaVersion: (_a = task == null ? void 0 : task.schema_version) != null ? _a : meta.uomtiles_schema_version ? Number(meta.uomtiles_schema_version) : null,
+      taskId: (_b = task == null ? void 0 : task.id) != null ? _b : null,
+      state: (task == null ? void 0 : task.state) === "completed" || meta.crawl_finished_at ? "completed" : "incomplete",
+      publisher: (_d = (_c = task == null ? void 0 : task.publisher) != null ? _c : meta.publisher) != null ? _d : null,
+      createdAt: (_f = (_e = task == null ? void 0 : task.created_at) != null ? _e : meta.crawl_started_at) != null ? _f : null,
+      startedAt: (_h = (_g = task == null ? void 0 : task.started_at) != null ? _g : meta.crawl_started_at) != null ? _h : null,
+      finishedAt: (_j = (_i = task == null ? void 0 : task.finished_at) != null ? _i : meta.crawl_finished_at) != null ? _j : null,
+      sourceZoom: meta.source_zoom ? Number(meta.source_zoom) : null,
+      gridLevel: meta.geographic_grid_level ? Number(meta.geographic_grid_level) : null,
+      roots,
+      tiles
+    };
+  } finally {
+    db.close();
+  }
+}
+function exportMbtiles(source, target) {
+  var _a, _b;
+  const input = resolve(source);
+  const output = resolve(target);
+  if (extname(output).toLowerCase() !== ".mbtiles") throw new Error("MBTiles \u8F93\u51FA\u6587\u4EF6\u5FC5\u987B\u4F7F\u7528 .mbtiles \u6269\u5C55\u540D");
+  const lock = acquireSqliteLease(input, "writer");
+  const temporary = `${output}.${process.pid}.tmp`;
+  if (existsSync(temporary)) unlinkSync(temporary);
+  mkdirSync(dirname(output), { recursive: true });
+  const sourceDb = new DatabaseSync(input, { readOnly: true });
+  const outputDb = new DatabaseSync(temporary);
+  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 = /* @__PURE__ */ 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);
+    insertMeta.run("uomtiles:publisher", summary.publisher || "unknown");
+    insertMeta.run("uomtiles:fetched_at", summary.finishedAt || summary.startedAt || "unknown");
+    insertMeta.run("uomtiles:source_zoom", String((_a = summary.sourceZoom) != null ? _a : "unknown"));
+    insertMeta.run("uomtiles:grid_level", String((_b = summary.gridLevel) != null ? _b : "unknown"));
+    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 (const coordinate of renderer.contentCoordinates(z)) {
+        const tile = renderer.renderTile(z, coordinate.x, coordinate.y);
+        if (!tile) continue;
+        insertTile.run(z, coordinate.x, xyzYToTmsY(z, coordinate.y), tile);
+        copied++;
+        if (copied % 1e3 === 0) lock.heartbeat();
+      }
+    } 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()) {
+        insertTile.run(row.zoom_level, row.tile_column, row.tile_row, row.tile_data);
+        copied++;
+        if (copied % 1e3 === 0) lock.heartbeat();
+      }
+    }
+    lock.heartbeat();
+    outputDb.exec("COMMIT");
+    outputDb.exec("CREATE UNIQUE INDEX tile_index ON tiles(zoom_level,tile_column,tile_row); PRAGMA optimize;");
+  } catch (error) {
+    try {
+      outputDb.exec("ROLLBACK");
+    } catch {
+    }
+    throw error;
+  } finally {
+    outputDb.close();
+    sourceDb.close();
+    lock.release();
+  }
+  if (existsSync(output)) unlinkSync(output);
+  renameSync(temporary, output);
+  return inspectUomtiles(output);
+}
+async function exportTiles(source, target, pmtilesCommand = process.env.UOMTILES_PMTILES_COMMAND || "pmtiles") {
+  const extension = extname(target).toLowerCase();
+  if (extension === ".mbtiles") {
+    exportMbtiles(source, target);
+    return;
+  }
+  if (extension !== ".pmtiles") throw new Error("\u8F93\u51FA\u6587\u4EF6\u5FC5\u987B\u4F7F\u7528 .mbtiles \u6216 .pmtiles \u6269\u5C55\u540D");
+  const intermediate = `${resolve(target)}.${process.pid}.mbtiles`;
+  try {
+    exportMbtiles(source, intermediate);
+    await execFileAsync(pmtilesCommand, ["convert", intermediate, resolve(target), "--force", "--quiet"], { timeout: 30 * 6e4 });
+  } catch (error) {
+    if ((error == null ? void 0 : error.code) === "ENOENT") throw new Error(`\u627E\u4E0D\u5230 ${pmtilesCommand}\uFF1B\u8BF7\u5B89\u88C5 Protomaps pmtiles CLI \u6216\u8BBE\u7F6E UOMTILES_PMTILES_COMMAND`);
+    throw error;
+  } finally {
+    if (existsSync(intermediate)) unlinkSync(intermediate);
+  }
+}
+
+const FETCH_PROCESS_ENV = "UOMTILES_FETCH_PROCESS";
+function decodeFetchProcess(value) {
+  if (!value) throw new Error(`${FETCH_PROCESS_ENV} is not configured`);
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new Error(`${FETCH_PROCESS_ENV} is invalid`);
+  }
+  if (!parsed || typeof parsed !== "object") throw new Error(`${FETCH_PROCESS_ENV} is invalid`);
+  const spec = parsed;
+  if (typeof spec.command !== "string" || !spec.command || !Array.isArray(spec.args) || spec.args.some((arg) => typeof arg !== "string")) {
+    throw new Error(`${FETCH_PROCESS_ENV} is invalid`);
+  }
+  return { command: spec.command, args: spec.args };
+}
+
+const workers = /* @__PURE__ */ new Map();
+function root() {
+  const path = workspaceDirectory(serverDataDirectory());
+  mkdirSync(path, { recursive: true });
+  return path;
+}
+function authPath() {
+  return accountFile(serverDataDirectory());
+}
+function removeOrphanWorkspaceSidecars(directory) {
+  const databases = /* @__PURE__ */ new Set();
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    if (!entry.isFile() || !/\.uomtiles-(?:wal|shm)$/i.test(entry.name)) continue;
+    databases.add(resolve(directory, entry.name.replace(/-(?:wal|shm)$/i, "")));
+  }
+  for (const database of databases) {
+    if (existsSync(database) && hasActiveSqliteLease(database, "writer")) continue;
+    for (const suffix of ["-wal", "-shm"]) {
+      const sidecar = `${database}${suffix}`;
+      if (existsSync(sidecar)) unlinkSync(sidecar);
+    }
+  }
+}
+function cleanWorkspaceFilename(filename) {
+  const candidate = filename.trim();
+  if (!candidate || basename(candidate) !== candidate || candidate.includes("/") || candidate.includes("\\") || candidate.includes("\0")) {
+    throw createError({ statusCode: 400, statusMessage: "\u6587\u4EF6\u540D\u4E0D\u5408\u6CD5" });
+  }
+  const clean = candidate.replace(/[^a-zA-Z0-9._\u4e00-\u9fff-]+/g, "_");
+  if (!clean || clean === "." || clean === "..") throw createError({ statusCode: 400, statusMessage: "\u6587\u4EF6\u540D\u4E0D\u5408\u6CD5" });
+  return clean;
+}
+function entries() {
+  const directory = root();
+  removeOrphanWorkspaceSidecars(directory);
+  return readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => ({ filename: entry.name, path: resolve(directory, entry.name), extension: extname(entry.name).slice(1).toLowerCase() })).filter((entry) => entry.extension === "uomtiles").map((entry) => ({ filename: entry.filename, path: entry.path, kind: "uomtiles" }));
+}
+function safeFilename(filename) {
+  let candidate;
+  try {
+    candidate = decodeURIComponent(filename);
+  } catch {
+    throw createError({ statusCode: 400, statusMessage: "\u5DE5\u4F5C\u533A\u6587\u4EF6\u540D\u7F16\u7801\u4E0D\u5408\u6CD5" });
+  }
+  if (!candidate || candidate === "." || candidate === ".." || basename(candidate) !== candidate || candidate.includes("\\") || candidate.includes("\0")) {
+    throw createError({ statusCode: 400, statusMessage: "\u5DE5\u4F5C\u533A\u6587\u4EF6\u540D\u4E0D\u5408\u6CD5" });
+  }
+  const workspaceRoot = root();
+  const target = resolve(workspaceRoot, candidate);
+  if (!target.startsWith(`${workspaceRoot}${sep}`)) throw createError({ statusCode: 400, statusMessage: "\u5DE5\u4F5C\u533A\u6587\u4EF6\u8DEF\u5F84\u4E0D\u5408\u6CD5" });
+  return candidate;
+}
+function resolveWorkspaceFile(filename) {
+  const candidate = safeFilename(filename);
+  const found = entries().find((entry) => entry.filename === candidate);
+  if (!found) throw createError({ statusCode: 404, statusMessage: "\u5DE5\u4F5C\u533A\u6587\u4EF6\u4E0D\u5B58\u5728" });
+  return found;
+}
+function validateTileFile(path, kind) {
+  if (kind === "pmtiles") {
+    const bytes = Buffer.alloc(127);
+    const file = openSync(path, "r");
+    try {
+      if (readSync(file, bytes, 0, bytes.length, 0) !== bytes.length) throw new Error("PMTiles header is truncated");
+      bytesToHeader(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+    } finally {
+      closeSync(file);
+    }
+    return;
+  }
+  const db = new DatabaseSync(path, { readOnly: true });
+  try {
+    const tables = new Set(db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map((row) => row.name));
+    if (kind === "uomtiles") {
+      if (!tables.has("uomtiles_task")) throw new Error("UOMTiles \u6587\u4EF6\u7F3A\u5C11 uomtiles_task \u8868");
+      return;
+    }
+    if (!tables.has("tiles")) throw new Error("SQLite \u6587\u4EF6\u7F3A\u5C11 tiles \u8868");
+    if (!tables.has("metadata")) throw new Error("MBTiles \u6587\u4EF6\u7F3A\u5C11 metadata \u8868");
+    db.prepare("SELECT zoom_level,tile_column,tile_row,tile_data FROM tiles LIMIT 1").get();
+  } finally {
+    db.close();
+  }
+}
+function publicSummary(summary, locked = true) {
+  const { path: _path, taskId: _taskId, ...publicValue } = summary;
+  return { ...publicValue, state: locked ? "running" : publicValue.state === "completed" ? "completed" : "incomplete" };
+}
+function readWorkspaceFile(entry) {
+  try {
+    const stat = statSync(entry.path);
+    validateTileFile(entry.path, entry.kind);
+    const locked = entry.kind === "uomtiles" && hasActiveSqliteLease(entry.path, "writer");
+    const summary = publicSummary(inspectUomtiles(entry.path), locked);
+    const zoomRange = { minZoom: 0, maxZoom: DYNAMIC_MAX_ZOOM };
+    return { filename: entry.filename, kind: entry.kind, bytes: stat.size, modifiedAt: stat.mtime.toISOString(), ...zoomRange, summary, locked };
+  } catch {
+    return null;
+  }
+}
+function listWorkspaceFiles() {
+  const files = entries().map(readWorkspaceFile).filter((entry) => Boolean(entry));
+  removeOrphanWorkspaceSidecars(root());
+  return files.sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt));
+}
+async function importWorkspaceFile(filename, input) {
+  const clean = cleanWorkspaceFilename(filename);
+  const extension = extname(clean).slice(1).toLowerCase();
+  if (extension !== "uomtiles") throw createError({ statusCode: 400, statusMessage: "\u5DE5\u4F5C\u533A\u4EC5\u652F\u6301 .uomtiles \u4EFB\u52A1\u6587\u4EF6" });
+  const target = resolve(root(), clean);
+  if (entries().some((entry) => entry.filename.toLocaleLowerCase() === clean.toLocaleLowerCase())) throw createError({ statusCode: 409, statusMessage: "\u5DE5\u4F5C\u533A\u4E2D\u5DF2\u5B58\u5728\u540C\u540D\u6587\u4EF6" });
+  const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await pipeline(input, createWriteStream(temporary, { flags: "wx", mode: 384 }));
+    if (statSync(temporary).size === 0) throw createError({ statusCode: 400, statusMessage: "\u6587\u4EF6\u4E3A\u7A7A" });
+    try {
+      validateTileFile(temporary, "uomtiles");
+    } catch (error) {
+      throw createError({ statusCode: 400, statusMessage: `\u6587\u4EF6\u683C\u5F0F\u65E0\u6548\uFF1A${error instanceof Error ? error.message : String(error)}` });
+    }
+    renameSync(temporary, target);
+  } catch (error) {
+    if (existsSync(temporary)) unlinkSync(temporary);
+    throw error;
+  }
+  return listWorkspaceFiles().find((entry) => entry.filename === clean);
+}
+function createWorkspaceTask(filename, publisher) {
+  const clean = cleanWorkspaceFilename(filename);
+  const extension = extname(clean);
+  if (extension && extension.toLowerCase() !== ".uomtiles" || clean === ".uomtiles") {
+    throw createError({ statusCode: 400, statusMessage: "\u4EFB\u52A1\u6587\u4EF6\u5FC5\u987B\u4F7F\u7528 .uomtiles \u6269\u5C55\u540D" });
+  }
+  const name = extension ? `${clean.slice(0, -extension.length)}.uomtiles` : `${clean}.uomtiles`;
+  if (entries().some((entry) => entry.filename.toLocaleLowerCase() === name.toLocaleLowerCase())) {
+    throw createError({ statusCode: 409, statusMessage: "\u540C\u540D\u4EFB\u52A1\u6587\u4EF6\u5DF2\u5B58\u5728" });
+  }
+  const storedName = name;
+  if (existsSync(resolve(root(), storedName))) throw createError({ statusCode: 409, statusMessage: "\u5DE5\u4F5C\u533A\u4E2D\u5DF2\u5B58\u5728\u540C\u540D\u6587\u4EF6" });
+  const target = resolve(root(), storedName);
+  const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    initializeUomtiles(temporary, publisher);
+    chmodSync(temporary, 384);
+    renameSync(temporary, target);
+  } catch (error) {
+    if (existsSync(temporary)) unlinkSync(temporary);
+    throw error;
+  }
+  return listWorkspaceFiles().find((entry) => entry.filename === storedName);
+}
+function deleteWorkspaceFile(filename) {
+  if (workers.has(filename)) throw createError({ statusCode: 409, statusMessage: "\u4E0B\u8F7D\u4E2D\u7684\u4EFB\u52A1\u4E0D\u80FD\u5220\u9664\uFF0C\u8BF7\u5148\u505C\u6B62\u4E0B\u8F7D" });
+  const file = resolveWorkspaceFile(filename);
+  if (file.kind !== "uomtiles") throw createError({ statusCode: 400, statusMessage: "\u53EA\u80FD\u5220\u9664\u5730\u56FE\u4E0B\u8F7D\u4EFB\u52A1" });
+  if (hasActiveSqliteLease(file.path, "writer")) throw createError({ statusCode: 409, statusMessage: "\u4EFB\u52A1\u6B63\u5728\u88AB\u5176\u4ED6\u8FDB\u7A0B\u4F7F\u7528\uFF0C\u6682\u65F6\u4E0D\u80FD\u5220\u9664" });
+  unlinkSync(file.path);
+  for (const suffix of ["-wal", "-shm"]) {
+    const sidecar = `${file.path}${suffix}`;
+    if (existsSync(sidecar)) unlinkSync(sidecar);
+  }
+}
+function startWorkspaceFetch(filename) {
+  const file = resolveWorkspaceFile(filename);
+  if (file.kind !== "uomtiles") throw createError({ statusCode: 400, statusMessage: "\u53EA\u6709 .uomtiles \u652F\u6301\u6293\u53D6\u548C\u65AD\u70B9\u7EED\u4F20" });
+  if (hasActiveSqliteLease(file.path, "writer") || workers.has(file.filename)) {
+    throw createError({ statusCode: 409, statusMessage: "\u8BE5\u4EFB\u52A1\u6B63\u5728\u4E0B\u8F7D" });
+  }
+  if (!existsSync(authPath())) throw createError({ statusCode: 401, statusMessage: "\u8BF7\u5148\u767B\u5F55 UOM" });
+  let spec;
+  try {
+    spec = decodeFetchProcess(process.env[FETCH_PROCESS_ENV]);
+  } catch (error) {
+    throw createError({ statusCode: 500, statusMessage: error instanceof Error ? error.message : String(error) });
+  }
+  const child = spawn(spec.command, spec.args, {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      UOMTILES_DATA_DIR: serverDataDirectory(),
+      UOMTILES_TASK_FILENAME: file.filename
+    },
+    stdio: "ignore"
+  });
+  workers.set(file.filename, { child });
+  const clear = () => {
+    var _a;
+    if (((_a = workers.get(file.filename)) == null ? void 0 : _a.child) === child) workers.delete(file.filename);
+  };
+  child.once("error", clear);
+  child.once("close", clear);
+  return listWorkspaceFiles();
+}
+function stopWorkspaceFetch(filename) {
+  const candidates = entries().filter((entry2) => entry2.kind === "uomtiles");
+  const entry = filename ? candidates.find((candidate) => candidate.filename === filename) : candidates.find((candidate) => Boolean(getSqliteLease(candidate.path, "writer")));
+  const lease = entry ? getSqliteLease(entry.path, "writer") : null;
+  const targetFilename = (entry == null ? void 0 : entry.filename) || filename;
+  const local = targetFilename ? workers.get(targetFilename) : void 0;
+  const pid = (local == null ? void 0 : local.child.pid) || (lease == null ? void 0 : lease.pid);
+  if (local) local.child.kill("SIGTERM");
+  else if ((lease == null ? void 0 : lease.hostname) === hostname() && pid && pid !== process.pid) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch (error) {
+      if ((error == null ? void 0 : error.code) !== "ESRCH") {
+        console.error(`\u505C\u6B62\u6293\u53D6\u5931\u8D25\uFF1A${(error == null ? void 0 : error.message) || String(error)}`);
+      }
+    }
+  }
+  return listWorkspaceFiles();
+}
+async function ensureWorkspaceExport(filename, format) {
+  const file = resolveWorkspaceFile(filename);
+  if (file.kind !== "uomtiles") throw createError({ statusCode: 400, statusMessage: "\u4EC5 .uomtiles \u53EF\u5BFC\u51FA" });
+  const directory = mkdtempSync(resolve(tmpdir(), "uomtiles-export-"));
+  const output = resolve(directory, `${file.filename.replace(/\.uomtiles$/i, "")}.${format}`);
+  try {
+    await exportTiles(file.path, output, String(useRuntimeConfig().pmtilesCommand || "pmtiles"));
+    return output;
+  } catch (error) {
+    rmSync(directory, { recursive: true, force: true });
+    throw error;
+  }
+}
+async function readWorkspaceTile(filename, z, x, y) {
+  return readTileFile(resolveWorkspaceFile(filename), z, x, y);
+}
+function workspaceTileProgress(filename, z, x, y) {
+  const file = resolveWorkspaceFile(filename);
+  return file.kind === "uomtiles" ? taskTileProgress(file.path, z, x, y) : null;
+}
+function workspaceReadStream(filename) {
+  const file = resolveWorkspaceFile(filename);
+  return { file, stream: createReadStream(file.path) };
+}
+
+export { workspaceTileProgress as a, readWorkspaceTile as b, readTileFiles as c, deleteWorkspaceFile as d, ensureWorkspaceExport as e, tileFileCoordinates as f, stopWorkspaceFetch as g, createWorkspaceTask as h, importWorkspaceFile as i, cleanWorkspaceFilename as j, hasActiveSqliteLease as k, listWorkspaceFiles as l, resolveWorkspaceFile as r, startWorkspaceFetch as s, tileFileCoordinatesAtZoom as t, validateTileFile as v, workspaceReadStream as w };
+//# sourceMappingURL=file-workspace.mjs.map