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

package/dist/v5/feature-arrow.d.ts

@@ -0,0 +1,36 @@
+import type { ArrowTableBatch, Schema } from '@loaders.gl/schema';
+/** Feature attributes and source identifier ready for Arrow normalization. */
+export interface TileFeatureAttributes {
+    /** Stable feature identifier decoded from the source's feature-ID descriptor. */
+    readonly featureId: string | number | bigint;
+    /** Property values interpreted from the source metadata class. */
+    readonly properties: Readonly<Record<string, unknown>>;
+    /** Original class or property-table name, kept distinct between output batches. */
+    readonly metadataClass: string;
+    /** Optional original encoded metadata bytes, preserved without interpretation. */
+    readonly rawMetadata?: Uint8Array;
+}
+/** Explicit Arrow mapping and bounded output size for feature attribute batches. */
+export interface FeatureArrowBatchOptions {
+    /** Declared output columns and types, including the feature-ID column. */
+    readonly schema: Schema;
+    /** Schema field receiving stable feature identifiers. Defaults to `feature_id`. */
+    readonly featureIdField?: string;
+    /** Optional binary field receiving source metadata bytes. */
+    readonly rawMetadataField?: string;
+    /** Maximum number of features in one emitted Arrow record batch. Defaults to 65,536. */
+    readonly batchSize?: number;
+}
+/**
+ * Converts decoded feature attributes to bounded Arrow batches using a caller-declared schema.
+ *
+ * Values retain their source primitive types; nested lists, structs, dictionary enums, and 64-bit
+ * identifiers use the corresponding schema field type. Missing schema fields and incompatible
+ * identifiers fail explicitly. Unknown properties are rejected so a class mapping cannot silently
+ * discard data. Separate metadata classes should be passed separately with their own schema.
+ *
+ * @param features - Features decoded from one source metadata class.
+ * @param options - Explicit Arrow schema and batch configuration.
+ * @returns Arrow table batches whose schema metadata records the source metadata class.
+ */
+export declare function convertFeatureAttributesToArrowBatches(features: readonly TileFeatureAttributes[], options: FeatureArrowBatchOptions): ArrowTableBatch[];

package/dist/v5/i3s-mesh-conversion.d.ts

@@ -0,0 +1,26 @@
+import type { EncodedI3SMeshLayer, I3SMeshWriterOptions } from '@loaders.gl/i3s';
+import type { TileConversionCodec, TileConversionSink } from '@loaders.gl/tile-converter/v5/core';
+import type { Tiles3DConversionSpatialContext } from '@loaders.gl/tile-converter/v5/core';
+import type { MeshSourceResource } from './mesh-source.js';
+import type { BrowserTileConversionFile } from '@loaders.gl/tile-converter/v5/core';
+/** One authored mesh layer, ready for the single-layer sink. */
+export interface I3SMeshConversionResource extends EncodedI3SMeshLayer {
+    /** Source placement identifier used for diagnostics. */
+    readonly id: string;
+}
+/** Spatial preparation and required authoring limits for the I3S codec. */
+export interface I3SMeshConversionCodecOptions extends Pick<I3SMeshWriterOptions, 'name' | 'maxPositionError' | 'maxResourceBytes'> {
+    /** Shared source-to-ECEF context, applied exactly once before I3S geographic encoding. */
+    readonly spatialContext: Tiles3DConversionSpatialContext;
+}
+/** Creates a portable source-mesh to I3S layer codec with explicit precision and feature diagnostics. */
+export declare function createI3SMeshConversionCodec<TInspection = unknown>(options: I3SMeshConversionCodecOptions): TileConversionCodec<TInspection, MeshSourceResource, I3SMeshConversionResource>;
+/** Atomic bounded output for one authored I3S layer. */
+export interface SingleMeshI3SSink extends TileConversionSink<I3SMeshConversionResource> {
+    /** Compressed archive-relative files visible only after successful finalization. */
+    getFiles(): readonly BrowserTileConversionFile[];
+}
+/** Creates an atomic bounded single-mesh I3S sink; pass finalized files to createTileConversionArchive. */
+export declare function createSingleMeshI3SSink(options: {
+    /** Maximum retained compressed resource bytes; not peak conversion memory. */ readonly maxTotalBytes: number;
+}): SingleMeshI3SSink;

package/dist/v5/index.cjs

@@ -0,0 +1,63 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TileConversionError: () => import_core.TileConversionError,
+  convertFeatureAttributesToArrowBatches: () => import_adapters.convertFeatureAttributesToArrowBatches,
+  convertPointCloudSource: () => import_adapters4.convertPointCloudSource,
+  convertTileset: () => import_core.convertTileset,
+  createI3SConversionSpatialContext: () => import_core3.createI3SConversionSpatialContext,
+  createI3SMeshConversionCodec: () => import_adapters11.createI3SMeshConversionCodec,
+  createManifestBackedTileConversionSink: () => import_core5.createManifestBackedTileConversionSink,
+  createMeshConversionCodec: () => import_adapters6.createMeshConversionCodec,
+  createMeshTilesetConversionSource: () => import_adapters10.createMeshTilesetConversionSource,
+  createSingleMeshI3SSink: () => import_adapters11.createSingleMeshI3SSink,
+  createSingleMeshTilesetArchive: () => import_adapters9.createSingleMeshTilesetArchive,
+  createSingleMeshTilesetSink: () => import_adapters7.createSingleMeshTilesetSink,
+  createTileConversionArchive: () => import_adapters8.createTileConversionArchive,
+  createTiles3DConversionSpatialContext: () => import_core3.createTiles3DConversionSpatialContext,
+  createTilesetConversionSource: () => import_core2.createTilesetConversionSource,
+  encodeMeshTile: () => import_adapters5.encodeMeshTile,
+  encodePointCloudSource: () => import_adapters3.encodePointCloudSource,
+  encodePointCloudSourceTile: () => import_adapters3.encodePointCloudSourceTile,
+  encodePointCloudTile: () => import_adapters2.encodePointCloudTile,
+  encodeTileConversionArchiveInBatches: () => import_adapters8.encodeTileConversionArchiveInBatches,
+  inspectTileset: () => import_core.inspectTileset,
+  traversePointCloudSource: () => import_core4.traversePointCloudSource,
+  validateTileset: () => import_core.validateTileset
+});
+module.exports = __toCommonJS(index_exports);
+var import_core = require("@loaders.gl/tile-converter/v5/core");
+var import_core2 = require("@loaders.gl/tile-converter/v5/core");
+var import_core3 = require("@loaders.gl/tile-converter/v5/core");
+var import_adapters = require("@loaders.gl/tile-converter/v5/adapters");
+var import_adapters2 = require("@loaders.gl/tile-converter/v5/adapters");
+var import_core4 = require("@loaders.gl/tile-converter/v5/core");
+var import_adapters3 = require("@loaders.gl/tile-converter/v5/adapters");
+var import_adapters4 = require("@loaders.gl/tile-converter/v5/adapters");
+var import_core5 = require("@loaders.gl/tile-converter/v5/core");
+var import_adapters5 = require("@loaders.gl/tile-converter/v5/adapters");
+var import_adapters6 = require("@loaders.gl/tile-converter/v5/adapters");
+var import_adapters7 = require("@loaders.gl/tile-converter/v5/adapters");
+var import_adapters8 = require("@loaders.gl/tile-converter/v5/adapters");
+var import_adapters9 = require("@loaders.gl/tile-converter/v5/adapters");
+var import_adapters10 = require("@loaders.gl/tile-converter/v5/adapters");
+var import_adapters11 = require("@loaders.gl/tile-converter/v5/adapters");

package/dist/v5/index.d.ts

@@ -0,0 +1,32 @@
+export { convertTileset, inspectTileset, TileConversionError, validateTileset } from '@loaders.gl/tile-converter/v5/core';
+export type { ConvertTilesetOptions, TileConversionCodec, TileConversionDiagnostic, TileConversionProgress, TileConversionReport, TileConversionSink, TileConversionSource, TileValidationReport, ValidateTilesetOptions } from '@loaders.gl/tile-converter/v5/core';
+export { createTilesetConversionSource } from '@loaders.gl/tile-converter/v5/core';
+export type { TilesetConversionSourceOptions } from '@loaders.gl/tile-converter/v5/core';
+export { createI3SConversionSpatialContext, createTiles3DConversionSpatialContext } from '@loaders.gl/tile-converter/v5/core';
+export type { I3SConversionSpatialContext, Tiles3DConversionSpatialContext } from '@loaders.gl/tile-converter/v5/core';
+export { convertFeatureAttributesToArrowBatches } from '@loaders.gl/tile-converter/v5/adapters';
+export type { FeatureArrowBatchOptions, TileFeatureAttributes } from '@loaders.gl/tile-converter/v5/adapters';
+export { encodePointCloudTile } from '@loaders.gl/tile-converter/v5/adapters';
+export type { EncodePointCloudTileOptions } from '@loaders.gl/tile-converter/v5/adapters';
+export { traversePointCloudSource } from '@loaders.gl/tile-converter/v5/core';
+export type { PointCloudSourceTile, TraversePointCloudSourceOptions } from '@loaders.gl/tile-converter/v5/core';
+export { encodePointCloudSource, encodePointCloudSourceTile } from '@loaders.gl/tile-converter/v5/adapters';
+export type { EncodedPointCloudSourceTile, EncodePointCloudSourceOptions } from '@loaders.gl/tile-converter/v5/adapters';
+export { convertPointCloudSource } from '@loaders.gl/tile-converter/v5/adapters';
+export type { ConvertPointCloudSourceOptions } from '@loaders.gl/tile-converter/v5/adapters';
+export { createManifestBackedTileConversionSink } from '@loaders.gl/tile-converter/v5/core';
+export type { ManifestBackedTileConversionSinkOptions, TileResourceManifest, TileResourceManifestEntry, TileResourceManifestStore } from '@loaders.gl/tile-converter/v5/core';
+export { encodeMeshTile } from '@loaders.gl/tile-converter/v5/adapters';
+export type { MeshTileMaterial, MeshTileOptions, MeshTileTexture, MeshTileSampler, MeshTileTextureTransform } from '@loaders.gl/tile-converter/v5/adapters';
+export { createMeshConversionCodec } from '@loaders.gl/tile-converter/v5/adapters';
+export type { MeshConversionInput, EncodedMeshConversionResource, MeshConversionCodecOptions } from '@loaders.gl/tile-converter/v5/adapters';
+export { createSingleMeshTilesetSink } from '@loaders.gl/tile-converter/v5/adapters';
+export type { SingleMeshTilesetSink, SingleMeshTilesetSinkOptions } from '@loaders.gl/tile-converter/v5/adapters';
+export { createTileConversionArchive, encodeTileConversionArchiveInBatches } from '@loaders.gl/tile-converter/v5/adapters';
+export type { TileConversionArchiveOptions } from '@loaders.gl/tile-converter/v5/adapters';
+export { createSingleMeshTilesetArchive } from '@loaders.gl/tile-converter/v5/adapters';
+export type { SingleMeshTilesetArchiveOptions } from '@loaders.gl/tile-converter/v5/adapters';
+export { createMeshTilesetConversionSource } from '@loaders.gl/tile-converter/v5/adapters';
+export type { MeshSourceResource, MeshTilesetSourceOptions, MeshSourceFeatureOptions } from '@loaders.gl/tile-converter/v5/adapters';
+export { createI3SMeshConversionCodec, createSingleMeshI3SSink } from '@loaders.gl/tile-converter/v5/adapters';
+export type { I3SMeshConversionResource, I3SMeshConversionCodecOptions, SingleMeshI3SSink } from '@loaders.gl/tile-converter/v5/adapters';

package/dist/v5/index.js

@@ -0,0 +1,59 @@
+// src/v5/index.ts
+import {
+  convertTileset,
+  inspectTileset,
+  TileConversionError,
+  validateTileset
+} from "@loaders.gl/tile-converter/v5/core";
+import { createTilesetConversionSource } from "@loaders.gl/tile-converter/v5/core";
+import {
+  createI3SConversionSpatialContext,
+  createTiles3DConversionSpatialContext
+} from "@loaders.gl/tile-converter/v5/core";
+import { convertFeatureAttributesToArrowBatches } from "@loaders.gl/tile-converter/v5/adapters";
+import { encodePointCloudTile } from "@loaders.gl/tile-converter/v5/adapters";
+import { traversePointCloudSource } from "@loaders.gl/tile-converter/v5/core";
+import {
+  encodePointCloudSource,
+  encodePointCloudSourceTile
+} from "@loaders.gl/tile-converter/v5/adapters";
+import { convertPointCloudSource } from "@loaders.gl/tile-converter/v5/adapters";
+import { createManifestBackedTileConversionSink } from "@loaders.gl/tile-converter/v5/core";
+import { encodeMeshTile } from "@loaders.gl/tile-converter/v5/adapters";
+import { createMeshConversionCodec } from "@loaders.gl/tile-converter/v5/adapters";
+import { createSingleMeshTilesetSink } from "@loaders.gl/tile-converter/v5/adapters";
+import {
+  createTileConversionArchive,
+  encodeTileConversionArchiveInBatches
+} from "@loaders.gl/tile-converter/v5/adapters";
+import { createSingleMeshTilesetArchive } from "@loaders.gl/tile-converter/v5/adapters";
+import { createMeshTilesetConversionSource } from "@loaders.gl/tile-converter/v5/adapters";
+import {
+  createI3SMeshConversionCodec,
+  createSingleMeshI3SSink
+} from "@loaders.gl/tile-converter/v5/adapters";
+export {
+  TileConversionError,
+  convertFeatureAttributesToArrowBatches,
+  convertPointCloudSource,
+  convertTileset,
+  createI3SConversionSpatialContext,
+  createI3SMeshConversionCodec,
+  createManifestBackedTileConversionSink,
+  createMeshConversionCodec,
+  createMeshTilesetConversionSource,
+  createSingleMeshI3SSink,
+  createSingleMeshTilesetArchive,
+  createSingleMeshTilesetSink,
+  createTileConversionArchive,
+  createTiles3DConversionSpatialContext,
+  createTilesetConversionSource,
+  encodeMeshTile,
+  encodePointCloudSource,
+  encodePointCloudSourceTile,
+  encodePointCloudTile,
+  encodeTileConversionArchiveInBatches,
+  inspectTileset,
+  traversePointCloudSource,
+  validateTileset
+};

package/dist/v5/mesh-conversion.d.ts

@@ -0,0 +1,62 @@
+import type { TilesetSpatialReference } from '@loaders.gl/tiles';
+import type { MeshGeometry } from '@loaders.gl/schema';
+import type { LoadLibraryOptions } from '@loaders.gl/worker-utils';
+import type { TileConversionCodec } from '@loaders.gl/tile-converter/v5/core';
+import type { Tiles3DConversionSpatialContext } from '@loaders.gl/tile-converter/v5/core';
+import type { MeshTileMaterial } from './mesh.js';
+/** Explicitly selected geometry, with positions already in the spatial context's source frame. */
+export interface MeshConversionInput {
+    /** Caller-owned resource identifier, forwarded to the output sink. */
+    readonly id: string;
+    /** Triangle geometry with absolute packed Float32 or Float64 source positions. */
+    readonly mesh: MeshGeometry;
+    /** Optional single material with an embedded base-color image, mapped explicitly by the source adapter. */
+    readonly material?: MeshTileMaterial;
+    /** Finite xyz origin in the target frame, subtracted before float32 encoding. */
+    readonly origin: readonly [number, number, number];
+}
+/** A completed GLB resource and the metadata needed to place its local geometry. */
+export interface EncodedMeshConversionResource {
+    /** Caller-owned resource identifier. */
+    readonly id: string;
+    /** Self-contained GLB with local positions and transformed normals. */
+    readonly glb: ArrayBuffer;
+    /** Target-frame translation to add to the encoded positions. */
+    readonly origin: readonly [number, number, number];
+    /** Target-frame bounds of the reconstructed encoded vertices, including float32 rounding. */
+    readonly boundingBox: readonly [readonly number[], readonly number[]];
+    /** Bounds of encoded local vertices before adding the origin, without absolute-coordinate cancellation. */
+    readonly localBoundingBox: readonly [readonly number[], readonly number[]];
+    /** Metadata describing the output coordinate operation and height reference. */
+    readonly spatialReference: TilesetSpatialReference;
+    /** Largest measured Euclidean reconstruction error in target coordinate units. */
+    readonly maximumPositionError: number;
+}
+/** Spatial policy used by the concrete mesh conversion codec. */
+export interface MeshConversionCodecOptions {
+    /** Shared context that accepts absolute source positions and returns absolute target positions. */
+    readonly spatialContext: Tiles3DConversionSpatialContext;
+    /** Maximum Euclidean reconstruction error per vertex, in target coordinate units. */
+    readonly maxPositionError: number;
+    /** Lossless Draco Edge Breaker is enabled by default; false emits uncompressed GLB geometry. */
+    readonly draco?: boolean;
+    /** Optional local/CDN library locations or injected Draco runtimes for compression and verification. */
+    readonly dracoLibraryOptions?: LoadLibraryOptions;
+}
+/**
+ * Creates a concrete mesh codec for `convertTileset`.
+ *
+ * Source adapters must select geometry and apply source placement before supplying absolute
+ * positions and matching normals. This codec applies the supplied spatial context once, rebases
+ * around each input's target origin, and rejects rounding above the explicit error budget.
+ * Lossless Draco Edge Breaker is enabled by default; decoded positions determine output bounds.
+ * Set draco to false for uncompressed geometry. Quantization is not enabled by this profile.
+ * Geographic and unknown output frames are rejected. The returned origin/bounds/reference are
+ * external placement metadata; applications own axis conventions, hierarchy, and packaging.
+ * Input arrays are not mutated. Core input/output byte gates, cancellation, awaited writes, and
+ * destination finalize/abort handling apply when used through `convertTileset`.
+ *
+ * @param options - Resolved spatial context and finite nonnegative target-unit precision budget.
+ * @returns One GLB and matching metadata per input geometry.
+ */
+export declare function createMeshConversionCodec<TInspection = unknown>(options: MeshConversionCodecOptions): TileConversionCodec<TInspection, MeshConversionInput, EncodedMeshConversionResource>;

package/dist/v5/mesh-draco.d.ts

@@ -0,0 +1,8 @@
+import type { MeshGeometry } from '@loaders.gl/schema';
+import type { LoadLibraryOptions } from '@loaders.gl/worker-utils';
+import { type MeshTileOptions } from './mesh.js';
+/** Encodes the validated single-mesh profile with lossless Edge Breaker and no raw fallback. */
+export declare function encodeDracoMeshTile(geometry: MeshGeometry, options: MeshTileOptions, libraryOptions?: LoadLibraryOptions): Promise<{
+    glb: ArrayBuffer;
+    positions: Float32Array;
+}>;

package/dist/v5/mesh-source-features.d.ts

@@ -0,0 +1,21 @@
+import type { MeshGeometry } from '@loaders.gl/schema';
+import type { GLTFPostprocessed, GLTFMeshPrimitivePostprocessed } from '@loaders.gl/gltf';
+import type { I3SMeshFeatures } from '@loaders.gl/i3s';
+import type { FeatureArrowBatchOptions } from './feature-arrow.js';
+/** Explicit source feature mapping; target type changes must be authorized separately. */
+export interface MeshSourceFeatureOptions extends FeatureArrowBatchOptions {
+    /** Batch-table class label, or the exact structural-metadata class to select. */
+    readonly metadataClass: string;
+    /** Optional source property providing stable identifiers; otherwise row indices are stable within the content. */
+    readonly sourceFeatureIdProperty?: string;
+    /** Explicit I3S representation for 64-bit integers; omission rejects those target fields. */
+    readonly integer64Encoding?: 'decimal-string';
+}
+/** Extracts legacy batch tables or one decoded modern property table and validates geometry ownership. */
+export declare function extractMeshFeatures(gltf: GLTFPostprocessed, primitive: GLTFMeshPrimitivePostprocessed, payload: {
+    batchTableJson?: Record<string, unknown>;
+    header?: {
+        batchLength?: number;
+    };
+    featureTableJson?: Record<string, unknown>;
+}, mesh: MeshGeometry, options?: MeshSourceFeatureOptions): I3SMeshFeatures | undefined;

package/dist/v5/mesh-source-texture.d.ts

@@ -0,0 +1,4 @@
+import type { GLTFMaterialPostprocessed } from '@loaders.gl/gltf';
+import type { MeshTileTexture } from './mesh.js';
+/** Maps a buffer-view or base64 PNG/JPEG image, sampling and UV transform without decoding pixels. */
+export declare function mapMeshSourceTexture(textureInfo: NonNullable<GLTFMaterialPostprocessed['pbrMetallicRoughness']>['baseColorTexture']): MeshTileTexture;

package/dist/v5/mesh-source.d.ts

@@ -0,0 +1,34 @@
+import type { Tileset3D, TilesetSourceMetadata } from '@loaders.gl/tiles';
+import type { TileConversionSource } from '@loaders.gl/tile-converter/v5/core';
+import type { TilesetConversionSourceOptions } from '@loaders.gl/tile-converter/v5/core';
+import type { MeshConversionInput } from './mesh-conversion.js';
+import type { MeshSourceFeatureOptions } from './mesh-source-features.js';
+import type { I3SMeshFeatures } from '@loaders.gl/i3s';
+export type { MeshSourceFeatureOptions } from './mesh-source-features.js';
+/** Source mesh with optional explicit-schema feature data and triangle association. */
+export interface MeshSourceResource extends MeshConversionInput {
+    /** Arrow features associated with the selected primitive; IDs are distinct from table row indices. */
+    readonly features?: I3SMeshFeatures;
+}
+/** Narrow source profile and content lifetime controls. */
+export interface MeshTilesetSourceOptions extends TilesetConversionSourceOptions {
+    /** Required when the source has batch/structural metadata; no schema is inferred. */
+    readonly features?: MeshSourceFeatureOptions;
+}
+/**
+ * Extracts static GLB/B3DM primitives from a native ECEF 3D Tiles runtime, including
+ * optional buffer-view or base64 data-URI PNG/JPEG images, TEXCOORD_0, glTF sampling and
+ * KHR_texture_transform controls on TEXCOORD_0. Decode content with
+ * `gltf.excludeExtensions: {KHR_texture_transform: false}` to retain authored UVs/transforms.
+ * Shared traversal retains placement identity and unloads content according to the supplied policy.
+ * The adapter applies node transforms, glTF up-axis correction, RTC translation, and tile placement
+ * once, retaining Float64 absolute positions and inverse-transpose unit normals. Animation, skins,
+ * morphs, instancing, broader texture semantics, unknown extensions, non-affine/mirrored
+ * placements, and
+ * metadata outside the declared feature profile fail explicitly. Multiple resources can be read;
+ * the single-mesh I3S sink rejects a second resource and aborts the entire output.
+ * @param tileset - Dedicated native EPSG:4978 runtime with decoded glTF content enabled.
+ * @param options - Explicit feature schema/mapping and optional decoded-content cleanup.
+ * @returns Portable conversion source; COLOR_0 is preserved for GLB, while I3S rejects vertex colors.
+ */
+export declare function createMeshTilesetConversionSource(tileset: Tileset3D, options?: MeshTilesetSourceOptions): TileConversionSource<TilesetSourceMetadata, MeshSourceResource>;

package/dist/v5/mesh-tileset-archive.d.ts

@@ -0,0 +1,18 @@
+import type { BrowserTileConversionFile } from '@loaders.gl/tile-converter/v5/core';
+/** Output-size budget for a single-mesh 3TZ archive. */
+export interface SingleMeshTilesetArchiveOptions {
+    /** Maximum final archive bytes, including ZIP headers and index; not peak serialization memory. */
+    readonly maxArchiveBytes: number;
+    /** Cooperative packaging cancellation; active Blob reads and entry encodes finish first. */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Packages the two unmodified files from a finalized single-mesh sink as a downloadable 3TZ Blob.
+ * The writer checks the complete archive budget before reading either Blob. Applications own
+ * object-URL creation/revocation and download UI. Retained input Blobs and transient ZIP buffers
+ * are additional memory. SLPK requires separately authored I3S scene-layer resources.
+ * @param files - Files returned by a successfully finalized createSingleMeshTilesetSink.
+ * @param options - Required final archive-size budget.
+ * @returns An indexed 3TZ Blob; save with the .3tz extension.
+ */
+export declare function createSingleMeshTilesetArchive(files: readonly BrowserTileConversionFile[], options: SingleMeshTilesetArchiveOptions): Promise<Blob>;

package/dist/v5/mesh-tileset-sink.d.ts

@@ -0,0 +1,51 @@
+import type { TileConversionSink } from '@loaders.gl/tile-converter/v5/core';
+import type { BrowserTileConversionFile } from '@loaders.gl/tile-converter/v5/core';
+import type { EncodedMeshConversionResource } from './mesh-conversion.js';
+/** Limits and fidelity policy for one ECEF mesh tileset. */
+export interface SingleMeshTilesetSinkOptions {
+    /** Maximum combined UTF-8 tileset JSON and GLB Blob bytes retained by the sink. */
+    readonly maxTotalBytes: number;
+    /** Explicit geometric error in meters, including source error and position rounding. */
+    readonly geometricError: number;
+}
+/** A single-tile output package retained as two named browser-native Blobs. */
+export interface SingleMeshTilesetSink extends TileConversionSink<EncodedMeshConversionResource> {
+    /** Returns mesh.glb and tileset.json only after successful finalization; empty after abort. */
+    getFiles(): readonly BrowserTileConversionFile[];
+}
+/**
+ * Packages exactly one `createMeshConversionCodec` output as a 3D Tiles 1.1 tileset.
+ *
+ * Requires resolved EPSG:4978 output identified by the compact string, with ellipsoidal heights.
+ * The tile transform cancels the standard glTF y-up to z-up rotation and adds the ECEF origin.
+ * Bounds come from encoded local vertices, avoiding subtraction of large absolute coordinates.
+ * Fixed relative names keep the package deterministic. Save both files together or pass them to
+ * createSingleMeshTilesetArchive for 3TZ packaging. Applications own downloads, workers, and
+ * source-scene extraction.
+ * The byte limit bounds retained Blobs, not peak conversion/serialization memory. Input GLB and
+ * local bounds must be unmodified codec outputs; this sink does not independently validate GLB.
+ *
+ * @param options - Required retained-output budget and geometric error in meters.
+ * @returns A bounded sink that exposes files on finalization and clears them on abort.
+ */
+export declare function createSingleMeshTilesetSink(options: SingleMeshTilesetSinkOptions): SingleMeshTilesetSink;
+/** Limits for an explicit collection of independent ECEF mesh leaves. */
+export interface MeshTilesetSinkOptions extends SingleMeshTilesetSinkOptions {
+    /** Maximum mesh placements, including repeated content at distinct source placements. */
+    readonly maxMeshes: number;
+}
+/** Atomic mesh package with a contentless root and independently placed GLB leaves. */
+export interface MeshTilesetSink extends TileConversionSink<EncodedMeshConversionResource> {
+    /** Returns deterministically named GLBs and tileset JSON only after finalization. */
+    getFiles(): readonly BrowserTileConversionFile[];
+}
+/**
+ * Packages independent codec outputs as a bounded 3D Tiles 1.1 leaf collection.
+ * Each leaf retains its ECEF placement and encoded bounds; the contentless ADD root encloses
+ * all leaves. Its geometric error covers the enclosing diagonal; each leaf retains the
+ * supplied error. This authors a flat partial dataset, not the source LOD hierarchy. Callers must
+ * exclude overlapping parent/descendant LOD representations and provide a conservative error.
+ * Resource IDs identify placements, never output paths. Retained bytes include final JSON;
+ * maxMeshes bounds hierarchy metadata, while neither limit bounds peak conversion memory.
+ */
+export declare function createMeshTilesetSink(options: MeshTilesetSinkOptions): MeshTilesetSink;

package/dist/v5/mesh.d.ts

@@ -0,0 +1,81 @@
+import { GLTFScenegraph } from '@loaders.gl/gltf';
+import type { MeshGeometry } from '@loaders.gl/schema';
+/** Explicit glTF wrapping and filtering for the selected base-color image. */
+export interface MeshTileSampler {
+    /** Horizontal wrapping: CLAMP_TO_EDGE, MIRRORED_REPEAT, or REPEAT; omitted values use REPEAT. */
+    readonly wrapS?: 33071 | 33648 | 10497;
+    /** Vertical wrapping: CLAMP_TO_EDGE, MIRRORED_REPEAT, or REPEAT; omitted values use REPEAT. */
+    readonly wrapT?: 33071 | 33648 | 10497;
+    /** Magnification: NEAREST or LINEAR; omission leaves filtering to the renderer. */
+    readonly magFilter?: 9728 | 9729;
+    /** Minification: NEAREST, LINEAR, or a glTF mipmap filter; omission leaves filtering to the renderer. */
+    readonly minFilter?: 9728 | 9729 | 9984 | 9985 | 9986 | 9987;
+}
+/** Selected KHR_texture_transform controls for TEXCOORD_0. */
+export interface MeshTileTextureTransform {
+    /** Finite UV translation; omitted values use [0, 0]. */
+    readonly offset?: readonly [number, number];
+    /** Finite counterclockwise rotation in radians around the UV origin; omission uses 0. */
+    readonly rotation?: number;
+    /** Finite UV scale; zero and negative values are allowed, and omission uses [1, 1]. */
+    readonly scale?: readonly [number, number];
+}
+/** One already encoded base-color image using TEXCOORD_0. */
+export interface MeshTileTexture {
+    /** Encoded PNG/JPEG bytes; a typed array subview selects only its own bytes. */
+    readonly data: Uint8Array;
+    /** Declared image format, checked against the encoded header. */
+    readonly mimeType: 'image/png' | 'image/jpeg';
+    /** Optional wrapping/filtering; omission retains glTF's implicit sampler. */
+    readonly sampler?: MeshTileSampler;
+    /** Optional UV transform, preserved as a required KHR_texture_transform extension. */
+    readonly transform?: MeshTileTextureTransform;
+}
+/** One glTF metallic-roughness material, shared by every triangle in the mesh. */
+export interface MeshTileMaterial {
+    /** Linear RGBA base-color multiplier; components must be finite in [0, 1]. */
+    readonly baseColorFactor?: readonly [number, number, number, number];
+    /** Optional embedded image, multiplied by baseColorFactor and COLOR_0; requires TEXCOORD_0. */
+    readonly baseColorTexture?: MeshTileTexture;
+    /** Metallic weight in [0, 1]; omitted values use the glTF default of 1. */
+    readonly metallicFactor?: number;
+    /** Roughness weight in [0, 1]; omitted values use the glTF default of 1. */
+    readonly roughnessFactor?: number;
+    /** Alpha interpretation; omitted values use OPAQUE. */
+    readonly alphaMode?: 'OPAQUE' | 'MASK' | 'BLEND';
+    /** Finite nonnegative threshold, allowed only with MASK; omitted values use 0.5. */
+    readonly alphaCutoff?: number;
+    /** Whether both sides are rendered; omitted values use false. */
+    readonly doubleSided?: boolean;
+}
+/** Optional appearance for the single-mesh GLB profile. */
+export interface MeshTileOptions {
+    /** Explicitly selected material; other texture maps and material extensions are unsupported. */
+    readonly material?: MeshTileMaterial;
+}
+/**
+ * Encodes one triangle mesh as a self-contained glTF 2.0 GLB resource.
+ *
+ * POSITION and optional NORMAL must contain packed finite Float32 xyz triples. COLOR_0 accepts
+ * packed Float32 linear RGB/RGBA in [0, 1] or normalized Uint8/Uint16 colors per vertex.
+ * Normals must have unit length within 0.0001. TEXCOORD_0 accepts packed finite Float32
+ * or normalized Uint8/Uint16 UV pairs per vertex. Optional indices use packed unsigned
+ * 8-, 16-, or 32-bit values.
+ * Unsupported attributes, layouts, and encoded transforms fail rather than being discarded.
+ * Coordinates are preserved: callers own CRS conversion, local origins, placement, source material mapping,
+ * feature mappings, and tileset packaging. Input arrays are never modified.
+ *
+ * @param mesh - Triangle-list geometry in the caller's selected local coordinate frame.
+ * @param options - Optional single material with an already encoded base-color image.
+ * @returns An embedded-buffer GLB containing one mesh, node, and default scene.
+ */
+export declare function encodeMeshTile(mesh: MeshGeometry, options?: MeshTileOptions): ArrayBuffer;
+/** Creates the shared material/image scene without allocating uncompressed geometry buffers. */
+export declare function createMeshTileScenegraph(options: MeshTileOptions, geometry: MeshGeometry): {
+    scenegraph: GLTFScenegraph;
+    materialIndex: number | undefined;
+};
+/** Adds placement-neutral nodes and serializes the single-mesh scene as GLB. */
+export declare function finalizeMeshTileScenegraph(scenegraph: GLTFScenegraph, meshIndex: number): ArrayBuffer;
+/** Validates the shared mesh profile; spatial preparation may retain Float64 positions internally. */
+export declare function validateMeshGeometry(mesh: MeshGeometry, allowFloat64Positions?: boolean): MeshGeometry;

package/dist/v5/point-cloud-conversion.d.ts

@@ -0,0 +1,31 @@
+import type { PointCloudTilesetSource } from '@loaders.gl/tiles';
+import type { TileConversionProgress, TileConversionReport, TileConversionSink } from '@loaders.gl/tile-converter/v5/core';
+import type { PointCloudSourceTile } from '@loaders.gl/tile-converter/v5/core';
+import type { EncodedPointCloudSourceTile, EncodePointCloudSourceOptions } from './point-cloud-source-encoder.js';
+/** Point-cloud encoding options and an application-owned output destination. */
+export interface ConvertPointCloudSourceOptions extends EncodePointCloudSourceOptions {
+    /** Destination receiving PNTS resources and their source placement metadata. */
+    readonly sink: TileConversionSink<EncodedPointCloudSourceTile>;
+    /** Input byte accounting for each visited source tile, including tiles with null content. */
+    readonly measureInputBytes: (sourceTile: PointCloudSourceTile) => number;
+    /** Maximum caller-measured bytes in one decoded source tile, checked before PNTS encoding. */
+    readonly maxInputResourceBytes?: number;
+    /** Maximum bytes in one encoded PNTS resource. Defaults to no limit. */
+    readonly maxOutputResourceBytes?: number;
+    /** Receive conversion progress, including resource counts and caller-measured input bytes. */
+    readonly onProgress?: (progress: TileConversionProgress) => void;
+}
+/**
+ * Converts a point-cloud source to PNTS resources through the v5 output-sink lifecycle.
+ *
+ * Each write is awaited before reading the next source tile. The destination is finalized only
+ * after traversal and writes succeed, and aborted on read, encoding, write, or cancellation errors.
+ * Input resource counts include empty tiles; output counts and byte sizes describe emitted PNTS
+ * resources. Applications supply input byte accounting because source tiles contain decoded Arrow
+ * data rather than transport bytes. The caller retains ownership of the input source.
+ *
+ * @param source - An I3S, COPC, or compatible point-cloud source to initialize and traverse.
+ * @param options - Destination, byte accounting, traversal limits, and per-tile encoding options.
+ * @returns The shared v5 conversion report after destination finalization.
+ */
+export declare function convertPointCloudSource(source: PointCloudTilesetSource, options: ConvertPointCloudSourceOptions): Promise<TileConversionReport>;

package/dist/v5/point-cloud-source-encoder.d.ts

@@ -0,0 +1,49 @@
+import type { PointCloudBoundingVolume, PointCloudCoordinateSystem, PointCloudTilesetSource, TilesetSpatialReference } from '@loaders.gl/tiles';
+import type { EncodePointCloudTileOptions } from './point-cloud.js';
+import type { PointCloudSourceTile, TraversePointCloudSourceOptions } from '@loaders.gl/tile-converter/v5/core';
+/** Traversal and per-tile encoding options for a point-cloud source. */
+export type EncodePointCloudSourceOptions = TraversePointCloudSourceOptions & {
+    /** Select encoder options for each source tile with content, using its header and decoded data. */
+    readonly getTileEncodingOptions?: (sourceTile: PointCloudSourceTile) => EncodePointCloudTileOptions;
+};
+/** A PNTS resource paired with the source placement metadata needed to package its tile. */
+export type EncodedPointCloudSourceTile = {
+    /** Stable source tile identifier. */
+    readonly id: string;
+    /** Original source hierarchy and bounds. */
+    readonly header: PointCloudSourceTile['header'];
+    /** Encoded point-cloud tile content. */
+    readonly pnts: ArrayBuffer;
+    /** Number of point records encoded. */
+    readonly pointCount: number;
+    /** Coordinate system used by the returned point positions. */
+    readonly coordinateSystem: PointCloudCoordinateSystem;
+    /** Origin to add to source-relative point positions. */
+    readonly cartographicOrigin: readonly number[];
+    /** Optional placement transform supplied by the point-cloud source. */
+    readonly modelMatrix?: readonly number[];
+    /** Optional source or target CRS metadata. */
+    readonly spatialReference?: TilesetSpatialReference;
+    /** Optional output-frame tile bounds supplied by the source. */
+    readonly spatialBoundingVolume?: PointCloudBoundingVolume;
+};
+/**
+ * Encodes a point-cloud source as a stream of PNTS resources, one for each non-empty source tile.
+ *
+ * @param source - An I3S, COPC, or compatible point-cloud tileset source.
+ * @param options - Optional traversal depth limit, cancellation signal, and per-tile encoder options.
+ * @returns Encoded source tiles in deterministic depth-first order.
+ */
+export declare function encodePointCloudSource(source: PointCloudTilesetSource, options?: EncodePointCloudSourceOptions): AsyncIterableIterator<EncodedPointCloudSourceTile>;
+/**
+ * Encodes one decoded source tile as PNTS and retains its hierarchy and placement metadata.
+ *
+ * Positions use the source coordinate system, with an optional RTC center subtracted before float32
+ * encoding and stored in the PNTS feature table. Source placement metadata is retained so callers
+ * can assemble the output tileset. This function does not transform the source CRS.
+ *
+ * @param sourceTile - Tile header and decoded Arrow point content from `traversePointCloudSource`.
+ * @param options - Optional RTC center, batch-table values, and constant color override.
+ * @returns An encoded source tile, or null when the source tile has no content.
+ */
+export declare function encodePointCloudSourceTile(sourceTile: PointCloudSourceTile, options?: EncodePointCloudTileOptions): EncodedPointCloudSourceTile | null;

package/dist/v5/point-cloud-source.d.ts

@@ -0,0 +1,25 @@
+import type { PointCloudTileContent, PointCloudTileHeader, PointCloudTilesetSource } from '@loaders.gl/tiles';
+/** A source tile and its decoded point content, including null content when no payload exists. */
+export type PointCloudSourceTile = {
+    /** Header with the source tile's hierarchy, bounds, and LOD metadata. */
+    readonly header: PointCloudTileHeader;
+    /** Arrow point data and its coordinate metadata, or null for an empty tile. */
+    readonly content: PointCloudTileContent | null;
+};
+/** Options for camera-independent point-cloud source traversal. */
+export type TraversePointCloudSourceOptions = {
+    /** Stop descending after this source tile level. Defaults to the complete hierarchy. */
+    readonly maxDepth?: number;
+    /** Cancel traversal between source operations. */
+    readonly signal?: AbortSignal;
+};
+/**
+ * Reads a point-cloud source in deterministic depth-first order, independent of a render camera.
+ * Each yielded value retains its tile header and Arrow content metadata so callers can apply the
+ * source coordinate frame and placement when encoding output tiles.
+ *
+ * @param source - An I3S, COPC, or compatible point-cloud tileset source.
+ * @param options - Optional depth limit and cancellation signal.
+ * @returns One header and decoded payload for each reachable source tile.
+ */
+export declare function traversePointCloudSource(source: PointCloudTilesetSource, options?: TraversePointCloudSourceOptions): AsyncIterableIterator<PointCloudSourceTile>;