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

package/dist/v5/node.js

@@ -0,0 +1,877 @@
+// src/v5/node-source.ts
+import { open, 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 TileConversionError3
+} from "@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
+import { BlobFile, HttpFile } from "@loaders.gl/loader-utils";
+import { parseSLPKArchive } from "@loaders.gl/i3s";
+import { parse3DTilesArchive } from "@loaders.gl/3d-tiles";
+import { TileConversionError as TileConversionError2 } 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 TileConversionError2("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 TileConversionError2("ARCHIVE_SOURCE_CLOSED", "Conversion archive is closed");
+  };
+  try {
+    checkOpen();
+    if (!["slpk", "3tz"].includes(format) || !Number.isSafeInteger(maxInputBytes) || maxInputBytes < 1)
+      throw new TileConversionError2(
+        "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 TileConversionError2(
+            "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 TileConversionError2(
+      "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 TileConversionError2(
+      "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 TileConversionError3(
+      "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 TileConversionError3(
+        "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 TileConversionError3(
+        "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 TileConversionError3(
+              "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 TileConversionError3("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 TileConversionError3(
+      "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 TileConversionError3(
+      "EXTERNAL_RESOURCE_UNSUPPORTED",
+      "Dependency paths cannot escape the selected input"
+    );
+  return path;
+}
+async function openLocalFile(path, maxInputBytes, signal, reserveRead) {
+  signal.throwIfAborted();
+  const handle = await open(path, "r");
+  try {
+    signal.throwIfAborted();
+    const information = await handle.stat();
+    if (!information.isFile() || !Number.isSafeInteger(information.size) || information.size > maxInputBytes)
+      throw new TileConversionError3(
+        "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 TileConversionError3(
+            "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 TileConversionError3(
+              "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
+import { mkdir, open as open2, rm, link, mkdtemp } from "node:fs/promises";
+import { dirname as dirname2, join, resolve as resolve3 } from "node:path";
+import { convertTileset, TileConversionError as TileConversionError5 } 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";
+
+// src/v5/node-i3s-source.ts
+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 TileConversionError4 } 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 TileConversionError4(
+      "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 TileConversionError4("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 TileConversionError4(
+        "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 TileConversionError4(
+          "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;
+  }
+}
+
+// src/v5/node-conversion.ts
+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 TileConversionError5(
+      "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 TileConversionError5(
+      "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 TileConversionError5(
+      "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 TileConversionError5(
+      "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 TileConversionError5(
+      "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 TileConversionError5(
+        "INVALID_NODE_OUTPUT",
+        "Output names must be unique confined relative resource paths"
+      );
+    names.add(name);
+    if (file.blob.size > maxOutputBytes - bytes)
+      throw new TileConversionError5(
+        "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 open2(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 open2(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 TileConversionError5("NODE_OUTPUT_WRITE_FAILED", "Output write made no progress");
+    offset += result.bytesWritten;
+  }
+}
+export {
+  NODE_TILESET_LIMITS,
+  convertNodeTileset,
+  createNodeI3SConversionSource,
+  createNodeTilesetConversionSource,
+  writeNodeTileConversionOutput
+};