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

package/dist/v5/node.cjs

@@ -0,0 +1,913 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/v5/node.ts
+var node_exports = {};
+__export(node_exports, {
+  NODE_TILESET_LIMITS: () => NODE_TILESET_LIMITS,
+  convertNodeTileset: () => convertNodeTileset,
+  createNodeI3SConversionSource: () => createNodeI3SConversionSource,
+  createNodeTilesetConversionSource: () => createNodeTilesetConversionSource,
+  writeNodeTileConversionOutput: () => writeNodeTileConversionOutput
+});
+module.exports = __toCommonJS(node_exports);
+
+// src/v5/node-source.ts
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_node_url = require("node:url");
+var import_d_tiles2 = require("@loaders.gl/tiles-3d/3d-tiles");
+var import_core2 = require("@loaders.gl/tile-converter/v5/core");
+
+// src/v5/conversion-api.ts
+var TileConversionError = 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 TileConversionError(
+      "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 TileConversionError(
+        "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 TileConversionError(
+        "BROWSER_SOURCE_FETCH_FAILED",
+        `Could not fetch conversion resource (${response.status})`
+      );
+    }
+    const reader = response.body?.getReader();
+    if (!reader)
+      throw new TileConversionError(
+        "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 TileConversionError(
+            "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;
+  };
+}
+
+// src/v5/archive-source.ts
+var import_loader_utils = require("@loaders.gl/core/loader-utils");
+var import_i3s = require("@loaders.gl/tiles-3d/i3s");
+var import_d_tiles = require("@loaders.gl/tiles-3d/3d-tiles");
+var import_core = require("@loaders.gl/tile-converter/v5/core");
+async function openTileConversionArchive(descriptor, maxInputBytes, signal, fetcher = fetch) {
+  signal.throwIfAborted();
+  if (!["slpk", "3tz"].includes(descriptor.format))
+    throw new import_core.TileConversionError("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 import_loader_utils.HttpFile(descriptor.input, {
+        fetch: (url, options) => transport(url, options),
+        consistency: "strict",
+        ...descriptor.identity
+      });
+      file = remote;
+      await remote.open(signal);
+    } else file = new import_loader_utils.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 import_core.TileConversionError("ARCHIVE_SOURCE_CLOSED", "Conversion archive is closed");
+  };
+  try {
+    checkOpen();
+    if (!["slpk", "3tz"].includes(format) || !Number.isSafeInteger(maxInputBytes) || maxInputBytes < 1)
+      throw new import_core.TileConversionError(
+        "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 import_core.TileConversionError(
+            "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 (0, import_i3s.parseSLPKArchive)(boundedFile) : await (0, import_d_tiles.parse3DTilesArchive)(boundedFile);
+    const root = new URL(rootUrl);
+    return {
+      rootUrl: format === "3tz" ? `${rootUrl}/tileset.json` : rootUrl,
+      descriptor: descriptor ? {
+        ...descriptor,
+        ...file instanceof import_loader_utils.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 import_core.TileConversionError(
+      "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 import_core.TileConversionError(
+      "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;
+}
+
+// src/v5/node-source.ts
+var 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
+};
+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 import_core2.TileConversionError(
+      "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 import_core2.TileConversionError(
+        "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 import_core2.TileConversionError(
+        "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 (0, import_promises.realpath)(inputUrl ? (0, import_node_url.fileURLToPath)(inputUrl) : (0, import_node_path.resolve)(options.input));
+      lifetimeSignal.throwIfAborted();
+      const directory = (0, import_node_path.dirname)(inputPath);
+      virtualRoot = new URL("https://conversion.invalid/input/");
+      rootUrl = new URL(
+        options.format === "3tz" ? "tileset.json" : encodeURIComponent((0, import_node_path.basename)(inputPath)),
+        virtualRoot
+      ).href;
+      if (options.format === "3tz") {
+        archiveFile = await openLocalFile(inputPath, maxInputBytes, lifetimeSignal, reserveRead);
+        const archive = await (0, import_d_tiles2.parse3DTilesArchive)(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 (0, import_promises.realpath)((0, import_node_path.resolve)(directory, path));
+          const relativePath = (0, import_node_path.relative)(directory, resolvedPath);
+          if (relativePath === ".." || relativePath.startsWith(`..${import_node_path.sep}`) || (0, import_node_path.isAbsolute)(relativePath))
+            throw new import_core2.TileConversionError(
+              "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 = (0, import_core2.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 import_core2.TileConversionError("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 import_core2.TileConversionError(
+      "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 import_core2.TileConversionError(
+      "EXTERNAL_RESOURCE_UNSUPPORTED",
+      "Dependency paths cannot escape the selected input"
+    );
+  return path;
+}
+async function openLocalFile(path, maxInputBytes, signal, reserveRead) {
+  signal.throwIfAborted();
+  const handle = await (0, import_promises.open)(path, "r");
+  try {
+    signal.throwIfAborted();
+    const information = await handle.stat();
+    if (!information.isFile() || !Number.isSafeInteger(information.size) || information.size > maxInputBytes)
+      throw new import_core2.TileConversionError(
+        "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 import_core2.TileConversionError(
+            "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 import_core2.TileConversionError(
+              "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;
+  }
+}
+
+// src/v5/node-conversion.ts
+var import_promises3 = require("node:fs/promises");
+var import_node_path3 = require("node:path");
+var import_core4 = require("@loaders.gl/tile-converter/v5/core");
+var import_adapters2 = require("@loaders.gl/tile-converter/v5/adapters");
+
+// src/v5/node-i3s-source.ts
+var import_promises2 = require("node:fs/promises");
+var import_node_url2 = require("node:url");
+var import_node_path2 = require("node:path");
+var import_core3 = require("@loaders.gl/tile-converter/v5/core");
+var import_adapters = require("@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 import_core3.TileConversionError(
+      "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 import_core3.TileConversionError("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 import_core3.TileConversionError(
+        "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 (0, import_adapters.openTileConversionArchive)(
+        { input: options.input, format: "slpk" },
+        maxInputBytes,
+        signal,
+        options.fetcher
+      ) : await (0, import_adapters.createTileConversionArchiveTransport)(
+        await openLocalFile(
+          await (0, import_promises2.realpath)(
+            /^file:/i.test(options.input) ? (0, import_node_url2.fileURLToPath)(options.input) : (0, import_node_path2.resolve)(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 import_core3.TileConversionError(
+          "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 (0, import_adapters.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 (0, import_adapters.createSelectedI3SMeshConversionSource)(inspection, {
+          ...selectionOptions,
+          resourceIds,
+          dracoLibraryOptions,
+          features
+        });
+      }
+    };
+  } catch (error) {
+    await close();
+    throw error;
+  }
+}
+
+// src/v5/node-conversion.ts
+async function convertNodeTileset(options) {
+  const started = options.profile ? performance.now() : 0;
+  let setupMilliseconds = 0;
+  const signal = options.signal ?? new AbortController().signal;
+  const maxOutputBytes = options.maxOutputBytes ?? import_adapters2.SELECTED_MESH_LIMITS.maxOutputBytes;
+  if (!["3d-tiles", "3tz", "slpk"].includes(options.outputFormat) || !Number.isSafeInteger(maxOutputBytes) || maxOutputBytes < 1 || maxOutputBytes > import_adapters2.SELECTED_MESH_LIMITS.maxOutputBytes)
+    throw new import_core4.TileConversionError(
+      "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 import_core4.TileConversionError(
+      "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 import_core4.TileConversionError(
+      "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 import_core4.TileConversionError(
+      "INVALID_NODE_CONVERSION_OPTIONS",
+      "Feature and layer policies must match the selected input format"
+    );
+  const sourceOptions = {
+    ...options,
+    signal,
+    inspectNestedTilesets: true,
+    maxTilesetDocuments: options.maxTilesetDocuments ?? import_adapters2.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/core/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) + import_adapters2.SELECTED_MESH_LIMITS.maxPositionError
+    } : await (0, import_adapters2.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;
+    setupMilliseconds = options.profile ? performance.now() - started : 0;
+    const common = {
+      profile: options.profile,
+      source,
+      signal,
+      measureInputBytes: import_adapters2.measureMeshBytes,
+      maxInputBytes: options.maxInputBytes ?? import_adapters2.SELECTED_MESH_LIMITS.maxInputBytes,
+      maxOutputBytes,
+      maxInputResources: import_adapters2.SELECTED_MESH_LIMITS.maxMeshResources,
+      maxOutputResources: import_adapters2.SELECTED_MESH_LIMITS.maxMeshResources
+    };
+    const codecOptions = {
+      spatialContext,
+      autoOrigin: i3s,
+      integratedMeshPolicy: options.integratedMeshPolicy,
+      dracoLibraryOptions,
+      maxPositionError: import_adapters2.SELECTED_MESH_LIMITS.maxPositionError
+    };
+    if (options.outputFormat === "slpk") {
+      const sink = (0, import_adapters2.createI3SMeshSink)({
+        maxTotalBytes: maxOutputBytes,
+        maxMeshes: import_adapters2.SELECTED_MESH_LIMITS.maxMeshResources,
+        maxResourceBytes: maxOutputBytes
+      });
+      report = await (0, import_core4.convertTileset)({
+        ...common,
+        sink,
+        codec: (0, import_adapters2.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 ? (0, import_adapters2.createMeshHierarchyTilesetSink)({
+        inspection,
+        resourceIds: options.resourceIds,
+        maxTotalBytes: maxOutputBytes,
+        maxPositionError: import_adapters2.SELECTED_MESH_LIMITS.maxPositionError
+      }) : (0, import_adapters2.createMeshTilesetSink)({
+        maxTotalBytes: maxOutputBytes,
+        maxMeshes: import_adapters2.SELECTED_MESH_LIMITS.maxMeshResources,
+        geometricError
+      });
+      report = await (0, import_core4.convertTileset)({
+        ...common,
+        sink,
+        codec: (0, import_adapters2.createMeshConversionCodec)(codecOptions),
+        measureOutputBytes: (resource) => resource.glb.byteLength
+      });
+      files = sink.getFiles();
+    }
+  } finally {
+    await rawSource.close();
+  }
+  const outputStarted = options.profile ? performance.now() : 0;
+  signal.throwIfAborted();
+  if (options.outputFormat !== "3d-tiles" && !options.output) {
+    for await (const chunk of (0, import_adapters2.encodeTileConversionArchiveInBatches)(files, {
+      format: options.outputFormat,
+      maxArchiveBytes: maxOutputBytes,
+      signal
+    }))
+      void chunk;
+  }
+  if (options.output)
+    await writeNodeTileConversionOutput(
+      files,
+      options.output,
+      options.outputFormat,
+      maxOutputBytes,
+      signal
+    );
+  return report.timings ? {
+    ...report,
+    timings: {
+      ...report.timings,
+      setupMilliseconds,
+      outputMilliseconds: performance.now() - outputStarted,
+      totalMilliseconds: performance.now() - started
+    }
+  } : 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 import_core4.TileConversionError(
+      "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 import_core4.TileConversionError(
+        "INVALID_NODE_OUTPUT",
+        "Output names must be unique confined relative resource paths"
+      );
+    names.add(name);
+    if (file.blob.size > maxOutputBytes - bytes)
+      throw new import_core4.TileConversionError(
+        "OUTPUT_BYTES_LIMIT_EXCEEDED",
+        "Output files exceed the byte budget"
+      );
+    bytes += file.blob.size;
+  }
+  const destination = (0, import_node_path3.resolve)(output);
+  if (format === "3d-tiles") {
+    await (0, import_promises3.mkdir)(destination);
+    try {
+      for (const file of files) {
+        signal.throwIfAborted();
+        const path = (0, import_node_path3.join)(destination, file.resourceId);
+        await (0, import_promises3.mkdir)((0, import_node_path3.dirname)(path), { recursive: true });
+        const handle = await (0, import_promises3.open)(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 (0, import_promises3.rm)(destination, { recursive: true, force: true });
+      throw error;
+    }
+  } else {
+    const temporaryDirectory = await (0, import_promises3.mkdtemp)((0, import_node_path3.join)((0, import_node_path3.dirname)(destination), ".tile-converter-"));
+    try {
+      const path = (0, import_node_path3.join)(temporaryDirectory, "archive");
+      const handle = await (0, import_promises3.open)(path, "wx");
+      try {
+        for await (const chunk of (0, import_adapters2.encodeTileConversionArchiveInBatches)(files, {
+          format,
+          maxArchiveBytes: maxOutputBytes,
+          signal
+        }))
+          await writeFileBytes(handle, chunk, signal);
+      } finally {
+        await handle.close();
+      }
+      signal.throwIfAborted();
+      await (0, import_promises3.link)(path, destination);
+    } finally {
+      await (0, import_promises3.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 import_core4.TileConversionError("NODE_OUTPUT_WRITE_FAILED", "Output write made no progress");
+    offset += result.bytesWritten;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NODE_TILESET_LIMITS,
+  convertNodeTileset,
+  createNodeI3SConversionSource,
+  createNodeTilesetConversionSource,
+  writeNodeTileConversionOutput
+});