@loaders.gl/tile-converter 5.0.0-alpha.11 → 5.0.0-alpha.12

package/dist/v5/converter-cli.js

@@ -0,0 +1,1214 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/v5/conversion-api.ts
+var TileConversionError2;
+var init_conversion_api = __esm({
+  "src/v5/conversion-api.ts"() {
+    "use strict";
+    TileConversionError2 = class extends Error {
+      /** Stable machine-readable failure code. */
+      code;
+      /** Diagnostics associated with this failure. */
+      diagnostics;
+      /** Creates a typed conversion failure. */
+      constructor(code, message, diagnostics = []) {
+        super(message);
+        this.name = "TileConversionError";
+        this.code = code;
+        this.diagnostics = diagnostics;
+      }
+    };
+  }
+});
+
+// src/v5/resource-fetcher.ts
+function createTileConversionResourceFetcher(options) {
+  let consumed = options.initialInputBytes ?? 0;
+  if (!Number.isSafeInteger(options.maxInputBytes) || options.maxInputBytes < 1 || !Number.isSafeInteger(consumed) || consumed < 0 || consumed > options.maxInputBytes)
+    throw new TileConversionError2(
+      "INVALID_INPUT_MEMORY_LIMIT",
+      "Resource fetch requires a positive aggregate byte budget and valid initial bytes"
+    );
+  const fetcher = options.fetcher ?? fetch;
+  return async (input, requestOptions) => {
+    options.signal?.throwIfAborted();
+    const url = new URL(input instanceof Request ? input.url : String(input));
+    if (!["http:", "https:", "blob:", "data:"].includes(url.protocol))
+      throw new TileConversionError2(
+        "EXTERNAL_RESOURCE_UNSUPPORTED",
+        "Conversion transport requires HTTP(S), Blob or embedded data resources"
+      );
+    const requestSignal = requestOptions?.signal ?? (input instanceof Request ? input.signal : void 0);
+    const signal = options.signal && requestSignal ? AbortSignal.any([options.signal, requestSignal]) : options.signal ?? requestSignal;
+    const response = await fetcher(input, { ...requestOptions, signal });
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new TileConversionError2(
+        "BROWSER_SOURCE_FETCH_FAILED",
+        `Could not fetch conversion resource (${response.status})`
+      );
+    }
+    const reader = response.body?.getReader();
+    if (!reader)
+      throw new TileConversionError2(
+        "BROWSER_SOURCE_STREAM_UNAVAILABLE",
+        "Conversion resources require readable response streams"
+      );
+    const cancelRead = () => {
+      void reader.cancel(signal?.reason).catch(() => {
+      });
+    };
+    signal?.addEventListener("abort", cancelRead, { once: true });
+    const parts = [];
+    let byteLength = 0;
+    try {
+      while (true) {
+        signal?.throwIfAborted();
+        const { done, value } = await reader.read();
+        signal?.throwIfAborted();
+        if (done) break;
+        if (value.byteLength > options.maxInputBytes - consumed)
+          throw new TileConversionError2(
+            "INPUT_RESOURCE_TOO_LARGE",
+            "Selected contents and external dependencies exceed the aggregate input byte budget"
+          );
+        consumed += value.byteLength;
+        byteLength += value.byteLength;
+        parts.push(value);
+      }
+    } catch (error) {
+      await reader.cancel(error);
+      throw error;
+    } finally {
+      signal?.removeEventListener("abort", cancelRead);
+      reader.releaseLock();
+    }
+    const bytes = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const part of parts) {
+      bytes.set(part, offset);
+      offset += part.byteLength;
+    }
+    const boundedResponse = new Response(bytes, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    Object.defineProperty(boundedResponse, "url", { value: response.url });
+    return boundedResponse;
+  };
+}
+var init_resource_fetcher = __esm({
+  "src/v5/resource-fetcher.ts"() {
+    "use strict";
+    init_conversion_api();
+  }
+});
+
+// src/v5/archive-source.ts
+import { BlobFile, HttpFile } from "@loaders.gl/loader-utils";
+import { parseSLPKArchive } from "@loaders.gl/i3s";
+import { parse3DTilesArchive } from "@loaders.gl/3d-tiles";
+import { TileConversionError as TileConversionError3 } from "@loaders.gl/tile-converter/v5/core";
+async function openTileConversionArchive(descriptor, maxInputBytes, signal, fetcher = fetch) {
+  signal.throwIfAborted();
+  if (!["slpk", "3tz"].includes(descriptor.format))
+    throw new TileConversionError3("INVALID_ARCHIVE_SOURCE", "Select SLPK or 3TZ archive input");
+  validateArchiveEntityTag(descriptor.identity?.etag);
+  const transport = createTileConversionResourceFetcher({
+    maxInputBytes,
+    signal,
+    fetcher: async (url, options) => {
+      const response = await fetcher(url, options);
+      if (response.status !== 206) {
+        await response.body?.cancel();
+        throw new Error("Remote conversion archives require HTTP 206 byte-range responses.");
+      }
+      try {
+        validateArchiveResponseValidator(response.headers);
+      } catch (error) {
+        await response.body?.cancel(error);
+        throw error;
+      }
+      return response;
+    }
+  });
+  let file;
+  let closePromise;
+  async function closeFile() {
+    if (file) {
+      closePromise ??= file.close();
+      await closePromise;
+    }
+  }
+  try {
+    if (typeof descriptor.input === "string") {
+      if (!["http:", "https:"].includes(new URL(descriptor.input).protocol))
+        throw new Error("Use an HTTP(S) archive URL.");
+      const remote = new HttpFile(descriptor.input, {
+        fetch: (url, options) => transport(url, options),
+        consistency: "strict",
+        ...descriptor.identity
+      });
+      file = remote;
+      await remote.open(signal);
+    } else file = new BlobFile(descriptor.input);
+    const ownedFile = file;
+    file = void 0;
+    return await createTileConversionArchiveTransport(
+      ownedFile,
+      descriptor.format,
+      maxInputBytes,
+      signal,
+      descriptor
+    );
+  } catch (error) {
+    await closeFile();
+    throw error;
+  }
+}
+async function createTileConversionArchiveTransport(file, format, maxInputBytes, signal, descriptor) {
+  const rootUrl = `https://conversion.invalid/input.${format}`;
+  let closed = false;
+  let releasePromise;
+  let closePromise;
+  const closeFile = () => {
+    closed = true;
+    closePromise ??= file.close();
+    return closePromise;
+  };
+  const checkOpen = () => {
+    signal.throwIfAborted();
+    if (closed)
+      throw new TileConversionError3("ARCHIVE_SOURCE_CLOSED", "Conversion archive is closed");
+  };
+  try {
+    checkOpen();
+    if (!["slpk", "3tz"].includes(format) || !Number.isSafeInteger(maxInputBytes) || maxInputBytes < 1)
+      throw new TileConversionError3(
+        "INVALID_ARCHIVE_SOURCE",
+        "Archive source requires a supported format and positive safe byte budget"
+      );
+    if (!Number.isSafeInteger(file.size) || file.size < 0 || file.size > maxInputBytes)
+      throw new Error("Conversion archive input must be at most 16 MiB.");
+    let readBytes = 0;
+    const boundedFile = {
+      handle: file.handle,
+      size: file.size,
+      bigsize: file.bigsize,
+      url: file.url,
+      ...file.stat ? { stat: () => file.stat() } : {},
+      close: closeFile,
+      /** Checks indexed reads before allocation and forwards operation cancellation. */
+      read: async (start, length) => {
+        checkOpen();
+        if (!Number.isSafeInteger(length) || length < 0 || length > maxInputBytes - readBytes)
+          throw new TileConversionError3(
+            "INPUT_RESOURCE_TOO_LARGE",
+            "Archive indexed reads exceed the input budget"
+          );
+        readBytes += length;
+        const bytes = await file.read(start, length, signal);
+        checkOpen();
+        return bytes;
+      }
+    };
+    const archive = format === "slpk" ? await parseSLPKArchive(boundedFile) : await parse3DTilesArchive(boundedFile);
+    const root = new URL(rootUrl);
+    return {
+      rootUrl: format === "3tz" ? `${rootUrl}/tileset.json` : rootUrl,
+      descriptor: descriptor ? {
+        ...descriptor,
+        ...file instanceof HttpFile ? { identity: file.getIdentitySnapshot() } : {}
+      } : void 0,
+      /** Resolves only resources belonging to this archive, without external network fallback. */
+      fetcher: (async (input, options) => {
+        checkOpen();
+        options?.signal?.throwIfAborted();
+        const url = new URL(input instanceof Request ? input.url : String(input));
+        if (url.origin !== root.origin || url.pathname !== root.pathname && !url.pathname.startsWith(`${root.pathname}/`))
+          throw new Error("Conversion dependencies must resolve inside the selected archive.");
+        const path = decodeURIComponent(
+          url.pathname.slice(root.pathname.length).replace(/^\//, "")
+        );
+        if (path.includes("\\") || path.split("/").some((segment) => segment === ".." || segment === "."))
+          throw new Error("Archive dependency path cannot escape its root.");
+        const bytes = format === "slpk" ? await archive.getFile(path, "http") : await archive.getFile(path);
+        checkOpen();
+        options?.signal?.throwIfAborted();
+        return new Response(bytes);
+      }),
+      /** Releases the readable file on success, failure or cancellation. */
+      close: async () => {
+        closed = true;
+        releasePromise ??= archive.close();
+        await releasePromise;
+      }
+    };
+  } catch (error) {
+    await closeFile();
+    throw error;
+  }
+}
+function validateArchiveEntityTag(entityTag) {
+  if (entityTag !== void 0 && entityTag !== null && !/^"[\x21\x23-\x7e\x80-\xff]*"$/.test(entityTag))
+    throw new TileConversionError3(
+      "ARCHIVE_VALIDATOR_UNSUPPORTED",
+      "Remote archives require a strong quoted ETag, or Last-Modified without an ETag; weak/malformed ETags are unsupported"
+    );
+}
+function validateArchiveResponseValidator(headers) {
+  const entityTag = headers.get("etag");
+  validateArchiveEntityTag(entityTag);
+  if (entityTag !== null) return;
+  const lastModified = headers.get("last-modified");
+  const responseDate = headers.get("date");
+  const modifiedTime = parseArchiveHttpDate(lastModified);
+  const responseTime = parseArchiveHttpDate(responseDate);
+  if (!Number.isFinite(modifiedTime) || !Number.isFinite(responseTime) || responseTime - modifiedTime < 6e4)
+    throw new TileConversionError3(
+      "ARCHIVE_VALIDATOR_UNSUPPORTED",
+      "Last-Modified archive identity requires a valid Date at least 60 seconds later; otherwise supply a strong ETag"
+    );
+}
+function parseArchiveHttpDate(value) {
+  const milliseconds = value === null ? NaN : Date.parse(value);
+  return Number.isFinite(milliseconds) && new Date(milliseconds).toUTCString() === value ? milliseconds : NaN;
+}
+var init_archive_source = __esm({
+  "src/v5/archive-source.ts"() {
+    "use strict";
+    init_resource_fetcher();
+  }
+});
+
+// src/v5/node-source.ts
+import { open as open2, realpath } from "node:fs/promises";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse3DTilesArchive as parse3DTilesArchive2 } from "@loaders.gl/3d-tiles";
+import {
+  createBrowserTilesetConversionSource,
+  TileConversionError as TileConversionError4
+} from "@loaders.gl/tile-converter/v5/core";
+async function createNodeTilesetConversionSource(options) {
+  const maxInputBytes = options.maxInputBytes ?? NODE_TILESET_LIMITS.maxInputBytes;
+  const maxInputResources = options.maxInputResources ?? NODE_TILESET_LIMITS.maxInputResources;
+  const maxTilesetDocuments = options.maxTilesetDocuments ?? 1;
+  if (!Number.isSafeInteger(maxInputBytes) || maxInputBytes < 1 || maxInputBytes > NODE_TILESET_LIMITS.maxInputBytes || !Number.isSafeInteger(maxInputResources) || maxInputResources < 1 || maxInputResources > NODE_TILESET_LIMITS.maxInputResources || !Number.isSafeInteger(maxTilesetDocuments) || maxTilesetDocuments < 1 || maxTilesetDocuments > NODE_TILESET_LIMITS.maxTilesetDocuments || !["3d-tiles", "3tz"].includes(options.format ?? "3d-tiles"))
+    throw new TileConversionError4(
+      "INVALID_NODE_SOURCE_OPTIONS",
+      "Node sources require positive byte/resource budgets within the initial profile limits"
+    );
+  options.signal?.throwIfAborted();
+  const controller = new AbortController();
+  const lifetimeSignal = options.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+  let archiveFile;
+  let closeArchive;
+  let consumedReadBytes = 0;
+  const reserveRead = (length) => {
+    if (length > maxInputBytes - consumedReadBytes)
+      throw new TileConversionError4(
+        "INPUT_RESOURCE_TOO_LARGE",
+        "Local reads exceed the aggregate input budget"
+      );
+    consumedReadBytes += length;
+  };
+  try {
+    const inputUrl = /^(?:https?|file):/i.test(options.input) ? new URL(options.input) : void 0;
+    if (!inputUrl && /^[a-z][a-z\d+.-]*:/i.test(options.input) && !/^[a-z]:[\\/]/i.test(options.input))
+      throw new TileConversionError4(
+        "UNSUPPORTED_NODE_SOURCE",
+        "Use a local path, file URL or HTTP(S) tileset URL"
+      );
+    const remote = inputUrl && inputUrl.protocol !== "file:";
+    let rootUrl;
+    let transport;
+    let virtualRoot;
+    if (remote && options.format === "3tz") {
+      const archive = await openTileConversionArchive(
+        { input: inputUrl.href, format: "3tz" },
+        maxInputBytes,
+        lifetimeSignal,
+        options.fetcher
+      );
+      rootUrl = archive.rootUrl;
+      transport = archive.fetcher;
+      closeArchive = archive.close;
+    } else if (remote) {
+      rootUrl = inputUrl.href;
+      transport = options.fetcher ?? fetch;
+    } else {
+      const inputPath = await realpath(inputUrl ? fileURLToPath(inputUrl) : resolve(options.input));
+      lifetimeSignal.throwIfAborted();
+      const directory = dirname(inputPath);
+      virtualRoot = new URL("https://conversion.invalid/input/");
+      rootUrl = new URL(
+        options.format === "3tz" ? "tileset.json" : encodeURIComponent(basename(inputPath)),
+        virtualRoot
+      ).href;
+      if (options.format === "3tz") {
+        archiveFile = await openLocalFile(inputPath, maxInputBytes, lifetimeSignal, reserveRead);
+        const archive = await parse3DTilesArchive2(archiveFile);
+        transport = async (input, requestOptions) => {
+          lifetimeSignal.throwIfAborted();
+          requestOptions?.signal?.throwIfAborted();
+          const path = getLocalResourcePath(input, virtualRoot);
+          const bytes = await archive.getFile(path);
+          lifetimeSignal.throwIfAborted();
+          requestOptions?.signal?.throwIfAborted();
+          return new Response(bytes);
+        };
+      } else {
+        transport = async (input, requestOptions) => {
+          const path = getLocalResourcePath(input, virtualRoot);
+          const resolvedPath = await realpath(resolve(directory, path));
+          const relativePath = relative(directory, resolvedPath);
+          if (relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath))
+            throw new TileConversionError4(
+              "EXTERNAL_RESOURCE_UNSUPPORTED",
+              "Local dependencies must remain inside the tileset directory"
+            );
+          const signal = requestOptions?.signal ? AbortSignal.any([lifetimeSignal, requestOptions.signal]) : lifetimeSignal;
+          const file = await openLocalFile(resolvedPath, maxInputBytes, signal, reserveRead);
+          try {
+            return new Response(await file.read());
+          } finally {
+            await file.close();
+          }
+        };
+      }
+    }
+    const resourceFetcher = createTileConversionResourceFetcher({
+      maxInputBytes,
+      signal: lifetimeSignal,
+      fetcher: transport
+    });
+    const source = createBrowserTilesetConversionSource({
+      input: rootUrl,
+      maxInputBytes,
+      maxInputResources,
+      maxTilesetDocuments,
+      inspectNestedTilesets: options.inspectNestedTilesets,
+      fetcher: resourceFetcher
+    });
+    return {
+      fetcher: resourceFetcher,
+      /** Inspects declarations without opening tile payloads or decoding coordinates. */
+      async inspect(signal) {
+        const inspection = await source.inspect(
+          signal ? AbortSignal.any([lifetimeSignal, signal]) : lifetimeSignal
+        );
+        if (virtualRoot)
+          for (const resource of inspection.resources)
+            getLocalResourcePath(
+              new URL(resource.uri, resource.tilesetUrl ?? inspection.rootUrl),
+              virtualRoot
+            );
+        return inspection;
+      },
+      /** Reads each declared placement with the same lifetime-wide input budget. */
+      read: (inspection, signal) => source.read(
+        inspection,
+        signal ? AbortSignal.any([lifetimeSignal, signal]) : lifetimeSignal
+      ),
+      /** Cancels future reads and releases the archive handle. */
+      async close() {
+        controller.abort(new TileConversionError4("NODE_SOURCE_CLOSED", "Node source is closed"));
+        const file = archiveFile;
+        archiveFile = void 0;
+        await closeArchive?.();
+        await file?.close();
+      }
+    };
+  } catch (error) {
+    await closeArchive?.();
+    await archiveFile?.close();
+    throw error;
+  }
+}
+function getLocalResourcePath(input, root) {
+  const url = new URL(input instanceof Request ? input.url : String(input));
+  if (url.origin !== root.origin || !url.pathname.startsWith(root.pathname))
+    throw new TileConversionError4(
+      "EXTERNAL_RESOURCE_UNSUPPORTED",
+      "Dependencies must resolve inside the selected local input"
+    );
+  const path = decodeURIComponent(url.pathname.slice(root.pathname.length));
+  if (!path || path.startsWith("/") || path.includes("\\") || path.split("/").some((segment) => segment === ".." || segment === "."))
+    throw new TileConversionError4(
+      "EXTERNAL_RESOURCE_UNSUPPORTED",
+      "Dependency paths cannot escape the selected input"
+    );
+  return path;
+}
+async function openLocalFile(path, maxInputBytes, signal, reserveRead) {
+  signal.throwIfAborted();
+  const handle = await open2(path, "r");
+  try {
+    signal.throwIfAborted();
+    const information = await handle.stat();
+    if (!information.isFile() || !Number.isSafeInteger(information.size) || information.size > maxInputBytes)
+      throw new TileConversionError4(
+        "INPUT_RESOURCE_TOO_LARGE",
+        "Local input must be a regular file within the byte budget"
+      );
+    const size = information.size;
+    return {
+      handle,
+      size,
+      bigsize: BigInt(size),
+      url: path,
+      /** Reads a bounded range, checking cancellation and unexpected EOF between native reads. */
+      async read(start = 0, length = size - Number(start), readSignal) {
+        const operationSignal = readSignal ? AbortSignal.any([signal, readSignal]) : signal;
+        operationSignal.throwIfAborted();
+        const offset = Number(start);
+        if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(length) || length < 0 || offset > size - length)
+          throw new TileConversionError4(
+            "INVALID_INPUT_RANGE",
+            "Local file reads require a range inside the file"
+          );
+        reserveRead(length);
+        const bytes = new Uint8Array(length);
+        let readBytes = 0;
+        while (readBytes < length) {
+          operationSignal.throwIfAborted();
+          const result = await handle.read(
+            bytes,
+            readBytes,
+            length - readBytes,
+            offset + readBytes
+          );
+          if (result.bytesRead === 0)
+            throw new TileConversionError4(
+              "INPUT_FILE_TRUNCATED",
+              "Local input ended before its declared size"
+            );
+          readBytes += result.bytesRead;
+        }
+        operationSignal.throwIfAborted();
+        return bytes.buffer;
+      },
+      /** Releases the Node file handle. */
+      close: () => handle.close()
+    };
+  } catch (error) {
+    await handle.close();
+    throw error;
+  }
+}
+var NODE_TILESET_LIMITS;
+var init_node_source = __esm({
+  "src/v5/node-source.ts"() {
+    "use strict";
+    init_resource_fetcher();
+    init_archive_source();
+    NODE_TILESET_LIMITS = {
+      /** Aggregate response bytes and, separately, indexed archive read bytes. */
+      maxInputBytes: 16 * 1024 * 1024,
+      /** Declared content placements in the explicit root document. */
+      maxInputResources: 1e3,
+      /** Maximum root/external document placements inspected or traversed. */
+      maxTilesetDocuments: 32
+    };
+  }
+});
+
+// src/v5/node-i3s-source.ts
+var node_i3s_source_exports = {};
+__export(node_i3s_source_exports, {
+  createNodeI3SConversionSource: () => createNodeI3SConversionSource
+});
+import { realpath as realpath2 } from "node:fs/promises";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { resolve as resolve2 } from "node:path";
+import { TileConversionError as TileConversionError5 } from "@loaders.gl/tile-converter/v5/core";
+import {
+  createSelectedI3SMeshConversionSource,
+  inspectI3SMeshConversionSource,
+  createTileConversionArchiveTransport as createTileConversionArchiveTransport2,
+  openTileConversionArchive as openTileConversionArchive2
+} from "@loaders.gl/tile-converter/v5/adapters";
+async function createNodeI3SConversionSource(options) {
+  const maxInputBytes = options.maxInputBytes ?? NODE_TILESET_LIMITS.maxInputBytes;
+  const maxInputResources = options.maxInputResources ?? NODE_TILESET_LIMITS.maxInputResources;
+  if (!["i3s", "slpk"].includes(options.format) || !Number.isSafeInteger(maxInputBytes) || maxInputBytes < 1 || maxInputBytes > NODE_TILESET_LIMITS.maxInputBytes || !Number.isSafeInteger(maxInputResources) || maxInputResources < 1 || maxInputResources > NODE_TILESET_LIMITS.maxInputResources)
+    throw new TileConversionError5(
+      "INVALID_NODE_SOURCE_OPTIONS",
+      "I3S sources require positive budgets within the bounded input profile"
+    );
+  const controller = new AbortController();
+  const signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
+  signal.throwIfAborted();
+  let release;
+  let closePromise;
+  const close = async () => {
+    controller.abort(new TileConversionError5("NODE_SOURCE_CLOSED", "Node source is closed"));
+    closePromise ??= release?.() ?? Promise.resolve();
+    await closePromise;
+  };
+  try {
+    const remote = /^https?:/i.test(options.input);
+    if (options.format === "i3s" && !remote)
+      throw new TileConversionError5(
+        "UNSUPPORTED_NODE_SOURCE",
+        "I3S input requires an HTTP(S) layer URL; use slpk for a local archive"
+      );
+    let rootUrl;
+    let transport;
+    if (options.format === "slpk") {
+      const archive = remote ? await openTileConversionArchive2(
+        { input: options.input, format: "slpk" },
+        maxInputBytes,
+        signal,
+        options.fetcher
+      ) : await createTileConversionArchiveTransport2(
+        await openLocalFile(
+          await realpath2(
+            /^file:/i.test(options.input) ? fileURLToPath2(options.input) : resolve2(options.input)
+          ),
+          maxInputBytes,
+          signal,
+          () => {
+          }
+        ),
+        "slpk",
+        maxInputBytes,
+        signal
+      );
+      release = archive.close;
+      rootUrl = archive.rootUrl;
+      transport = archive.fetcher;
+    } else {
+      rootUrl = new URL(options.input).href;
+      transport = options.fetcher ?? fetch;
+    }
+    const bounded = createTileConversionResourceFetcher({
+      maxInputBytes,
+      signal,
+      fetcher: transport
+    });
+    let metadataBytes = 0;
+    const root = new URL(rootUrl);
+    const fetcher = async (input, requestOptions) => {
+      const url = new URL(input instanceof Request ? input.url : String(input));
+      if (url.origin === root.origin && (url.pathname === root.pathname || url.pathname.startsWith(`${root.pathname}/`))) {
+        for (const [key, value] of root.searchParams)
+          if (!url.searchParams.has(key)) url.searchParams.set(key, value);
+      }
+      const response = await bounded(
+        input instanceof Request ? new Request(url, input) : url,
+        requestOptions
+      );
+      if (response.url && response.url !== url.href)
+        throw new TileConversionError5(
+          "I3S_REDIRECT_UNSUPPORTED",
+          "Use the final I3S resource URL; redirected resource bases are not qualified"
+        );
+      const bytes = await response.arrayBuffer();
+      metadataBytes += bytes.byteLength;
+      const result = new Response(bytes, { status: response.status, headers: response.headers });
+      Object.defineProperty(result, "url", { value: response.url });
+      return result;
+    };
+    const selectionOptions = {
+      rootUrl,
+      fetcher,
+      signal,
+      maxInputBytes,
+      maxInputResources,
+      dracoLibraryOptions: { decoderProfile: "full" }
+    };
+    return {
+      close,
+      /** Reads only layer and node metadata, under the same lifetime-wide budget as conversion. */
+      async inspect(operationSignal) {
+        signal.throwIfAborted();
+        operationSignal?.throwIfAborted();
+        const activeSignal = operationSignal ? AbortSignal.any([signal, operationSignal]) : signal;
+        const operationFetcher = (input, requestOptions) => fetcher(input, {
+          ...requestOptions,
+          signal: requestOptions?.signal ? AbortSignal.any([activeSignal, requestOptions.signal]) : activeSignal
+        });
+        const inspection = await inspectI3SMeshConversionSource({
+          ...selectionOptions,
+          fetcher: operationFetcher,
+          signal: activeSignal
+        });
+        return { ...inspection, metadataBytes };
+      },
+      /** Creates an original-coordinate selected mesh source using application-provided Draco assets. */
+      select: (inspection, resourceIds, dracoLibraryOptions, features) => {
+        signal.throwIfAborted();
+        return createSelectedI3SMeshConversionSource(inspection, {
+          ...selectionOptions,
+          resourceIds,
+          dracoLibraryOptions,
+          features
+        });
+      }
+    };
+  } catch (error) {
+    await close();
+    throw error;
+  }
+}
+var init_node_i3s_source = __esm({
+  "src/v5/node-i3s-source.ts"() {
+    "use strict";
+    init_resource_fetcher();
+    init_node_source();
+  }
+});
+
+// src/v5/node-conversion.ts
+var node_conversion_exports = {};
+__export(node_conversion_exports, {
+  convertNodeTileset: () => convertNodeTileset,
+  writeNodeTileConversionOutput: () => writeNodeTileConversionOutput
+});
+import { mkdir, open as open3, rm, link, mkdtemp } from "node:fs/promises";
+import { dirname as dirname2, join, resolve as resolve3 } from "node:path";
+import { convertTileset, TileConversionError as TileConversionError6 } from "@loaders.gl/tile-converter/v5/core";
+import {
+  createSelectedMeshConversionSource,
+  measureMeshBytes,
+  SELECTED_MESH_LIMITS,
+  createMeshConversionCodec,
+  createI3SMeshConversionCodec,
+  createMeshTilesetSink,
+  createMeshHierarchyTilesetSink,
+  createI3SMeshSink,
+  encodeTileConversionArchiveInBatches
+} from "@loaders.gl/tile-converter/v5/adapters";
+async function convertNodeTileset(options) {
+  const signal = options.signal ?? new AbortController().signal;
+  const maxOutputBytes = options.maxOutputBytes ?? SELECTED_MESH_LIMITS.maxOutputBytes;
+  if (!["3d-tiles", "3tz", "slpk"].includes(options.outputFormat) || !Number.isSafeInteger(maxOutputBytes) || maxOutputBytes < 1 || maxOutputBytes > SELECTED_MESH_LIMITS.maxOutputBytes)
+    throw new TileConversionError6(
+      "INVALID_NODE_CONVERSION_OPTIONS",
+      "Select a supported output profile and a positive output budget at most 32 MiB"
+    );
+  const i3s = options.format === "i3s" || options.format === "slpk";
+  if (options.preserveHierarchy !== void 0 && typeof options.preserveHierarchy !== "boolean" || options.preserveHierarchy && (i3s || options.outputFormat === "slpk"))
+    throw new TileConversionError6(
+      "MESH_HIERARCHY_UNSUPPORTED",
+      "Hierarchy preservation requires 3D Tiles/3TZ input and output"
+    );
+  if (i3s && (options.outputFormat !== "slpk" && options.geometricError === void 0 || options.geometricError !== void 0 && (typeof options.geometricError !== "number" || !Number.isFinite(options.geometricError) || options.geometricError < 0)))
+    throw new TileConversionError6(
+      "MESH_GEOMETRIC_ERROR_INVALID",
+      "I3S to 3D Tiles requires an explicit nonnegative geometric error in meters"
+    );
+  if (i3s ? options.features !== void 0 : options.i3sFeatures !== void 0 || options.integratedMeshPolicy !== void 0 || options.geometricError !== void 0)
+    throw new TileConversionError6(
+      "INVALID_NODE_CONVERSION_OPTIONS",
+      "Feature and layer policies must match the selected input format"
+    );
+  const sourceOptions = {
+    ...options,
+    signal,
+    inspectNestedTilesets: true,
+    maxTilesetDocuments: options.maxTilesetDocuments ?? SELECTED_MESH_LIMITS.maxTilesetDocuments
+  };
+  const rawSource = i3s ? await createNodeI3SConversionSource({
+    ...sourceOptions,
+    format: options.format
+  }) : await createNodeTilesetConversionSource({
+    ...sourceOptions,
+    format: options.format
+  });
+  let files;
+  let report;
+  try {
+    const inspection = await rawSource.inspect(signal);
+    await import("@loaders.gl/polyfills");
+    const { getDracoLibraryOptions } = await import("@loaders.gl/draco/bundled");
+    const dracoLibraryOptions = getDracoLibraryOptions({
+      decoderProfile: "full",
+      useLocalLibraries: true
+    });
+    const selection = "select" in rawSource ? {
+      ...await rawSource.select(
+        inspection,
+        options.resourceIds,
+        dracoLibraryOptions,
+        options.i3sFeatures
+      ),
+      geometricError: (options.geometricError ?? 0) + SELECTED_MESH_LIMITS.maxPositionError
+    } : await createSelectedMeshConversionSource(
+      inspection,
+      {
+        resourceIds: options.resourceIds,
+        preserveHierarchy: options.preserveHierarchy,
+        features: options.features,
+        signal,
+        source: rawSource,
+        fetcher: rawSource.fetcher,
+        dracoLibraryOptions,
+        maxInputBytes: options.maxInputBytes
+      }
+    );
+    const { source, spatialContext, geometricError } = selection;
+    const common = {
+      source,
+      signal,
+      measureInputBytes: measureMeshBytes,
+      maxInputBytes: options.maxInputBytes ?? SELECTED_MESH_LIMITS.maxInputBytes,
+      maxOutputBytes,
+      maxInputResources: SELECTED_MESH_LIMITS.maxMeshResources,
+      maxOutputResources: SELECTED_MESH_LIMITS.maxMeshResources
+    };
+    const codecOptions = {
+      spatialContext,
+      autoOrigin: i3s,
+      integratedMeshPolicy: options.integratedMeshPolicy,
+      dracoLibraryOptions,
+      maxPositionError: SELECTED_MESH_LIMITS.maxPositionError
+    };
+    if (options.outputFormat === "slpk") {
+      const sink = createI3SMeshSink({
+        maxTotalBytes: maxOutputBytes,
+        maxMeshes: SELECTED_MESH_LIMITS.maxMeshResources,
+        maxResourceBytes: maxOutputBytes
+      });
+      report = await convertTileset({
+        ...common,
+        sink,
+        codec: createI3SMeshConversionCodec({ ...codecOptions, maxResourceBytes: maxOutputBytes }),
+        measureOutputBytes: (resource) => Object.values(resource.files).reduce((total, bytes) => total + bytes.byteLength, 0)
+      });
+      files = sink.getFiles();
+    } else {
+      const sink = options.preserveHierarchy ? createMeshHierarchyTilesetSink({
+        inspection,
+        resourceIds: options.resourceIds,
+        maxTotalBytes: maxOutputBytes,
+        maxPositionError: SELECTED_MESH_LIMITS.maxPositionError
+      }) : createMeshTilesetSink({
+        maxTotalBytes: maxOutputBytes,
+        maxMeshes: SELECTED_MESH_LIMITS.maxMeshResources,
+        geometricError
+      });
+      report = await convertTileset({
+        ...common,
+        sink,
+        codec: createMeshConversionCodec(codecOptions),
+        measureOutputBytes: (resource) => resource.glb.byteLength
+      });
+      files = sink.getFiles();
+    }
+  } finally {
+    await rawSource.close();
+  }
+  signal.throwIfAborted();
+  if (options.outputFormat !== "3d-tiles" && !options.output) {
+    for await (const chunk of encodeTileConversionArchiveInBatches(files, {
+      format: options.outputFormat,
+      maxArchiveBytes: maxOutputBytes,
+      signal
+    }))
+      void chunk;
+  }
+  if (options.output)
+    await writeNodeTileConversionOutput(
+      files,
+      options.output,
+      options.outputFormat,
+      maxOutputBytes,
+      signal
+    );
+  return report;
+}
+async function writeNodeTileConversionOutput(files, output, format, maxOutputBytes, signal) {
+  signal.throwIfAborted();
+  if (!["3d-tiles", "3tz", "slpk"].includes(format) || !Number.isSafeInteger(maxOutputBytes) || maxOutputBytes < 1)
+    throw new TileConversionError6(
+      "INVALID_NODE_OUTPUT",
+      "Output requires a supported format and positive safe byte limit"
+    );
+  let bytes = 0;
+  const names = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const name = file.resourceId;
+    if (!name || name.includes("\\") || name.includes("\0") || name.includes(":") || name.split("/").some((segment) => !segment || segment === "." || segment === "..") || names.has(name))
+      throw new TileConversionError6(
+        "INVALID_NODE_OUTPUT",
+        "Output names must be unique confined relative resource paths"
+      );
+    names.add(name);
+    if (file.blob.size > maxOutputBytes - bytes)
+      throw new TileConversionError6(
+        "OUTPUT_BYTES_LIMIT_EXCEEDED",
+        "Output files exceed the byte budget"
+      );
+    bytes += file.blob.size;
+  }
+  const destination = resolve3(output);
+  if (format === "3d-tiles") {
+    await mkdir(destination);
+    try {
+      for (const file of files) {
+        signal.throwIfAborted();
+        const path = join(destination, file.resourceId);
+        await mkdir(dirname2(path), { recursive: true });
+        const handle = await open3(path, "wx");
+        try {
+          const reader = file.blob.stream().getReader();
+          try {
+            while (true) {
+              signal.throwIfAborted();
+              const { value, done } = await reader.read();
+              if (done) break;
+              await writeFileBytes(handle, value, signal);
+            }
+          } finally {
+            await reader.cancel();
+            reader.releaseLock();
+          }
+        } finally {
+          await handle.close();
+        }
+      }
+      signal.throwIfAborted();
+    } catch (error) {
+      await rm(destination, { recursive: true, force: true });
+      throw error;
+    }
+  } else {
+    const temporaryDirectory = await mkdtemp(join(dirname2(destination), ".tile-converter-"));
+    try {
+      const path = join(temporaryDirectory, "archive");
+      const handle = await open3(path, "wx");
+      try {
+        for await (const chunk of encodeTileConversionArchiveInBatches(files, {
+          format,
+          maxArchiveBytes: maxOutputBytes,
+          signal
+        }))
+          await writeFileBytes(handle, chunk, signal);
+      } finally {
+        await handle.close();
+      }
+      signal.throwIfAborted();
+      await link(path, destination);
+    } finally {
+      await rm(temporaryDirectory, { recursive: true, force: true });
+    }
+  }
+}
+async function writeFileBytes(handle, bytes, signal) {
+  let offset = 0;
+  while (offset < bytes.byteLength) {
+    signal.throwIfAborted();
+    const result = await handle.write(bytes, offset, bytes.byteLength - offset);
+    if (!result.bytesWritten)
+      throw new TileConversionError6("NODE_OUTPUT_WRITE_FAILED", "Output write made no progress");
+    offset += result.bytesWritten;
+  }
+}
+var init_node_conversion = __esm({
+  "src/v5/node-conversion.ts"() {
+    "use strict";
+    init_node_source();
+    init_node_i3s_source();
+  }
+});
+
+// src/v5/node-cli.ts
+import { parseArgs } from "node:util";
+
+// src/v5/node-feature-schema.ts
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { TileConversionError } from "@loaders.gl/tile-converter/v5/core";
+var MAXIMUM_SCHEMA_BYTES = 64 * 1024;
+var FIELD_TYPES = [
+  "int8",
+  "uint8",
+  "int16",
+  "uint16",
+  "int32",
+  "uint32",
+  "int64",
+  "uint64",
+  "float32",
+  "float64",
+  "utf8"
+];
+async function readFeatureSchema(path, i3s, signal) {
+  signal?.throwIfAborted();
+  const file = await open(path, constants.O_RDONLY | constants.O_NONBLOCK);
+  let mapping;
+  try {
+    if (!(await file.stat()).isFile()) rejectSchema("Feature schema must be a regular local file");
+    const bytes = new Uint8Array(MAXIMUM_SCHEMA_BYTES + 1);
+    let length = 0;
+    while (length < bytes.length) {
+      signal?.throwIfAborted();
+      const { bytesRead } = await file.read(bytes, length, bytes.length - length, null);
+      if (!bytesRead) break;
+      length += bytesRead;
+    }
+    signal?.throwIfAborted();
+    if (length > MAXIMUM_SCHEMA_BYTES) rejectSchema("Feature schema exceeds 64 KiB");
+    try {
+      mapping = JSON.parse(
+        new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, length))
+      );
+    } catch {
+      rejectSchema("Feature schema must contain valid UTF-8 JSON");
+    }
+  } finally {
+    await file.close();
+  }
+  const options = requireRecord(mapping);
+  rejectUnknownKeys(options, [
+    "schema",
+    "metadataClass",
+    "sourceFeatureIdProperty",
+    "featureIdField",
+    "batchSize",
+    "integer64Encoding",
+    ...i3s ? ["objectIdProperty", "maxAttributeBytes"] : []
+  ]);
+  requireName(options.metadataClass);
+  for (const key of ["sourceFeatureIdProperty", "featureIdField"]) {
+    if (options[key] !== void 0) requireName(options[key]);
+  }
+  if (options.batchSize !== void 0 && (!Number.isSafeInteger(options.batchSize) || Number(options.batchSize) < 1 || Number(options.batchSize) > 65536))
+    rejectSchema("batchSize must be an integer from 1 to 65536");
+  if (options.integer64Encoding !== void 0 && options.integer64Encoding !== "decimal-string")
+    rejectSchema("integer64Encoding must be decimal-string when supplied");
+  const schema = requireRecord(options.schema);
+  rejectUnknownKeys(schema, ["fields", "metadata"]);
+  validateMetadata(schema.metadata);
+  if (!Array.isArray(schema.fields) || !schema.fields.length || schema.fields.length > 256)
+    rejectSchema("schema.fields must declare between 1 and 256 fields");
+  const names = /* @__PURE__ */ new Set();
+  for (const value of schema.fields) {
+    const field = requireRecord(value);
+    rejectUnknownKeys(field, ["name", "type", "nullable", "metadata"]);
+    requireName(field.name);
+    if (names.has(field.name)) rejectSchema("Feature fields must have unique names");
+    names.add(field.name);
+    if (typeof field.type !== "string" || !FIELD_TYPES.includes(field.type) || field.nullable !== void 0 && typeof field.nullable !== "boolean")
+      rejectSchema("Fields require a scalar numeric/utf8 type and an optional boolean nullable");
+    validateMetadata(field.metadata);
+  }
+  const identifier = schema.fields.find(
+    (value) => value.name === (options.featureIdField ?? "feature_id")
+  );
+  if (!identifier || identifier.nullable === true || !["utf8", ...FIELD_TYPES.filter((type) => /^(u?int)/.test(type))].includes(identifier.type))
+    rejectSchema("Declare a nonnullable string or integer feature ID field");
+  if (i3s) {
+    requireName(options.objectIdProperty);
+    if (!Number.isSafeInteger(options.maxAttributeBytes) || Number(options.maxAttributeBytes) < 1 || Number(options.maxAttributeBytes) > 16 * 1024 * 1024)
+      rejectSchema("maxAttributeBytes must be a positive integer at most 16 MiB");
+    return {
+      i3sFeatures: options
+    };
+  }
+  return { features: options };
+}
+function rejectUnknownKeys(record, allowed) {
+  if (Object.keys(record).some((key) => !allowed.includes(key)))
+    rejectSchema("Unknown feature-schema option");
+}
+function requireRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    rejectSchema("Feature mappings require JSON objects");
+  return value;
+}
+function requireName(value) {
+  if (typeof value !== "string" || !value.trim())
+    rejectSchema("Feature names must be nonempty strings");
+}
+function validateMetadata(value) {
+  if (value === void 0) return;
+  if (Object.values(requireRecord(value)).some((entry) => typeof entry !== "string"))
+    rejectSchema("Schema metadata values must be strings");
+}
+function rejectSchema(message) {
+  throw new TileConversionError("CLI_FEATURE_SCHEMA_INVALID", message);
+}
+
+// src/v5/node-cli.ts
+init_node_source();
+import { TileConversionError as TileConversionError7 } from "@loaders.gl/tile-converter/v5/core";
+var HELP = `Usage: tile-converter-v5 inspect|convert|validate <input path or URL> [options]
+
+  --input-format 3d-tiles|3tz|i3s|slpk  Explicit input format (default: 3d-tiles)
+  --geometric-error N        Required source error in meters for I3S to 3D Tiles
+  --integrated-mesh-policy as-3d-object  Authorize I3S layer-type change
+  --preserve-hierarchy        Retain a complete explicit 3D Tiles tree (3D Tiles/3TZ only)
+  --feature-schema PATH       Local JSON feature class/schema mapping (at most 64 KiB)
+  --resource ID               Selected content placement; repeat for multiple selections
+  --output-format 3d-tiles|3tz|slpk  Target profile (default: 3tz)
+  --output PATH               New destination (required for convert, forbidden for validate)
+  --max-input-bytes N          Lower the 16 MiB input/read budget
+  --max-resources N            Lower the 1,000 content-declaration limit
+  --max-documents N            Lower the 32 metadata-document limit
+  --max-output-bytes N         Lower the 32 MiB output/archive budget
+  --help                      Show this help
+
+Inspect reads metadata only, following declared .json external tilesets.
+Convert/validate require explicit selections; I3S uses declared CRS and shared spatial preparation.
+Validate decodes, converts and packages the selected target profile without writing files.
+Output defaults to a partial flat mesh collection. --preserve-hierarchy requires every declared content.
+Remote archives require HTTP 206 ranges and a stable ETag or Last-Modified validator.
+I3S inspect lists leaf nodes; feature-bearing conversion requires --feature-schema.
+Hierarchy mode supports at most 32 document placements, 256 tiles and 64 total mesh primitive placements, including ordered 1.1 contents arrays.
+`;
+async function runTileConverterCLI(argumentsList, output, signal) {
+  try {
+    const { values, positionals } = parseArgs({
+      args: argumentsList,
+      allowPositionals: true,
+      options: {
+        help: { type: "boolean" },
+        "preserve-hierarchy": { type: "boolean" },
+        "input-format": { type: "string", default: "3d-tiles" },
+        "max-input-bytes": { type: "string", default: String(NODE_TILESET_LIMITS.maxInputBytes) },
+        "max-resources": { type: "string", default: String(NODE_TILESET_LIMITS.maxInputResources) },
+        "max-documents": { type: "string", default: String(NODE_TILESET_LIMITS.maxTilesetDocuments) },
+        "max-output-bytes": { type: "string", default: String(32 * 1024 * 1024) },
+        "output-format": { type: "string", default: "3tz" },
+        output: { type: "string" },
+        resource: { type: "string", multiple: true },
+        "feature-schema": { type: "string" },
+        "geometric-error": { type: "string" },
+        "integrated-mesh-policy": { type: "string" }
+      }
+    });
+    if (values.help || !argumentsList.length) {
+      output.stdout(HELP);
+      return 0;
+    }
+    if (positionals.length !== 2 || !["inspect", "convert", "validate"].includes(positionals[0]) || !["3d-tiles", "3tz", "i3s", "slpk"].includes(values["input-format"]))
+      throw new TileConversionError7(
+        "CLI_USAGE_ERROR",
+        "Use inspect, convert or validate with one input and --input-format 3d-tiles, 3tz, i3s or slpk"
+      );
+    const format = values["input-format"];
+    const operation = positionals[0];
+    const sourceOptions = {
+      input: positionals[1],
+      format,
+      signal,
+      maxInputBytes: parseLimit(values["max-input-bytes"]),
+      maxInputResources: parseLimit(values["max-resources"]),
+      maxTilesetDocuments: parseLimit(values["max-documents"]),
+      inspectNestedTilesets: true
+    };
+    if (operation !== "inspect") {
+      if (!values.resource?.length || !["3d-tiles", "3tz", "slpk"].includes(values["output-format"]) || (operation === "convert" ? !values.output : values.output !== void 0))
+        throw new TileConversionError7(
+          "CLI_USAGE_ERROR",
+          "Convert/validate require --resource selections and a supported --output-format; only convert requires --output"
+        );
+      if (values["integrated-mesh-policy"] !== void 0 && values["integrated-mesh-policy"] !== "as-3d-object")
+        throw new TileConversionError7(
+          "CLI_USAGE_ERROR",
+          "Use --integrated-mesh-policy as-3d-object"
+        );
+      const features = values["feature-schema"] === void 0 ? void 0 : await readFeatureSchema(
+        values["feature-schema"],
+        format === "i3s" || format === "slpk",
+        signal
+      );
+      const { convertNodeTileset: convertNodeTileset2 } = await Promise.resolve().then(() => (init_node_conversion(), node_conversion_exports));
+      const report = await convertNodeTileset2({
+        ...sourceOptions,
+        ...features,
+        resourceIds: values.resource,
+        preserveHierarchy: values["preserve-hierarchy"],
+        outputFormat: values["output-format"],
+        output: values.output,
+        maxOutputBytes: parseLimit(values["max-output-bytes"]),
+        geometricError: values["geometric-error"] === void 0 ? void 0 : parseGeometricError(values["geometric-error"]),
+        integratedMeshPolicy: values["integrated-mesh-policy"]
+      });
+      output.stdout(
+        `${JSON.stringify({ operation, input: positionals[1], inputFormat: format, outputFormat: values["output-format"], ...values.output ? { output: values.output } : {}, report }, null, 2)}
+`
+      );
+      return 0;
+    }
+    if (values["feature-schema"] !== void 0 || values["preserve-hierarchy"] !== void 0 || values["geometric-error"] !== void 0 || values["integrated-mesh-policy"] !== void 0 || values.resource || values.output || values["output-format"] !== "3tz" || values["max-output-bytes"] !== String(32 * 1024 * 1024))
+      throw new TileConversionError7(
+        "CLI_USAGE_ERROR",
+        "Inspect does not accept conversion/output options"
+      );
+    const source = format === "i3s" || format === "slpk" ? await (await Promise.resolve().then(() => (init_node_i3s_source(), node_i3s_source_exports))).createNodeI3SConversionSource({
+      ...sourceOptions,
+      format
+    }) : await createNodeTilesetConversionSource({ ...sourceOptions, format });
+    const inspection = await source.inspect(signal).finally(() => source.close());
+    output.stdout(
+      `${JSON.stringify({ operation: "inspect", input: positionals[1], inputFormat: format, ...inspection }, null, 2)}
+`
+    );
+    return 0;
+  } catch (error) {
+    output.stderr(
+      `${JSON.stringify({
+        code: error instanceof Error && "code" in error ? error.code : "CONVERSION_FAILED",
+        message: error instanceof Error ? error.message : String(error),
+        diagnostics: error instanceof TileConversionError7 ? error.diagnostics : []
+      })}
+`
+    );
+    return 1;
+  }
+}
+function parseLimit(value) {
+  if (!/^[1-9]\d*$/.test(value) || !Number.isSafeInteger(Number(value)))
+    throw new TileConversionError7(
+      "CLI_USAGE_ERROR",
+      "Limits must be positive safe decimal integers"
+    );
+  return Number(value);
+}
+function parseGeometricError(value) {
+  if (!/^(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(value) || !Number.isFinite(Number(value)))
+    throw new TileConversionError7(
+      "CLI_USAGE_ERROR",
+      "Geometric error must be a finite nonnegative number in meters"
+    );
+  return Number(value);
+}
+
+// src/v5/converter-cli.ts
+async function main() {
+  const controller = new AbortController();
+  const cancelOperation = () => controller.abort(new Error("Tile conversion operation interrupted"));
+  process.on("SIGINT", cancelOperation);
+  try {
+    process.exitCode = await runTileConverterCLI(
+      process.argv.slice(2),
+      {
+        stdout: (text) => process.stdout.write(text),
+        stderr: (text) => process.stderr.write(text)
+      },
+      controller.signal
+    );
+  } finally {
+    process.removeListener("SIGINT", cancelOperation);
+  }
+}
+void main();