@loaders.gl/tile-converter 5.0.0-alpha.7 → 5.0.0-alpha.9

package/src/v4/3d-tiles-converter/helpers/validate-i3s-spatial-reference.ts

@@ -0,0 +1,124 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright vis.gl contributors
+
+import {parseWKTCRS, type WKTCRSNode} from '@math.gl/crs';
+import {getSpatialCoordinateFrame} from '@loaders.gl/tiles';
+
+/** Horizontal CRS declarations consumed by the legacy I3S converter. */
+export type I3SConversionSpatialReference = {
+  /** Layer-level horizontal coordinate reference system. */
+  spatialReference?: {
+    /** Original spatial reference identifier. */
+    wkid?: number;
+    /** Current spatial reference identifier. */
+    latestWkid?: number;
+    /** Custom spatial reference definition. */
+    wkt?: string;
+  };
+  /** Fallback CRS declaration on the layer extent. */
+  fullExtent?: {
+    /** Coordinate system shared by the extent and layer. */
+    spatialReference?: I3SConversionSpatialReference['spatialReference'];
+  };
+  /** Coordinate systems declared for node bounds and geometry. */
+  store?: {
+    /** Coordinate system used by node bounds. */
+    indexCRS?: string;
+    /** Coordinate system used by geometry positions. */
+    vertexCRS?: string;
+  };
+};
+
+/**
+ * Reject explicit horizontal CRS declarations that the legacy converter cannot transform.
+ * Undeclared CRS metadata retains the historical WGS-84 assumption.
+ * @param layer - Source layer metadata, before interpreting any coordinates as longitude/latitude.
+ */
+export function validateI3SConversionSpatialReference(layer: I3SConversionSpatialReference): void {
+  const spatialReferences = [layer.spatialReference, layer.fullExtent?.spatialReference];
+  const unsupportedSpatialReference = spatialReferences.find(spatialReference => {
+    if (!spatialReference) {
+      return false;
+    }
+    const identifier = spatialReference.latestWkid ?? spatialReference.wkid;
+    return (
+      (identifier !== undefined && identifier !== 4326 && identifier !== 4979) ||
+      (spatialReference.wkt !== undefined && !isWgs84GeographicWkt(spatialReference.wkt))
+    );
+  });
+  const declarations = [layer.store?.indexCRS, layer.store?.vertexCRS].filter(
+    (declaration): declaration is string => Boolean(declaration)
+  );
+  const unsupportedDeclaration = declarations.find(
+    declaration =>
+      !/^(?:EPSG:(?:4326|4979)|urn:ogc:def:crs:EPSG::(?:4326|4979)|https?:\/\/www\.opengis\.net\/def\/crs\/EPSG\/0\/(?:4326|4979)\/?)$/i.test(
+        declaration
+      )
+  );
+  if (unsupportedSpatialReference || unsupportedDeclaration) {
+    const identifier = unsupportedSpatialReference?.latestWkid ?? unsupportedSpatialReference?.wkid;
+    const description =
+      unsupportedDeclaration || (identifier !== undefined ? `EPSG:${identifier}` : 'custom WKT');
+    throw new Error(
+      `The legacy I3S-to-3D Tiles converter requires WGS-84 (EPSG:4326) input; received ${description}. Reproject the source I3S dataset to EPSG:4326 before conversion.`
+    );
+  }
+}
+
+/** Recognize geographic WGS-84 WKT with degree units and the Greenwich prime meridian. */
+function isWgs84GeographicWkt(wellKnownText: string): boolean {
+  try {
+    if (getSpatialCoordinateFrame(wellKnownText) !== 'geographic') {
+      return false;
+    }
+    const {root} = parseWKTCRS(wellKnownText);
+    const nodes = collectWktNodes(root);
+    const datum = root.values.find(
+      value =>
+        value.type === 'node' &&
+        ['DATUM', 'ENSEMBLE', 'GEODETICDATUM'].includes(value.keyword.toUpperCase())
+    );
+    if (datum?.type !== 'node' || datum.values[0]?.type !== 'string') {
+      return false;
+    }
+    const datumName = datum.values[0].value.toLowerCase().replace(/[^a-z0-9]/g, '');
+    if (
+      ![
+        'wgs84',
+        'wgs1984',
+        'dwgs1984',
+        'worldgeodeticsystem1984',
+        'worldgeodeticsystem1984ensemble'
+      ].includes(datumName)
+    ) {
+      return false;
+    }
+    const angularUnits = nodes.filter(
+      node =>
+        ['UNIT', 'ANGLEUNIT'].includes(node.keyword.toUpperCase()) &&
+        (node === root || root.values.includes(node) || node.keyword.toUpperCase() === 'ANGLEUNIT')
+    );
+    const primeMeridian = nodes.find(node => node.keyword.toUpperCase() === 'PRIMEM');
+    return (
+      angularUnits.length > 0 &&
+      angularUnits.every(
+        node =>
+          node.values[1]?.type === 'number' &&
+          Math.abs(node.values[1].value - Math.PI / 180) < 1e-12
+      ) &&
+      (!primeMeridian ||
+        (primeMeridian.values[1]?.type === 'number' && primeMeridian.values[1].value === 0))
+    );
+  } catch {
+    return false;
+  }
+}
+
+/** Collect WKT nodes for semantic checks without inspecting quoted text as syntax. */
+function collectWktNodes(node: WKTCRSNode): WKTCRSNode[] {
+  return [
+    node,
+    ...node.values.flatMap(value => (value.type === 'node' ? collectWktNodes(value) : []))
+  ];
+}

package/src/{deps-installer → v4/deps-installer}/deps-installer.ts

@@ -48,13 +48,13 @@ export class DepsInstaller {
     await this.installFromNpm('draco', 'draco-worker-node.js');
 
     console.log('Installing "Draco Writer" worker'); // eslint-disable-line no-console
-    await this.installFromNpm('draco', 'draco-writer-worker-node.js');
+    await this.installFromNpm('draco', 'draco-writer-worker-node.cjs');
 
     console.log('Installing "Basis Loader" worker'); // eslint-disable-line no-console
-    await this.installFromNpm('textures', 'basis-worker-node.js');
+    await this.installFromNpm('textures', 'basis-worker-node.cjs');
 
     console.log('Installing "KTX2 Basis Writer" worker'); // eslint-disable-line no-console
-    await this.installFromNpm('textures', 'ktx2-basis-writer-worker-node.js');
+    await this.installFromNpm('textures', 'ktx2-basis-writer-worker-node.cjs');
 
     console.log('Installing "Draco decoder" library'); // eslint-disable-line no-console
     await this.installFromUrl(
@@ -101,13 +101,16 @@ export class DepsInstaller {
     console.log('All dependencies were installed succesfully.'); // eslint-disable-line no-console
   }
 
+  /** Download a published worker or library into the converter's local resource directory. */
   private async installFromNpm(module: string, name: string, extraPath: string = '') {
-    const fileResponse = await fetchFile(
-      `https://unpkg.com/@loaders.gl/${module}@${VERSION}/dist/${extraPath}/${name}`
-    );
+    const resourcePath = ['dist', extraPath, name].filter(Boolean).join('/');
+    const resourceUrl = `https://unpkg.com/@loaders.gl/${module}@${VERSION}/${resourcePath}`;
+    const fileResponse = await fetchFile(resourceUrl);
 
     if (fileResponse.status < 200 || fileResponse.status >= 300) {
-      throw new Error(`Failed to load resource ${name}`);
+      throw new Error(
+        `Failed to load resource ${name} from ${resourceUrl}: HTTP ${fileResponse.status}`
+      );
     }
 
     const fileData = await fileResponse.arrayBuffer();

package/src/v4/i3s-converter/helpers/encode-string-attribute.ts

@@ -0,0 +1,23 @@
+/**
+ * Encodes I3S string attributes as little-endian counts followed by UTF-8 strings.
+ * Each string's byte count includes its trailing null byte. Values retain the
+ * converter's existing JavaScript string coercion, including null and undefined.
+ */
+export function encodeStringAttribute(values: readonly unknown[]): ArrayBuffer {
+  const textEncoder = new TextEncoder();
+  const encodedValues = Array.from(values, value => textEncoder.encode(`${String(value)}\0`));
+  const stringByteLength = encodedValues.reduce((total, value) => total + value.byteLength, 0);
+  const headerByteLength = (2 + values.length) * Uint32Array.BYTES_PER_ELEMENT;
+  const output = new Uint8Array(headerByteLength + stringByteLength);
+  const header = new DataView(output.buffer);
+  header.setUint32(0, values.length, true);
+  header.setUint32(4, stringByteLength, true);
+
+  let byteOffset = headerByteLength;
+  for (const [index, encodedValue] of encodedValues.entries()) {
+    header.setUint32(8 + index * Uint32Array.BYTES_PER_ELEMENT, encodedValue.byteLength, true);
+    output.set(encodedValue, byteOffset);
+    byteOffset += encodedValue.byteLength;
+  }
+  return output.buffer;
+}

package/src/{i3s-converter → v4/i3s-converter}/helpers/geometry-converter.ts

@@ -21,7 +21,6 @@ import {Ellipsoid} from '@math.gl/geospatial';
 /* @ts-expect-error TS2732: Cannot find module 'node:module' or its corresponding type declarations. */
 import {createRequire} from 'node:module';
 /* @ts-expect-error TS2732: Cannot find module 'node:module' or its corresponding type declarations. */
-import {dirname, join} from 'node:path';
 
 import {DracoWriterWorker} from '@loaders.gl/draco';
 import {assert, encode} from '@loaders.gl/core';
@@ -34,6 +33,7 @@ import {
 import md5 from 'md5';
 import {v4 as uuidv4} from 'uuid';
 import {generateAttributes} from './geometry-attributes';
+import {encodeStringAttribute} from './encode-string-attribute';
 import {createBoundingVolumesFromGeometry} from './coordinate-converter';
 import {
   ConvertedAttributes,
@@ -1028,15 +1028,18 @@ async function mergeMaterials(
     material1.mergedMaterials &&
     material2.mergedMaterials
   ) {
-    const buffer1 = Buffer.from(material1.texture.bufferView.data);
-    const buffer2 = Buffer.from(material2.texture.bufferView.data);
+    const firstImageBytes = new Uint8Array(material1.texture.bufferView.data);
+    const secondImageBytes = new Uint8Array(material2.texture.bufferView.data);
     try {
       // @ts-ignore
       const {joinImages} = await import('join-images');
-      const sharpData = await joinImages([buffer1, buffer2], {direction: 'horizontal'});
-      material1.texture.bufferView.data = await sharpData
+      const sharpData = await joinImages([firstImageBytes, secondImageBytes], {
+        direction: 'horizontal'
+      });
+      const encodedImage = await sharpData
         .toFormat(material1.texture.mimeType === 'image/png' ? 'png' : 'jpeg')
         .toBuffer();
+      material1.texture.bufferView.data = new Uint8Array(encodedImage);
     } catch (error) {
       // eslint-disable-next-line no-console
       console.log(
@@ -1458,10 +1461,10 @@ function generateAttributeBuffer(type: string, value: any): ArrayBuffer {
       attributeBuffer = generateDoubleAttributeBuffer(value);
       break;
     case STRING_TYPE:
-      attributeBuffer = generateStringAttributeBuffer(value);
+      attributeBuffer = encodeStringAttribute(value);
       break;
     default:
-      attributeBuffer = generateStringAttributeBuffer(value);
+      attributeBuffer = encodeStringAttribute(value);
   }
 
   return attributeBuffer;
@@ -1497,7 +1500,7 @@ function getAttributeType(key: string, attributeStorageInfo: any[]): string {
 /**
  * Convert short integer to attribute arrayBuffer.
  * @param featureIds
- * @returns - Buffer with objectId data.
+ * @returns ArrayBuffer with objectId data.
  */
 function generateShortIntegerAttributeBuffer(featureIds: any[]): ArrayBuffer {
   const count = new Uint32Array([featureIds.length]);
@@ -1508,7 +1511,7 @@ function generateShortIntegerAttributeBuffer(featureIds: any[]): ArrayBuffer {
 /**
  * Convert double to attribute arrayBuffer.
  * @param featureIds
- * @returns - Buffer with objectId data.
+ * @returns ArrayBuffer with objectId data.
  */
 function generateDoubleAttributeBuffer(featureIds: any[]): ArrayBuffer {
   const count = new Uint32Array([featureIds.length]);
@@ -1518,36 +1521,6 @@ function generateDoubleAttributeBuffer(featureIds: any[]): ArrayBuffer {
   return concatenateArrayBuffers(count.buffer, padding.buffer, valuesArray.buffer);
 }
 
-/**
- * Convert batch table attributes to array buffer with batch table data.
- * @param batchAttributes
- * @returns - Buffer with batch table data.
- */
-function generateStringAttributeBuffer(batchAttributes: any[]): ArrayBuffer {
-  const stringCountArray = new Uint32Array([batchAttributes.length]);
-  let totalNumberOfBytes = 0;
-  const stringSizesArray = new Uint32Array(batchAttributes.length);
-  const stringBufferArray: ArrayBuffer[] = [];
-
-  for (let index = 0; index < batchAttributes.length; index++) {
-    const currentString = `${String(batchAttributes[index])}\0`;
-    const currentStringBuffer = Buffer.from(currentString);
-    const currentStringSize = currentStringBuffer.length;
-    totalNumberOfBytes += currentStringSize;
-    stringSizesArray[index] = currentStringSize;
-    stringBufferArray.push(currentStringBuffer);
-  }
-
-  const totalBytes = new Uint32Array([totalNumberOfBytes]);
-
-  return concatenateArrayBuffers(
-    stringCountArray.buffer,
-    totalBytes.buffer,
-    stringSizesArray.buffer,
-    ...stringBufferArray
-  );
-}
-
 /**
  * Convert featureIds to BigUint64Array.
  * @param featureIds
@@ -1642,14 +1615,14 @@ async function generateCompressedGeometry(
   );
 }
 
+/** Resolve the published Node Draco writer, falling back to the dependency installer destination. */
 function getLocalDracoWriterWorkerUrl(): string {
   try {
     const require = createRequire(import.meta.url);
-    const packageJsonPath = require.resolve('@loaders.gl/draco/package.json');
-    return join(dirname(packageJsonPath), 'src/workers/draco-writer-worker-node.cjs');
+    return require.resolve('@loaders.gl/draco/draco-writer-worker-node.cjs');
   } catch {
     // Fall back to monorepo-local path
-    return './modules/draco/src/workers/draco-writer-worker-node.cjs';
+    return './modules/draco/dist/draco-writer-worker-node.cjs';
   }
 }
 

package/src/{i3s-converter → v4/i3s-converter}/helpers/gltf-attributes.ts

@@ -2,6 +2,7 @@ import type {Tiles3DTileContent} from '@loaders.gl/3d-tiles';
 import type {GLTFAccessorPostprocessed, GLTFNodePostprocessed} from '@loaders.gl/gltf';
 import {Matrix4, TypedArray, Vector3} from '@math.gl/core';
 import {BoundingSphere, OrientedBoundingBox} from '@math.gl/culling';
+import {getImageData} from '@loaders.gl/images';
 import {Ellipsoid} from '@math.gl/geospatial';
 import {GLTFAttributesData} from '../types';
 
@@ -30,15 +31,15 @@ export function prepareDataForAttributesConversion(
       if (imageObject?.image?.compressed) {
         return null;
       }
-      const data = imageObject?.image?.data;
+      const {data, width, height} = getImageData(imageObject.image);
       const dataCopy = new Uint8Array(data.length);
       dataCopy.set(data);
       return {
         data: dataCopy,
         compressed: false,
-        height: imageObject.image.height,
-        width: imageObject.image.width,
-        components: imageObject.image.components,
+        height,
+        width,
+        components: data.length / (width * height),
         mimeType: imageObject.mimeType
       };
     }) || [];

package/src/{i3s-converter → v4/i3s-converter}/helpers/load-3d-tiles.ts

@@ -119,15 +119,11 @@ export async function loadFromArchive(
     const hashTable = await loadHashTable(fileProvider);
     const archive = new Tiles3DArchive(fileProvider, hashTable, tz3Path);
     const fileSystem = new ZipFileSystem(archive);
-    // const loadOptionsWithoutDeprecatedFetch = {...loadOptions} as Tiles3DLoaderOptions & {
-    //   fetch?: unknown;
-    // };
-    // delete loadOptionsWithoutDeprecatedFetch.fetch;
-    // const mergedOptions = {
-    //   ...loadOptionsWithoutDeprecatedFetch,
-    //   core: {...loadOptions?.core, fetch: fileSystem.fetch.bind(fileSystem)}
-    // }
-    const content = await load(filename, loader, loadOptions);
+    const archiveLoadOptions = {
+      ...loadOptions,
+      core: {...loadOptions?.core, fetch: fileSystem.fetch.bind(fileSystem)}
+    };
+    const content = await load(filename, loader, archiveLoadOptions);
     await fileSystem.destroy();
     return content;
   }

package/src/{i3s-converter → v4/i3s-converter}/i3s-converter.ts

@@ -49,7 +49,7 @@ import {validateNodeBoundingVolumes} from './helpers/node-debug';
 import {KTX2BasisWriterWorker} from '@loaders.gl/textures';
 import {LoaderWithParser} from '@loaders.gl/loader-utils';
 import {I3SMaterialDefinition, TextureSetDefinitionFormats} from '@loaders.gl/i3s';
-import {ImageWriter} from '@loaders.gl/images';
+import {getImageData, ImageWriter} from '@loaders.gl/images';
 import {GLTFImagePostprocessed} from '@loaders.gl/gltf';
 import {
   GLTFPrimitiveModeString,
@@ -143,7 +143,7 @@ export default class I3SConverter {
     basis: {
       format: 'rgba32',
       // We need to load local fs workers because nodejs can't load workers from the Internet
-      workerUrl: './modules/textures/dist/basis-worker-node.js'
+      workerUrl: './modules/textures/dist/basis-worker-node.cjs'
     },
     // We need to load local fs workers because nodejs can't load workers from the Internet
     draco: {workerUrl: './modules/draco/dist/draco-worker-node.js'},
@@ -1266,18 +1266,17 @@ export default class I3SConverter {
 
           if (this.generateTextures) {
             formats.push({name: '1', format: 'ktx2'});
-            // For Node.js texture.image.data is type of Buffer
-            const copyArrayBuffer = texture.image.data.subarray();
-            const arrayToEncode = new Uint8Array(copyArrayBuffer);
+            const imageData = getImageData(texture.image);
+            const arrayToEncode = new Uint8Array(imageData.data);
             const ktx2TextureData = encode(
-              {...texture.image, data: arrayToEncode},
+              {...imageData, data: arrayToEncode},
               // @ts-expect-error - Worker encoder typing is still WIP
               KTX2BasisWriterWorker,
               {
                 ...KTX2BasisWriterWorker.options,
                 ['ktx2-basis-writer']: {
                   // We need to load local fs workers because nodejs can't load workers from the Internet
-                  workerUrl: './modules/textures/dist/ktx2-basis-writer-worker-node.js'
+                  workerUrl: './modules/textures/dist/ktx2-basis-writer-worker-node.cjs'
                 },
                 reuseWorkers: true,
                 _nodeWorkers: true,

package/src/{i3s-server → v4/i3s-server}/README.md

@@ -6,8 +6,8 @@ The server provides I3S Rest endpoints per specification https://github.com/Esri
 ## Development
 
 - install tsx globally `yarn global add tsx`
-- uncomment "local debug" lines in `modules/tile-converter/src/i3s-server/app.ts` and `modules/tile-converter/src/i3s-server/bin/www.ts` (see comments);
-- run `PORT=8080 HTTPS_PORT=4443 I3sLayerPath="./path/to/dataset" DEBUG=i3s-server:* npx tsx ./src/i3s-server/bin/www.ts`
+- uncomment "local debug" lines in `src/v4/i3s-server/app.ts` and `src/v4/i3s-server/bin/www.ts` (see comments);
+- run `PORT=8080 HTTPS_PORT=4443 I3sLayerPath="./path/to/dataset" DEBUG=i3s-server:* npx tsx ./src/v4/i3s-server/bin/www.ts`
 
 ## Usage
 

package/src/{i3s-server → v4/i3s-server}/routes/slpk-router.ts

@@ -29,6 +29,7 @@ router.get('*', (req, res, next) => {
         const json = JSON.parse(textDecoder.decode(file));
         res.send(json);
       } catch (_e) {
+        // Express 4 sends typed arrays as JSON; adapt only at this Node.js HTTP boundary.
         res.send(Buffer.from(file));
       }
     } else {

package/src/v4/index.ts

@@ -0,0 +1,2 @@
+export {default as I3SConverter} from './i3s-converter/i3s-converter';
+export {default as Tiles3DConverter} from './3d-tiles-converter/3d-tiles-converter';

package/src/v5/browser-sink.ts

@@ -0,0 +1,130 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {TileConversionError} from './conversion-api.js';
+import type {TileConversionReport, TileConversionSink} from './conversion-api.js';
+
+const BLOB_SIZE_GETTER = Object.getOwnPropertyDescriptor(Blob.prototype, 'size')?.get;
+
+/** One named browser output resource. */
+export interface BrowserTileConversionResource {
+  /** Stable relative output path supplied by the target profile. */
+  readonly resourceId: string;
+  /** Parts combined into a Blob after the total output budget is checked. */
+  readonly parts: readonly BlobPart[];
+  /** MIME type recorded on the resulting Blob. */
+  readonly contentType?: string;
+}
+
+/** A named output resource retained by the bounded browser sink. */
+export interface BrowserTileConversionFile {
+  /** Stable relative output path supplied by the target profile. */
+  readonly resourceId: string;
+  /** Browser-native data for download or application-provided packaging. */
+  readonly blob: Blob;
+}
+
+/** Memory limit for a browser conversion sink. */
+export interface BoundedMemoryTileConversionSinkOptions {
+  /** Maximum combined Blob size retained by this sink, captured at creation, in bytes. */
+  readonly maxTotalBytes: number;
+}
+
+/** Browser sink with read access to its bounded output resources. */
+export interface BoundedMemoryTileConversionSink
+  extends TileConversionSink<BrowserTileConversionResource> {
+  /** Returns the retained files in stable resource-ID order. */
+  getFiles(): readonly BrowserTileConversionFile[];
+}
+
+/**
+ * Creates a browser-only sink that retains output as Blobs under a total byte limit.
+ *
+ * The sink does not download or archive files. Applications can use `getFiles()` after
+ * `convertTileset` completes and package or download the returned Blobs as needed.
+ *
+ * @param options - Maximum in-memory output size.
+ * @returns A sink that stores browser-native Blobs and clears them on abort.
+ */
+export function createBoundedMemoryTileConversionSink(
+  options: BoundedMemoryTileConversionSinkOptions
+): BoundedMemoryTileConversionSink {
+  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 = new Map<string, BrowserTileConversionFile>();
+  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: TileConversionReport) {
+      if (closed) {
+        throw new TileConversionError('RESOURCE_SINK_CLOSED', 'Sink has already been finalized');
+      }
+      closed = true;
+    },
+    async abort() {
+      files.clear();
+      totalBytes = 0;
+      closed = true;
+    }
+  };
+}
+
+/** Measures supported Blob parts without copying them into a Blob first. */
+function measureBlobPart(part: BlobPart): number {
+  if (typeof part === 'string') {
+    return new TextEncoder().encode(part).byteLength;
+  }
+  if (BLOB_SIZE_GETTER) {
+    try {
+      return BLOB_SIZE_GETTER.call(part) as number;
+    } catch {
+      // Keep checking the remaining supported Blob part types.
+    }
+  }
+  if (part instanceof ArrayBuffer || ArrayBuffer.isView(part)) {
+    return part.byteLength;
+  }
+  throw new TileConversionError('UNSUPPORTED_BROWSER_RESOURCE', 'Unsupported browser Blob part');
+}