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

package/dist/v5/core.cjs

@@ -0,0 +1,863 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/v5/core.ts
+var core_exports = {};
+__export(core_exports, {
+  TileConversionError: () => TileConversionError,
+  convertTileset: () => convertTileset,
+  createBoundedMemoryTileConversionSink: () => createBoundedMemoryTileConversionSink,
+  createBrowserTileConversionSource: () => createBrowserTileConversionSource,
+  createBrowserTilesetConversionSource: () => createBrowserTilesetConversionSource,
+  createI3SConversionSpatialContext: () => createI3SConversionSpatialContext,
+  createManifestBackedTileConversionSink: () => createManifestBackedTileConversionSink,
+  createTiles3DConversionSpatialContext: () => createTiles3DConversionSpatialContext,
+  createTilesetConversionSource: () => createTilesetConversionSource,
+  inspectTileset: () => inspectTileset,
+  traversePointCloudSource: () => traversePointCloudSource,
+  validateTileset: () => validateTileset
+});
+module.exports = __toCommonJS(core_exports);
+
+// 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;
+  }
+};
+async function inspectTileset(source, signal) {
+  throwIfAborted(signal);
+  const inspection = await source.inspect(signal);
+  throwIfAborted(signal);
+  return inspection;
+}
+async function convertTileset(options) {
+  const {
+    source,
+    codec,
+    sink,
+    measureInputBytes,
+    measureOutputBytes,
+    maxInputResourceBytes = Number.POSITIVE_INFINITY,
+    maxOutputResourceBytes = Number.POSITIVE_INFINITY,
+    signal,
+    onProgress
+  } = options;
+  let inputResources = 0;
+  let outputResources = 0;
+  let inputBytes = 0;
+  let outputBytes = 0;
+  let largestOutputResourceBytes = 0;
+  const diagnostics = [];
+  const reportProgress = (phase) => {
+    onProgress?.({ phase, inputResources, outputResources, inputBytes, outputBytes });
+  };
+  try {
+    if (maxInputResourceBytes !== Number.POSITIVE_INFINITY && (!Number.isSafeInteger(maxInputResourceBytes) || maxInputResourceBytes < 0)) {
+      throw new TileConversionError(
+        "INVALID_INPUT_RESOURCE_LIMIT",
+        "maxInputResourceBytes must be a nonnegative safe integer or Infinity"
+      );
+    }
+    reportProgress("inspect");
+    const inspection = await inspectTileset(source, signal);
+    for await (const inputResource of source.read(inspection, signal)) {
+      throwIfAborted(signal);
+      const inputResourceBytes = measureInputBytes(inputResource);
+      if (!Number.isSafeInteger(inputResourceBytes) || inputResourceBytes < 0) {
+        throw new TileConversionError(
+          "INVALID_INPUT_RESOURCE_SIZE",
+          "measureInputBytes must return a nonnegative safe integer"
+        );
+      }
+      if (inputResourceBytes > maxInputResourceBytes) {
+        throw new TileConversionError(
+          "INPUT_RESOURCE_TOO_LARGE",
+          `Input resource is ${inputResourceBytes} bytes, exceeding the configured limit of ${maxInputResourceBytes} bytes`
+        );
+      }
+      inputResources++;
+      inputBytes += inputResourceBytes;
+      reportProgress("convert");
+      const convertedResources = await codec.convert(inputResource, inspection, signal);
+      for await (const outputResource of convertedResources) {
+        throwIfAborted(signal);
+        reportProgress("validate");
+        const resourceDiagnostics = await codec.validateOutput?.(outputResource, signal) || [];
+        diagnostics.push(...resourceDiagnostics);
+        const outputResourceBytes = measureOutputBytes(outputResource);
+        largestOutputResourceBytes = Math.max(largestOutputResourceBytes, outputResourceBytes);
+        if (outputResourceBytes > maxOutputResourceBytes) {
+          throw new TileConversionError(
+            "OUTPUT_RESOURCE_TOO_LARGE",
+            `Output resource is ${outputResourceBytes} bytes, exceeding the configured limit of ${maxOutputResourceBytes} bytes`
+          );
+        }
+        if (resourceDiagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+          throw new TileConversionError(
+            "OUTPUT_VALIDATION_FAILED",
+            "Output resource validation failed",
+            resourceDiagnostics
+          );
+        }
+        throwIfAborted(signal);
+        await sink.write(outputResource, signal);
+        throwIfAborted(signal);
+        outputResources++;
+        outputBytes += outputResourceBytes;
+        reportProgress("convert");
+      }
+    }
+    const report = {
+      state: "completed",
+      inputResources,
+      outputResources,
+      inputBytes,
+      outputBytes,
+      largestOutputResourceBytes,
+      diagnostics
+    };
+    throwIfAborted(signal);
+    reportProgress("finalize");
+    await sink.finalize(report);
+    return report;
+  } catch (error) {
+    try {
+      await sink.abort(error);
+    } catch (abortError) {
+      throw new AggregateError(
+        [error, abortError],
+        "Conversion failed and the destination could not abort"
+      );
+    }
+    throw error;
+  }
+}
+async function validateTileset(options) {
+  throwIfAborted(options.signal);
+  const diagnostics = await options.validate(options.tileset, options.signal);
+  throwIfAborted(options.signal);
+  return {
+    valid: !diagnostics.some((diagnostic) => diagnostic.severity === "error"),
+    diagnostics
+  };
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+  }
+}
+
+// src/v5/browser-source.ts
+function createBrowserTileConversionSource(options) {
+  if (!options.resourceId || !Number.isSafeInteger(options.maxInputBytes) || options.maxInputBytes < 0) {
+    throw new TileConversionError(
+      "INVALID_BROWSER_SOURCE_OPTIONS",
+      "Browser sources require a resource ID and a non-negative safe input byte limit"
+    );
+  }
+  return {
+    async inspect(signal) {
+      throwIfAborted2(signal);
+      const contentType = options.contentType ?? getBlobContentType(options.input);
+      return {
+        resourceId: options.resourceId,
+        ...contentType ? { contentType } : {}
+      };
+    },
+    async *read(inspection, signal) {
+      throwIfAborted2(signal);
+      const input = options.input;
+      let data;
+      let contentType = inspection.contentType;
+      if (typeof input === "string") {
+        const response = await fetch(input, { signal });
+        if (!response.ok) {
+          throw new TileConversionError(
+            "BROWSER_SOURCE_FETCH_FAILED",
+            `Could not fetch browser input (${response.status} ${response.statusText})`
+          );
+        }
+        contentType = contentType ?? response.headers.get("content-type") ?? void 0;
+        data = await readResponseBytes(response, options.maxInputBytes, signal);
+      } else {
+        if (input.size > options.maxInputBytes) {
+          throw createInputLimitError(options.maxInputBytes);
+        }
+        data = new Uint8Array(await input.arrayBuffer());
+      }
+      throwIfAborted2(signal);
+      yield {
+        resourceId: inspection.resourceId,
+        data,
+        ...contentType ? { contentType } : {}
+      };
+    }
+  };
+}
+async function readResponseBytes(response, maxInputBytes, signal) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new TileConversionError(
+      "BROWSER_SOURCE_STREAM_UNAVAILABLE",
+      "Browser URL inputs must provide a readable response stream"
+    );
+  }
+  const data = new Uint8Array(maxInputBytes);
+  let totalBytes = 0;
+  try {
+    while (true) {
+      throwIfAborted2(signal);
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value.byteLength > maxInputBytes - totalBytes) {
+        await reader.cancel();
+        throw createInputLimitError(maxInputBytes);
+      }
+      data.set(value, totalBytes);
+      totalBytes += value.byteLength;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return data.subarray(0, totalBytes);
+}
+function getBlobContentType(input) {
+  return typeof input === "string" ? void 0 : input.type || void 0;
+}
+function createInputLimitError(maxInputBytes) {
+  return new TileConversionError(
+    "INPUT_RESOURCE_TOO_LARGE",
+    `Browser input exceeds the configured ${maxInputBytes} byte memory limit`
+  );
+}
+function throwIfAborted2(signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+  }
+}
+
+// src/v5/point-cloud-source.ts
+async function* traversePointCloudSource(source, options = {}) {
+  const { maxDepth = Number.POSITIVE_INFINITY, signal } = options;
+  if (maxDepth !== Number.POSITIVE_INFINITY && (!Number.isSafeInteger(maxDepth) || maxDepth < 0)) {
+    throw new RangeError("Point-cloud source maxDepth must be a non-negative integer");
+  }
+  throwIfAborted3(signal);
+  if (!source.isReady) {
+    await source.initialize();
+  }
+  throwIfAborted3(signal);
+  const root = await source.getRootTile();
+  const pendingTiles = [root];
+  const visitedTileIds = /* @__PURE__ */ new Set();
+  while (pendingTiles.length > 0) {
+    throwIfAborted3(signal);
+    const header = pendingTiles.pop();
+    if (visitedTileIds.has(header.id)) {
+      continue;
+    }
+    visitedTileIds.add(header.id);
+    const content = await source.loadTileContent(header);
+    throwIfAborted3(signal);
+    yield { header, content };
+    throwIfAborted3(signal);
+    if (header.level >= maxDepth) {
+      continue;
+    }
+    const children = await source.getChildren(header);
+    throwIfAborted3(signal);
+    for (let index = children.length - 1; index >= 0; index--) {
+      pendingTiles.push(children[index]);
+    }
+  }
+}
+function throwIfAborted3(signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+  }
+}
+
+// src/v5/spatial-conversion.ts
+var import_tiles = require("@loaders.gl/tiles");
+var import_core = require("@math.gl/core");
+function createTiles3DConversionSpatialContext(discovered, options = {}) {
+  const spatialReference = createConversionSpatialReference(discovered, options);
+  if (spatialReference.status === "unresolved") {
+    throw createSpatialConversionError(spatialReference);
+  }
+  const transformer = spatialReference.status === "native" ? void 0 : createSpatialTransformer(
+    spatialReference,
+    () => new import_tiles.Tiles3DSpatialTransformer(spatialReference, options)
+  );
+  const outputSpatialReference = transformer ? (0, import_tiles.markTilesetSpatialReferenceTransformed)(spatialReference) : spatialReference;
+  return {
+    spatialReference: outputSpatialReference,
+    transformPositions: (positions) => transformer ? transformer.transformPositions(positions) : Float64Array.from(positions),
+    transformNormals: (normals, positions) => transformer ? transformer.transformNormals(normals, positions) : Float32Array.from(normals),
+    transformBoundingVolume: (volume, sourceTransform) => transformer ? transformer.transformBoundingVolume(volume, sourceTransform) : cloneBoundingVolume(volume)
+  };
+}
+function createI3SConversionSpatialContext(discovered, options = {}) {
+  const spatialReference = createConversionSpatialReference(discovered, options);
+  if (spatialReference.status === "unresolved") {
+    throw createSpatialConversionError(spatialReference);
+  }
+  const transformer = spatialReference.status === "native" ? void 0 : createSpatialTransformer(
+    spatialReference,
+    () => new import_tiles.I3SSpatialTransformer(spatialReference, options)
+  );
+  const outputSpatialReference = transformer ? transformer.spatialReference : spatialReference;
+  return {
+    spatialReference: outputSpatialReference,
+    transformPositions: (positions, sourceOrigin) => transformer ? transformer.transformPositions(positions, sourceOrigin) : createNativeI3SPositions(positions, sourceOrigin, spatialReference),
+    transformPositionsAsync: (positions, sourceOrigin) => transformer ? transformer.transformPositionsAsync(positions, sourceOrigin) : Promise.resolve(createNativeI3SPositions(positions, sourceOrigin, spatialReference)),
+    transformNormals: (normals, positions, normalReferenceFrame) => transformer ? transformer.transformNormals(normals, positions, normalReferenceFrame) : Float32Array.from(normals),
+    transformBoundingVolume: (bounds) => transformer ? transformer.transformBoundingVolume(bounds) : cloneI3SBounds(bounds),
+    transformBoundingVolumeAsync: (bounds) => transformer ? transformer.transformBoundingVolumeAsync(bounds) : Promise.resolve(cloneI3SBounds(bounds))
+  };
+}
+function createSpatialConversionError(spatialReference, cause) {
+  const diagnostics = spatialReference.warnings.map((message2) => ({
+    code: "SPATIAL_REFERENCE_WARNING",
+    message: message2,
+    severity: "warning"
+  }));
+  const causeMessage = cause instanceof Error ? `: ${cause.message}` : "";
+  const message = causeMessage ? `Spatial conversion could not be initialized${causeMessage}` : "The requested spatial conversion cannot be resolved from the available metadata";
+  diagnostics.push({
+    code: "SPATIAL_REFERENCE_UNRESOLVED",
+    message,
+    severity: "error"
+  });
+  return new TileConversionError("SPATIAL_REFERENCE_UNRESOLVED", message, diagnostics);
+}
+function createConversionSpatialReference(discovered, options) {
+  if (!("status" in discovered)) {
+    return (0, import_tiles.createTilesetSpatialReference)(discovered, options);
+  }
+  if (discovered.status === "transformed") {
+    throw createSpatialConversionError(
+      discovered,
+      new Error("coordinates are already transformed")
+    );
+  }
+  const sourceMetadata = {
+    sourceCrs: discovered.sourceCrs,
+    sourceCrsState: discovered.crs.state,
+    sourceCrsRepresentation: discovered.crs.state === "explicit" || discovered.crs.state === "default" ? discovered.crs.representation : void 0,
+    sourceCrsAlternatives: discovered.crs.state === "explicit" || discovered.crs.state === "default" ? discovered.crs.alternatives : void 0,
+    verticalCrs: discovered.verticalCrs,
+    units: discovered.units,
+    verticalUnitScale: discovered.verticalUnitScale,
+    coordinateEpoch: discovered.coordinateEpoch,
+    heightReference: discovered.heightReference,
+    elevationMode: discovered.elevationMode,
+    elevationOffset: discovered.elevationOffset,
+    elevationUnit: discovered.elevationUnit,
+    elevationUnitScale: discovered.elevationUnitScale,
+    coordinateFrame: discovered.coordinateFrame,
+    axisOrder: discovered.axisOrder,
+    provenance: discovered.provenance,
+    warnings: discovered.warnings
+  };
+  const retainedOptions = {
+    ...options,
+    targetCrs: options.targetCrs ?? discovered.targetCrs,
+    targetHeightReference: options.targetHeightReference ?? discovered.targetHeightReference,
+    outputCoordinates: options.outputCoordinates ?? discovered.outputCoordinates
+  };
+  return (0, import_tiles.createTilesetSpatialReference)(sourceMetadata, retainedOptions);
+}
+function createSpatialTransformer(spatialReference, createTransformer) {
+  try {
+    return createTransformer();
+  } catch (error) {
+    throw createSpatialConversionError(spatialReference, error);
+  }
+}
+function cloneBoundingVolume(volume) {
+  return {
+    ...volume,
+    box: volume.box ? [...volume.box] : void 0,
+    sphere: volume.sphere ? [...volume.sphere] : void 0,
+    region: volume.region ? [...volume.region] : void 0
+  };
+}
+function cloneI3SBounds(bounds) {
+  return {
+    ...bounds,
+    mbs: bounds.mbs ? Array.from(bounds.mbs) : void 0,
+    obb: bounds.obb ? {
+      center: Array.from(bounds.obb.center),
+      halfSize: Array.from(bounds.obb.halfSize),
+      quaternion: Array.from(bounds.obb.quaternion)
+    } : void 0
+  };
+}
+function createNativeI3SPositions(sourcePositions, sourceOrigin, spatialReference) {
+  if (sourcePositions.length % 3 !== 0 || sourceOrigin.length < 3) {
+    throw new Error("I3S positions and origin must contain complete xyz coordinates");
+  }
+  const origin = [
+    Number(sourceOrigin[0]),
+    Number(sourceOrigin[1]),
+    Number(sourceOrigin[2])
+  ];
+  const sourcePositions64 = Float64Array.from(sourcePositions);
+  const positions = new Float32Array(sourcePositions.length);
+  for (let index = 0; index < sourcePositions.length; index += 3) {
+    positions[index] = Number(sourcePositions[index]) - origin[0];
+    positions[index + 1] = Number(sourcePositions[index + 1]) - origin[1];
+    positions[index + 2] = Number(sourcePositions[index + 2]) - origin[2];
+  }
+  const isGeographic = spatialReference.coordinateFrame === "geographic";
+  const modelMatrix = isGeographic ? new import_core.Matrix4() : new import_core.Matrix4().translate(origin);
+  return {
+    positions,
+    sourcePositions: sourcePositions64,
+    origin,
+    cartographicOrigin: isGeographic ? origin : [0, 0, 0],
+    coordinateSystem: isGeographic ? "lnglat-offsets" : "cartesian",
+    modelMatrix
+  };
+}
+
+// src/v5/tileset-source.ts
+var import_tiles2 = require("@loaders.gl/tiles");
+function createTilesetConversionSource(tileset, options = {}) {
+  return {
+    async inspect(signal) {
+      signal?.throwIfAborted();
+      await tileset.tilesetInitializationPromise;
+      signal?.throwIfAborted();
+      if (!tileset.root) {
+        throw new TileConversionError(
+          "TILESET_ROOT_REQUIRED",
+          "Tileset initialization completed without a root tile"
+        );
+      }
+      return tileset.source.getMetadata();
+    },
+    read: (_inspection, signal) => (0, import_tiles2.traverseTilesetContents)(tileset, { unloadContent: options.unloadContent, signal })
+  };
+}
+
+// src/v5/resource-manifest.ts
+var TILE_RESOURCE_MANIFEST_VERSION = 1;
+async function createManifestBackedTileConversionSink(options) {
+  const priorManifest = await options.manifestStore.load();
+  const resources = /* @__PURE__ */ new Map();
+  if (priorManifest) {
+    validateManifest(priorManifest);
+    for (const entry of priorManifest.resources) {
+      resources.set(entry.resourceId, entry);
+    }
+  }
+  let writeChain = Promise.resolve();
+  let writeFailed = false;
+  let writeFailure;
+  let closed = false;
+  const persistManifest = async (complete, report) => {
+    await options.manifestStore.save({
+      version: TILE_RESOURCE_MANIFEST_VERSION,
+      complete,
+      resources: [...resources.values()].sort(
+        (left, right) => left.resourceId < right.resourceId ? -1 : left.resourceId > right.resourceId ? 1 : 0
+      ),
+      ...report ? { report } : {}
+    });
+  };
+  const writeResource = async (resource, signal) => {
+    if (closed) {
+      throw new TileConversionError("RESOURCE_SINK_CLOSED", "Cannot write after sink finalization");
+    }
+    if (writeFailed) {
+      throw writeFailure;
+    }
+    const entry = createManifestEntry(options, resource);
+    const priorEntry = resources.get(entry.resourceId);
+    if (priorEntry) {
+      if (priorEntry.byteLength !== entry.byteLength || priorEntry.fingerprint !== entry.fingerprint) {
+        throw new TileConversionError(
+          "RESOURCE_RESUME_MISMATCH",
+          `Resource "${entry.resourceId}" changed since the saved manifest`
+        );
+      }
+      return;
+    }
+    await options.sink.write(resource, signal);
+    resources.set(entry.resourceId, entry);
+    await persistManifest(false);
+  };
+  return {
+    write(resource, signal) {
+      const operation = writeChain.then(() => writeResource(resource, signal));
+      writeChain = operation.catch((error) => {
+        writeFailed = true;
+        writeFailure = error;
+      });
+      return operation;
+    },
+    async finalize(report) {
+      await writeChain;
+      if (writeFailed) {
+        throw writeFailure;
+      }
+      if (closed) {
+        throw new TileConversionError("RESOURCE_SINK_CLOSED", "Sink has already been finalized");
+      }
+      await options.sink.finalize(report);
+      await persistManifest(true, report);
+      closed = true;
+    },
+    async abort(reason) {
+      await writeChain;
+      if (closed) return;
+      closed = true;
+      resources.clear();
+      await persistManifest(false);
+      await options.sink.abort(reason);
+    }
+  };
+}
+function createManifestEntry(options, resource) {
+  const resourceId = options.getResourceId(resource);
+  const byteLength = options.measureResourceBytes(resource);
+  const fingerprint = options.fingerprintResource(resource);
+  if (typeof resourceId !== "string" || resourceId.length === 0 || typeof fingerprint !== "string" || fingerprint.length === 0 || !Number.isSafeInteger(byteLength) || byteLength < 0) {
+    throw new TileConversionError(
+      "INVALID_RESOURCE_MANIFEST_ENTRY",
+      "Resource manifest entries require an ID, a fingerprint, and a non-negative safe byte length"
+    );
+  }
+  return { resourceId, byteLength, fingerprint };
+}
+function validateManifest(manifest) {
+  if (typeof manifest !== "object" || manifest === null || manifest.version !== TILE_RESOURCE_MANIFEST_VERSION || typeof manifest.complete !== "boolean" || !Array.isArray(manifest.resources)) {
+    throw new TileConversionError(
+      "UNSUPPORTED_RESOURCE_MANIFEST",
+      `Unsupported or malformed resource manifest version: ${String(manifest.version)}`
+    );
+  }
+  const resourceIds = /* @__PURE__ */ new Set();
+  for (const entry of manifest.resources) {
+    if (typeof entry?.resourceId !== "string" || entry.resourceId.length === 0 || typeof entry?.fingerprint !== "string" || entry.fingerprint.length === 0 || !Number.isSafeInteger(entry.byteLength) || entry.byteLength < 0 || resourceIds.has(entry.resourceId)) {
+      throw new TileConversionError(
+        "INVALID_RESOURCE_MANIFEST",
+        "Resource manifest contains an invalid or duplicate entry"
+      );
+    }
+    resourceIds.add(entry.resourceId);
+  }
+}
+
+// src/v5/browser-sink.ts
+var BLOB_SIZE_GETTER = Object.getOwnPropertyDescriptor(Blob.prototype, "size")?.get;
+function createBoundedMemoryTileConversionSink(options) {
+  const { maxTotalBytes } = options;
+  if (!Number.isSafeInteger(maxTotalBytes) || maxTotalBytes < 0) {
+    throw new TileConversionError(
+      "INVALID_OUTPUT_MEMORY_LIMIT",
+      "The browser output memory limit must be a non-negative safe integer"
+    );
+  }
+  const files = /* @__PURE__ */ new Map();
+  let totalBytes = 0;
+  let closed = false;
+  return {
+    getFiles() {
+      return [...files.values()].sort(
+        (left, right) => left.resourceId < right.resourceId ? -1 : left.resourceId > right.resourceId ? 1 : 0
+      );
+    },
+    async write(resource, signal) {
+      if (signal?.aborted) {
+        throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+      }
+      if (closed) {
+        throw new TileConversionError(
+          "RESOURCE_SINK_CLOSED",
+          "Cannot write after sink finalization"
+        );
+      }
+      if (!resource.resourceId || files.has(resource.resourceId)) {
+        throw new TileConversionError(
+          "INVALID_BROWSER_RESOURCE_ID",
+          "Browser output resource IDs must be non-empty and unique"
+        );
+      }
+      const byteLength = resource.parts.reduce((total, part) => total + measureBlobPart(part), 0);
+      if (!Number.isSafeInteger(byteLength) || totalBytes + byteLength > maxTotalBytes) {
+        throw new TileConversionError(
+          "OUTPUT_MEMORY_LIMIT_EXCEEDED",
+          `Browser output exceeds the configured ${maxTotalBytes} byte memory limit`
+        );
+      }
+      const blob = new Blob([...resource.parts], { type: resource.contentType });
+      files.set(resource.resourceId, { resourceId: resource.resourceId, blob });
+      totalBytes += blob.size;
+    },
+    async finalize(_report) {
+      if (closed) {
+        throw new TileConversionError("RESOURCE_SINK_CLOSED", "Sink has already been finalized");
+      }
+      closed = true;
+    },
+    async abort() {
+      files.clear();
+      totalBytes = 0;
+      closed = true;
+    }
+  };
+}
+function measureBlobPart(part) {
+  if (typeof part === "string") {
+    return new TextEncoder().encode(part).byteLength;
+  }
+  if (BLOB_SIZE_GETTER) {
+    try {
+      return BLOB_SIZE_GETTER.call(part);
+    } catch {
+    }
+  }
+  if (part instanceof ArrayBuffer || ArrayBuffer.isView(part)) {
+    return part.byteLength;
+  }
+  throw new TileConversionError("UNSUPPORTED_BROWSER_RESOURCE", "Unsupported browser Blob part");
+}
+
+// src/v5/browser-tileset-source.ts
+function createBrowserTilesetConversionSource(options) {
+  if (!Number.isSafeInteger(options.maxInputBytes) || options.maxInputBytes < 1 || !Number.isSafeInteger(options.maxInputResources) || options.maxInputResources < 1) {
+    throw new TileConversionError(
+      "INVALID_BROWSER_SOURCE_OPTIONS",
+      "Browser tileset sources require positive byte and resource limits"
+    );
+  }
+  const fetcher = options.fetcher ?? fetch;
+  return {
+    async inspect(signal) {
+      throwIfAborted4(signal);
+      const rootUrl = new URL(options.input).href;
+      const response = await fetcher(rootUrl, { signal });
+      if (!response.ok) {
+        throw new TileConversionError(
+          "BROWSER_SOURCE_FETCH_FAILED",
+          `Could not fetch browser tileset (${response.status} ${response.statusText})`
+        );
+      }
+      const data = await readResponseBytes2(response, options.maxInputBytes, signal);
+      let tileset;
+      try {
+        tileset = JSON.parse(new TextDecoder().decode(data));
+      } catch {
+        throw new TileConversionError("INVALID_BROWSER_TILESET", "Tileset input is not valid JSON");
+      }
+      if (!isRecord(tileset) || !["1.0", "1.1"].includes(tileset.asset?.version || "") || !isRecord(tileset.root)) {
+        throw new TileConversionError(
+          "UNSUPPORTED_BROWSER_TILESET",
+          "Browser tileset traversal supports explicit 3D Tiles 1.0 and 1.1 documents"
+        );
+      }
+      const resources = collectResources(tileset.root, options.maxInputResources);
+      return { rootUrl, tileset, resources, tilesetBytes: data.byteLength };
+    },
+    async *read(inspection, signal) {
+      let inputBytes = inspection.tilesetBytes;
+      for (const descriptor of inspection.resources) {
+        throwIfAborted4(signal);
+        const resourceUrl = resolveResourceUrl(descriptor.uri, inspection.rootUrl);
+        const response = await fetcher(resourceUrl, { signal });
+        if (!response.ok) {
+          throw new TileConversionError(
+            "BROWSER_SOURCE_FETCH_FAILED",
+            `Could not fetch browser tile content (${response.status} ${response.statusText})`,
+            [
+              {
+                code: "BROWSER_SOURCE_FETCH_FAILED",
+                message: resourceUrl,
+                severity: "error",
+                resourceId: descriptor.resourceId
+              }
+            ]
+          );
+        }
+        const remainingBytes = options.maxInputBytes - inputBytes;
+        const data = await readResponseBytes2(response, remainingBytes, signal);
+        inputBytes += data.byteLength;
+        const contentType = response.headers.get("content-type") ?? void 0;
+        if (isJsonContent(data, contentType)) {
+          throw new TileConversionError(
+            "UNSUPPORTED_BROWSER_TILESET_CONTENT",
+            `Nested tilesets and JSON tile content are not supported: ${descriptor.uri}`
+          );
+        }
+        yield { ...descriptor, data, ...contentType ? { contentType } : {} };
+      }
+    }
+  };
+}
+function collectResources(root, maxInputResources) {
+  const resources = [];
+  const stack = [
+    { tile: root, path: [], transform: identityMatrix() }
+  ];
+  while (stack.length > 0) {
+    const { tile, path, transform: parentTransform } = stack.pop();
+    if (!isRecord(tile)) {
+      throw new TileConversionError("INVALID_BROWSER_TILESET", "Tile entries must be objects");
+    }
+    if (tile.implicitTiling !== void 0 || tile.extensions?.["3DTILES_implicit_tiling"] !== void 0) {
+      throw new TileConversionError(
+        "UNSUPPORTED_BROWSER_TILESET",
+        "Browser tileset traversal does not yet support implicit tiling"
+      );
+    }
+    if (tile.contents !== void 0 && !Array.isArray(tile.contents)) {
+      throw new TileConversionError("INVALID_BROWSER_TILESET", "Tile contents must be an array");
+    }
+    if (tile.children !== void 0 && !Array.isArray(tile.children)) {
+      throw new TileConversionError("INVALID_BROWSER_TILESET", "Tile children must be an array");
+    }
+    const transform = multiplyMatrices(parentTransform, normalizeMatrix(tile.transform));
+    const contents = tile.contents ?? (tile.content ? [tile.content] : []);
+    for (let contentIndex = 0; contentIndex < contents.length; contentIndex++) {
+      const content = contents[contentIndex];
+      if (!isRecord(content)) {
+        throw new TileConversionError(
+          "INVALID_BROWSER_TILESET",
+          "Tile content entries must be objects"
+        );
+      }
+      const uri = content.uri ?? content.url;
+      if (typeof uri !== "string" || !uri) {
+        throw new TileConversionError(
+          "INVALID_BROWSER_TILESET",
+          `Tile content at ${path.join("/")} has no URI`
+        );
+      }
+      if (resources.length >= maxInputResources) {
+        throw new TileConversionError(
+          "INPUT_RESOURCE_COUNT_EXCEEDED",
+          `Browser tileset exceeds the configured ${maxInputResources} resource limit`
+        );
+      }
+      resources.push({
+        resourceId: `tile-${path.length ? path.join("-") : "root"}-content-${contentIndex}`,
+        uri,
+        tilePath: path,
+        transform
+      });
+    }
+    const children = tile.children ?? [];
+    for (let childIndex = children.length - 1; childIndex >= 0; childIndex--) {
+      stack.push({
+        tile: children[childIndex],
+        path: [...path, childIndex],
+        transform
+      });
+    }
+  }
+  return resources;
+}
+async function readResponseBytes2(response, maximumBytes, signal) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new TileConversionError(
+      "BROWSER_SOURCE_STREAM_UNAVAILABLE",
+      "Browser inputs must provide a readable response stream"
+    );
+  }
+  const data = new Uint8Array(maximumBytes);
+  let byteLength = 0;
+  try {
+    while (true) {
+      throwIfAborted4(signal);
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value.byteLength > maximumBytes - byteLength) {
+        await reader.cancel();
+        throw new TileConversionError(
+          "INPUT_RESOURCE_TOO_LARGE",
+          `Browser tileset input exceeds the configured ${maximumBytes} byte remaining limit`
+        );
+      }
+      data.set(value, byteLength);
+      byteLength += value.byteLength;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return data.subarray(0, byteLength);
+}
+function isJsonContent(data, contentType) {
+  if (contentType?.includes("json")) return true;
+  let byteOffset = data[0] === 239 && data[1] === 187 && data[2] === 191 ? 3 : 0;
+  while ([9, 10, 13, 32].includes(data[byteOffset])) byteOffset++;
+  return data[byteOffset] === 123;
+}
+function resolveResourceUrl(uri, rootUrl) {
+  const root = new URL(rootUrl);
+  const resource = new URL(uri, root);
+  if (resource.origin === root.origin) {
+    for (const [name, value] of root.searchParams) {
+      if (!resource.searchParams.has(name)) resource.searchParams.append(name, value);
+    }
+  }
+  return resource.href;
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function identityMatrix() {
+  return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+}
+function normalizeMatrix(matrix) {
+  if (matrix === void 0) return identityMatrix();
+  if (!Array.isArray(matrix) || matrix.length !== 16 || matrix.some((value) => !Number.isFinite(value))) {
+    throw new TileConversionError(
+      "INVALID_BROWSER_TILESET",
+      "Tile transform must contain 16 finite numbers"
+    );
+  }
+  return matrix;
+}
+function multiplyMatrices(left, right) {
+  const result = new Array(16);
+  for (let column = 0; column < 4; column++) {
+    for (let row = 0; row < 4; row++) {
+      result[column * 4 + row] = left[row] * right[column * 4] + left[4 + row] * right[column * 4 + 1] + left[8 + row] * right[column * 4 + 2] + left[12 + row] * right[column * 4 + 3];
+    }
+  }
+  return result;
+}
+function throwIfAborted4(signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+  }
+}