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

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,32 @@
+import type { EncodedI3SMeshLayer, I3SMeshWriterOptions, I3SDracoLibraryOptions } from '@loaders.gl/i3s';
+import type { TileConversionCodec, TileConversionSink } from '@loaders.gl/tile-converter/v5/core';
+import type { Tiles3DConversionSpatialContext, I3SConversionSpatialContext } 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 | I3SConversionSpatialContext;
+    /** I3S vector frame when using an I3S context; defaults to earth-centered. */
+    readonly normalReferenceFrame?: 'earth-centered' | 'vertex-reference-frame';
+    /** Lossless Edge Breaker geometry by default; false retains raw I3S geometry. */
+    readonly draco?: boolean;
+    /** Full Draco encoder/decoder runtime URLs or injected modules. */
+    readonly dracoLibraryOptions?: I3SDracoLibraryOptions;
+}
+/** 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> {
+    /** Archive-relative geometry, metadata and images 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/i3s-mesh-sink.d.ts

@@ -0,0 +1,25 @@
+import type { BrowserTileConversionFile, TileConversionSink } from '@loaders.gl/tile-converter/v5/core';
+import type { I3SMeshConversionResource } from './i3s-mesh-conversion.js';
+/** Bounded flat collection of mesh nodes sharing one I3S feature/geometry schema. */
+export interface I3SMeshSinkOptions {
+    /** Maximum compressed bytes retained, including final layer/index metadata. */
+    readonly maxTotalBytes: number;
+    /** Maximum primitive placements, from one through 64. */
+    readonly maxMeshes: number;
+    /** Maximum decompressed or generated metadata/attribute resource bytes. */
+    readonly maxResourceBytes: number;
+}
+/** Atomic multi-mesh I3S output, ready for portable SLPK packaging. */
+export interface I3SMeshSink extends TileConversionSink<I3SMeshConversionResource> {
+    /** Finalized files only; failed or unfinished conversion exposes no output. */
+    getFiles(): readonly BrowserTileConversionFile[];
+}
+/**
+ * Combines independently authored mesh resources into one flat I3S layer.
+ * Leaves retain geographic placements, compressed geometry and attributes. A shared schema is
+ * required; generated object IDs must be disjoint (the conversion codec allocates them).
+ * Finalization rebuilds legacy indices, paged indices and enclosing ECEF bounds, including a
+ * second page for the 64th leaf. No source LOD hierarchy is implied. Byte gates bound retained
+ * resources and metadata, not peak decoder/compressor memory.
+ */
+export declare function createI3SMeshSink(options: I3SMeshSinkOptions): I3SMeshSink;

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

@@ -0,0 +1,13 @@
+import type { I3STileContent, I3SMeshFeatures } from '@loaders.gl/i3s';
+import type { TilesetContentTraversalItem, TilesetSourceMetadata } from '@loaders.gl/tiles';
+import type { MeshSourceFeatureOptions } from './mesh-source-features.js';
+import type { MeshTilesetSourceOptions } from './mesh-source.js';
+/** Explicit mapping of scalar I3S attribute resources and their geometry identifiers. */
+export interface I3SMeshSourceFeatureOptions extends MeshSourceFeatureOptions {
+    /** Attribute column whose exact integer values identify the decoded geometry. */
+    readonly objectIdProperty: string;
+    /** Aggregate encoded attribute byte limit for each node, checked before parsing. */
+    readonly maxAttributeBytes: number;
+}
+/** Reads exact scalar/string columns and constructs complete triangle-to-Arrow-row ownership. */
+export declare function extractI3SMeshFeatures(content: I3STileContent, item: TilesetContentTraversalItem, metadata: TilesetSourceMetadata, options: I3SMeshSourceFeatureOptions, readExternalResource: MeshTilesetSourceOptions['readExternalResource'], contentUri: string | undefined, signal?: AbortSignal): Promise<I3SMeshFeatures>;

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

@@ -0,0 +1,5 @@
+import type { I3STileContent, I3STileHeader } from '@loaders.gl/i3s';
+import type { MeshTilesetSourceOptions } from './mesh-source.js';
+import type { MeshTileMaterial } from './mesh.js';
+/** Maps normalized I3S factors and one encoded base-color PNG/JPEG with explicit wrapping. */
+export declare function mapI3SMeshSourceMaterial(content: I3STileContent, header: Partial<I3STileHeader>, readExternalResource: MeshTilesetSourceOptions['readExternalResource'], contentUri: string | undefined, signal?: AbortSignal): Promise<MeshTileMaterial | undefined>;

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

@@ -0,0 +1,30 @@
+import type { I3STileContent, I3SMeshFeatures } from '@loaders.gl/i3s';
+import type { Tileset3D, TilesetSourceMetadata, TilesetContentTraversalItem } from '@loaders.gl/tiles';
+import type { TileConversionSource, TilesetConversionSourceOptions } from '@loaders.gl/tile-converter/v5/core';
+import type { MeshSourceResource } from './mesh-source.js';
+import type { MeshTilesetSourceOptions } from './mesh-source.js';
+import type { I3SMeshSourceFeatureOptions } from './i3s-mesh-source-features.js';
+export type { I3SMeshSourceFeatureOptions } from './i3s-mesh-source-features.js';
+/** Selected I3S triangle, encoded base-color appearance and explicit-schema feature profile. */
+export interface I3SMeshTilesetSourceOptions extends TilesetConversionSourceOptions {
+    /** Read scalar/string attribute resources with an explicit schema and geometry OID mapping. */
+    readonly features?: I3SMeshSourceFeatureOptions;
+    /** Application-owned bounded reader, including archive resolution, authentication and decompression. */
+    readonly readExternalResource?: MeshTilesetSourceOptions['readExternalResource'];
+    /** Custom alternative to features, for source semantics outside the scalar resource profile. */
+    readonly getFeatures?: (content: I3STileContent, item: TilesetContentTraversalItem, metadata: TilesetSourceMetadata, signal?: AbortSignal) => I3SMeshFeatures | Promise<I3SMeshFeatures>;
+}
+/**
+ * Reads original absolute I3S positions through camera-independent traversal.
+ * Use a dedicated runtime with i3s.geometryMode='source'. The shared I3S spatial codec owns
+ * units, elevation and reprojection; this source never consumes renderer placement matrices.
+ * Pair the GLB codec with autoOrigin=true, or select an explicit target origin on the resources.
+ * Positions/normals/TEXCOORD_0, basic PBR factors and one encoded PNG/JPEG base-color texture
+ * are supported. Vertex colors, UV regions, additional attributes and segmentation fail explicitly.
+ * Features require an explicit schema/resource reader or a custom Arrow mapper.
+ * Unsafe decoded numeric geometry identifiers are rejected; exact property IDs use bigint.
+ * @param tileset - Dedicated I3S runtime using source-coordinate content decoding.
+ * @param options - Feature mapping and lifetime policy for content loaded during traversal.
+ * @returns A portable source of one absolute mesh per I3S node content.
+ */
+export declare function createI3SMeshTilesetConversionSource(tileset: Tileset3D, options?: I3SMeshTilesetSourceOptions): TileConversionSource<TilesetSourceMetadata, MeshSourceResource>;

package/dist/v5/index.cjs

@@ -0,0 +1,73 @@
+"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,
+  createI3SMeshSink: () => import_adapters12.createI3SMeshSink,
+  createI3SMeshTilesetConversionSource: () => import_adapters15.createI3SMeshTilesetConversionSource,
+  createManifestBackedTileConversionSink: () => import_core5.createManifestBackedTileConversionSink,
+  createMeshConversionCodec: () => import_adapters6.createMeshConversionCodec,
+  createMeshTilesetConversionSource: () => import_adapters10.createMeshTilesetConversionSource,
+  createPointCloudTilesetSink: () => import_adapters13.createPointCloudTilesetSink,
+  createSingleMeshI3SSink: () => import_adapters11.createSingleMeshI3SSink,
+  createSingleMeshTilesetArchive: () => import_adapters9.createSingleMeshTilesetArchive,
+  createSingleMeshTilesetSink: () => import_adapters7.createSingleMeshTilesetSink,
+  createTileConversionArchive: () => import_adapters8.createTileConversionArchive,
+  createTileConversionResourceFetcher: () => import_adapters12.createTileConversionResourceFetcher,
+  createTiles3DConversionSpatialContext: () => import_core3.createTiles3DConversionSpatialContext,
+  createTilesetConversionSource: () => import_core2.createTilesetConversionSource,
+  encodeMeshTile: () => import_adapters5.encodeMeshTile,
+  encodePointCloudSource: () => import_adapters3.encodePointCloudSource,
+  encodePointCloudSourceTile: () => import_adapters3.encodePointCloudSourceTile,
+  encodePointCloudTile: () => import_adapters2.encodePointCloudTile,
+  encodePointCloudTileWithMetadata: () => import_adapters2.encodePointCloudTileWithMetadata,
+  encodeTileConversionArchiveInBatches: () => import_adapters8.encodeTileConversionArchiveInBatches,
+  inspectTileset: () => import_core.inspectTileset,
+  transformPointCloudSourceTile: () => import_adapters14.transformPointCloudSourceTile,
+  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");
+var import_adapters12 = require("@loaders.gl/tile-converter/v5/adapters");
+var import_adapters13 = require("@loaders.gl/tile-converter/v5/adapters");
+var import_adapters14 = require("@loaders.gl/tile-converter/v5/adapters");
+var import_adapters15 = require("@loaders.gl/tile-converter/v5/adapters");

package/dist/v5/index.d.ts

@@ -0,0 +1,40 @@
+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, encodePointCloudTileWithMetadata } from '@loaders.gl/tile-converter/v5/adapters';
+export type { EncodePointCloudTileOptions, EncodedPointCloudTile } 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';
+export { createI3SMeshSink, createTileConversionResourceFetcher } from '@loaders.gl/tile-converter/v5/adapters';
+export type { I3SMeshSink, I3SMeshSinkOptions, TileConversionResourceFetcherOptions, MeshTileFeatures } from '@loaders.gl/tile-converter/v5/adapters';
+export { createPointCloudTilesetSink } from '@loaders.gl/tile-converter/v5/adapters';
+export type { PointCloudTilesetSink, PointCloudTilesetSinkOptions } from '@loaders.gl/tile-converter/v5/adapters';
+export { transformPointCloudSourceTile } from '@loaders.gl/tile-converter/v5/adapters';
+export type { PointCloudSpatialOptions } from '@loaders.gl/tile-converter/v5/adapters';
+export { createI3SMeshTilesetConversionSource } from '@loaders.gl/tile-converter/v5/adapters';
+export type { I3SMeshTilesetSourceOptions, I3SMeshSourceFeatureOptions } from '@loaders.gl/tile-converter/v5/adapters';

package/dist/v5/index.js

@@ -0,0 +1,75 @@
+// 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,
+  encodePointCloudTileWithMetadata
+} 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";
+import {
+  createI3SMeshSink,
+  createTileConversionResourceFetcher
+} from "@loaders.gl/tile-converter/v5/adapters";
+import { createPointCloudTilesetSink } from "@loaders.gl/tile-converter/v5/adapters";
+import { transformPointCloudSourceTile } from "@loaders.gl/tile-converter/v5/adapters";
+import { createI3SMeshTilesetConversionSource } from "@loaders.gl/tile-converter/v5/adapters";
+export {
+  TileConversionError,
+  convertFeatureAttributesToArrowBatches,
+  convertPointCloudSource,
+  convertTileset,
+  createI3SConversionSpatialContext,
+  createI3SMeshConversionCodec,
+  createI3SMeshSink,
+  createI3SMeshTilesetConversionSource,
+  createManifestBackedTileConversionSink,
+  createMeshConversionCodec,
+  createMeshTilesetConversionSource,
+  createPointCloudTilesetSink,
+  createSingleMeshI3SSink,
+  createSingleMeshTilesetArchive,
+  createSingleMeshTilesetSink,
+  createTileConversionArchive,
+  createTileConversionResourceFetcher,
+  createTiles3DConversionSpatialContext,
+  createTilesetConversionSource,
+  encodeMeshTile,
+  encodePointCloudSource,
+  encodePointCloudSourceTile,
+  encodePointCloudTile,
+  encodePointCloudTileWithMetadata,
+  encodeTileConversionArchiveInBatches,
+  inspectTileset,
+  transformPointCloudSourceTile,
+  traversePointCloudSource,
+  validateTileset
+};

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

@@ -0,0 +1,71 @@
+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, I3SConversionSpatialContext } from '@loaders.gl/tile-converter/v5/core';
+import type { MeshTileFeatures } from './mesh-features.js';
+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;
+    /** Original I3S vector basis; overrides the codec default when supplied by a source. */
+    readonly normalReferenceFrame?: 'earth-centered' | 'vertex-reference-frame';
+    /** Optional single material with an embedded base-color image, mapped explicitly by the source adapter. */
+    readonly material?: MeshTileMaterial;
+    /** Explicit feature table and triangle associations, written as structural metadata. */
+    readonly features?: MeshTileFeatures;
+    /** 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 | I3SConversionSpatialContext;
+    /** I3S vector frame when using an I3S context; defaults to earth-centered. */
+    readonly normalReferenceFrame?: 'earth-centered' | 'vertex-reference-frame';
+    /** Rebase around the transformed bounds center instead of the resource's explicit origin. */
+    readonly autoOrigin?: boolean;
+    /** 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-features.d.ts

@@ -0,0 +1,9 @@
+import type { MeshGeometry } from '@loaders.gl/schema';
+import type { GLTFScenegraph } from '@loaders.gl/gltf';
+import type { I3SMeshFeatures } from '@loaders.gl/i3s';
+/** Explicit-schema Arrow features; stable identifiers are distinct from geometry row indices. */
+export type MeshTileFeatures = Pick<I3SMeshFeatures, 'batches' | 'triangleFeatureIndices' | 'featureIdField'>;
+/** Expands shared vertices so each complete triangle retains its own feature row through Draco. */
+export declare function prepareMeshFeatureGeometry(mesh: MeshGeometry, features?: MeshTileFeatures): MeshGeometry;
+/** Writes one inline structural metadata table without number coercion or nullable sentinel collisions. */
+export declare function encodeMeshFeatures(scenegraph: GLTFScenegraph, meshIndex: number, features?: MeshTileFeatures): void;

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,6 @@
+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;
+/** Resolves one external encoded image through an explicitly supplied application reader. */
+export declare function resolveMeshSourceTexture(textureInfo: NonNullable<GLTFMaterialPostprocessed['pbrMetallicRoughness']>['baseColorTexture'], readExternalResource: ((uri: string, contentUri: string | undefined, signal?: AbortSignal) => Promise<Uint8Array>) | undefined, contentUri: string | undefined, signal?: AbortSignal): Promise<MeshTileTexture>;

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

@@ -0,0 +1,41 @@
+import type { GLTFMaterialPostprocessed } from '@loaders.gl/gltf';
+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 { MeshTileMaterial } from './mesh.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;
+    /** Explicit bounded reader for external encoded images, relative to the content URI. */
+    readonly readExternalResource?: (uri: string, contentUri: string | undefined, signal?: AbortSignal) => Promise<Uint8Array>;
+}
+/**
+ * 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.
+ * Triangle strips are expanded with alternating winding; the glTF loader already expands fans.
+ * 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;
+ * collection sinks accept bounded multiple placements; the compatibility single-mesh sink rejects a second resource.
+ * @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>;
+/** Maps supported PBR controls and an embedded base-color image, rejecting unmapped semantics. */
+export declare function mapMeshSourceMaterial(material: GLTFMaterialPostprocessed | undefined, readExternalResource: MeshTilesetSourceOptions['readExternalResource'], contentUri: string | undefined, signal?: AbortSignal): Promise<MeshTileMaterial | undefined>;

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;