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

package/dist/v5/browser-sink.d.ts

@@ -0,0 +1,37 @@
+import type { TileConversionSink } from './conversion-api.js';
+/** 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 declare function createBoundedMemoryTileConversionSink(options: BoundedMemoryTileConversionSinkOptions): BoundedMemoryTileConversionSink;

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

@@ -0,0 +1,38 @@
+import type { TileConversionSource } from './conversion-api.js';
+/** Metadata available before a browser resource is read. */
+export interface BrowserTileConversionInspection {
+    /** Stable resource path assigned to the input tile. */
+    readonly resourceId: string;
+    /** Optional MIME type supplied by the caller or source Blob. */
+    readonly contentType?: string;
+}
+/** Raw bytes read from one browser tile resource. */
+export interface BrowserTileConversionInputResource {
+    /** Stable resource path assigned to the input tile. */
+    readonly resourceId: string;
+    /** Complete resource bytes for a profile-specific codec. */
+    readonly data: Uint8Array;
+    /** Optional MIME type supplied by the caller, Blob, or URL response. */
+    readonly contentType?: string;
+}
+/** Browser input and size limit for a single-resource conversion. */
+export interface BrowserTileConversionSourceOptions {
+    /** Input URL or already available browser Blob. */
+    readonly input: string | Blob;
+    /** Stable path to associate with the input resource. */
+    readonly resourceId: string;
+    /** Maximum number of input bytes held in memory. */
+    readonly maxInputBytes: number;
+    /** Optional MIME type override. */
+    readonly contentType?: string;
+}
+/**
+ * Creates a browser source for one mesh resource provided as a URL or Blob.
+ *
+ * URL responses are read incrementally and canceled if they exceed `maxInputBytes`.
+ * Tileset JSON traversal and format decoding remain profile-specific source and codec work.
+ *
+ * @param options - Input, stable resource ID, and maximum input size.
+ * @returns A source that yields one complete resource to a v5 codec.
+ */
+export declare function createBrowserTileConversionSource(options: BrowserTileConversionSourceOptions): TileConversionSource<BrowserTileConversionInspection, BrowserTileConversionInputResource>;

package/dist/v5/browser-tileset-source.d.ts

@@ -0,0 +1,70 @@
+import type { TileConversionSource } from './conversion-api.js';
+type TilesetContent = {
+    uri?: string;
+    url?: string;
+};
+type TilesetTile = {
+    content?: TilesetContent;
+    contents?: TilesetContent[];
+    children?: TilesetTile[];
+    transform?: number[];
+    implicitTiling?: unknown;
+    extensions?: Record<string, unknown>;
+};
+type TilesetDocument = {
+    asset?: {
+        version?: string;
+    };
+    root?: TilesetTile;
+};
+/** Input options for bounded traversal of one explicit 3D Tiles tileset. */
+export interface BrowserTilesetConversionSourceOptions {
+    /** URL of the root tileset JSON document. */
+    readonly input: string;
+    /** Maximum bytes retained across the tileset JSON and all content resources. */
+    readonly maxInputBytes: number;
+    /** Maximum number of content resources to visit. */
+    readonly maxInputResources: number;
+    /** Fetch implementation, defaulting to the browser global. */
+    readonly fetcher?: typeof fetch;
+}
+/** Inspection result for an explicit 3D Tiles source. */
+export interface BrowserTilesetConversionInspection {
+    /** Absolute URL of the root tileset document. */
+    readonly rootUrl: string;
+    /** Parsed root document used for deterministic content traversal. */
+    readonly tileset: TilesetDocument;
+    /** Ordered content descriptors. */
+    readonly resources: readonly BrowserTilesetResourceDescriptor[];
+    /** Root document bytes charged against the input limit. */
+    readonly tilesetBytes: number;
+}
+/** Placement metadata for one ordered content resource. */
+export interface BrowserTilesetResourceDescriptor {
+    /** Unique, stable path for this content placement. */
+    readonly resourceId: string;
+    /** Original URI declared by the tileset. */
+    readonly uri: string;
+    /** Tile child indexes from the tileset root. */
+    readonly tilePath: readonly number[];
+    /** Combined root-to-tile transform in column-major order. */
+    readonly transform: readonly number[];
+}
+/** One raw content resource from a browser-readable explicit tileset. */
+export interface BrowserTilesetConversionInputResource extends BrowserTilesetResourceDescriptor {
+    /** Complete content bytes for an injected profile-specific codec. */
+    readonly data: Uint8Array;
+    /** Optional content type reported by the response. */
+    readonly contentType?: string;
+}
+/**
+ * Creates a bounded browser source for explicit 3D Tiles 1.0 and 1.1 tilesets.
+ *
+ * Traversal visits each declared content placement once in depth-first order. Implicit tiling and
+ * nested external tilesets are rejected; content decoding and conversion remain codec work.
+ *
+ * @param options - Tileset URL and aggregate byte and resource limits.
+ * @returns A source yielding ordered raw tile resources with placement transforms.
+ */
+export declare function createBrowserTilesetConversionSource(options: BrowserTilesetConversionSourceOptions): TileConversionSource<BrowserTilesetConversionInspection, BrowserTilesetConversionInputResource>;
+export {};

package/dist/v5/browser.cjs

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

package/dist/v5/browser.d.ts

@@ -0,0 +1,34 @@
+export { convertTileset, inspectTileset, TileConversionError, validateTileset } 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 type { ConvertTilesetOptions, TileConversionCodec, TileConversionDiagnostic, TileConversionProgress, TileConversionReport, TileConversionSink, TileConversionSource, TileValidationReport, ValidateTilesetOptions } from '@loaders.gl/tile-converter/v5/core';
+export { createBoundedMemoryTileConversionSink } from '@loaders.gl/tile-converter/v5/core';
+export { createBrowserTileConversionSource } from '@loaders.gl/tile-converter/v5/core';
+export type { BoundedMemoryTileConversionSink, BoundedMemoryTileConversionSinkOptions, BrowserTileConversionFile, BrowserTileConversionResource } from '@loaders.gl/tile-converter/v5/core';
+export type { BrowserTileConversionInspection, BrowserTileConversionInputResource, BrowserTileConversionSourceOptions } from '@loaders.gl/tile-converter/v5/core';
+export { createBrowserTilesetConversionSource } from '@loaders.gl/tile-converter/v5/core';
+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 type { BrowserTilesetConversionInputResource, BrowserTilesetConversionInspection, BrowserTilesetConversionSourceOptions, BrowserTilesetResourceDescriptor } 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 { createTiles3DConversionSpatialContext } from '@loaders.gl/tile-converter/v5/core';
+export type { Tiles3DConversionSpatialContext } from '@loaders.gl/tile-converter/v5/core';
+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/browser.js

@@ -0,0 +1,57 @@
+// src/v5/browser.ts
+import {
+  convertTileset,
+  inspectTileset,
+  TileConversionError,
+  validateTileset
+} from "@loaders.gl/tile-converter/v5/core";
+import { createTilesetConversionSource } from "@loaders.gl/tile-converter/v5/core";
+import { createBoundedMemoryTileConversionSink } from "@loaders.gl/tile-converter/v5/core";
+import { createBrowserTileConversionSource } from "@loaders.gl/tile-converter/v5/core";
+import { createBrowserTilesetConversionSource } from "@loaders.gl/tile-converter/v5/core";
+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 { encodeMeshTile } from "@loaders.gl/tile-converter/v5/adapters";
+import { createMeshConversionCodec } from "@loaders.gl/tile-converter/v5/adapters";
+import { createTiles3DConversionSpatialContext } from "@loaders.gl/tile-converter/v5/core";
+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,
+  convertPointCloudSource,
+  convertTileset,
+  createBoundedMemoryTileConversionSink,
+  createBrowserTileConversionSource,
+  createBrowserTilesetConversionSource,
+  createI3SMeshConversionCodec,
+  createMeshConversionCodec,
+  createMeshTilesetConversionSource,
+  createSingleMeshI3SSink,
+  createSingleMeshTilesetArchive,
+  createSingleMeshTilesetSink,
+  createTileConversionArchive,
+  createTiles3DConversionSpatialContext,
+  createTilesetConversionSource,
+  encodeMeshTile,
+  encodePointCloudSource,
+  encodePointCloudSourceTile,
+  encodePointCloudTile,
+  encodeTileConversionArchiveInBatches,
+  inspectTileset,
+  traversePointCloudSource,
+  validateTileset
+};

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

@@ -0,0 +1,122 @@
+/** A diagnostic produced while inspecting, converting, or validating tiles. */
+export interface TileConversionDiagnostic {
+    /** Stable machine-readable diagnostic code. */
+    readonly code: string;
+    /** Human-readable explanation of the diagnostic. */
+    readonly message: string;
+    /** Severity used by callers to decide whether the result is acceptable. */
+    readonly severity: 'info' | 'warning' | 'error';
+    /** Optional resource that produced the diagnostic. */
+    readonly resourceId?: string;
+}
+/** Typed failure raised when a conversion policy or validation gate rejects a resource. */
+export declare class TileConversionError extends Error {
+    /** Stable machine-readable failure code. */
+    readonly code: string;
+    /** Diagnostics associated with this failure. */
+    readonly diagnostics: readonly TileConversionDiagnostic[];
+    /** Creates a typed conversion failure. */
+    constructor(code: string, message: string, diagnostics?: readonly TileConversionDiagnostic[]);
+}
+/** Progress reported by the portable conversion core. */
+export interface TileConversionProgress {
+    /** Current conversion phase. */
+    readonly phase: 'inspect' | 'convert' | 'validate' | 'finalize';
+    /** Number of input resources consumed so far. */
+    readonly inputResources: number;
+    /** Number of output resources written so far. */
+    readonly outputResources: number;
+    /** Number of input bytes consumed so far. */
+    readonly inputBytes: number;
+    /** Number of output bytes written so far. */
+    readonly outputBytes: number;
+}
+/** Summary returned after a tileset conversion completes. */
+export interface TileConversionReport {
+    /** Completed conversion state. Failed conversions reject with their cause. */
+    readonly state: 'completed';
+    /** Number of input resources consumed. */
+    readonly inputResources: number;
+    /** Number of output resources written. */
+    readonly outputResources: number;
+    /** Number of input bytes consumed. */
+    readonly inputBytes: number;
+    /** Number of output bytes written. */
+    readonly outputBytes: number;
+    /** Largest output resource written. */
+    readonly largestOutputResourceBytes: number;
+    /** Diagnostics reported during conversion and validation. */
+    readonly diagnostics: readonly TileConversionDiagnostic[];
+}
+/** Portable source adapter that resolves and reads a tileset. */
+export interface TileConversionSource<TInspection, TInput> {
+    /** Inspect the source and return its profile-specific metadata. */
+    inspect(signal?: AbortSignal): Promise<TInspection>;
+    /** Stream input resources in deterministic traversal order. */
+    read(inspection: TInspection, signal?: AbortSignal): AsyncIterable<TInput>;
+}
+/** Output adapter whose awaited writes apply backpressure to conversion. */
+export interface TileConversionSink<TOutput> {
+    /** Write one completed output resource and resolve when it can be released. */
+    write(resource: TOutput, signal?: AbortSignal): Promise<void>;
+    /** Finalize the destination after every resource has been written. */
+    finalize(report: TileConversionReport): Promise<void>;
+    /** Abort and clean up a partial destination after a failure. */
+    abort(reason: unknown): Promise<void>;
+}
+/** Codec adapter used to convert one input resource into streamed outputs. */
+export interface TileConversionCodec<TInspection, TInput, TOutput> {
+    /** Convert one input resource into zero or more output resources. */
+    convert(resource: TInput, inspection: TInspection, signal?: AbortSignal): AsyncIterable<TOutput> | Promise<AsyncIterable<TOutput>>;
+    /** Optionally validate each output resource before it is written. */
+    validateOutput?(resource: TOutput, signal?: AbortSignal): Promise<readonly TileConversionDiagnostic[]>;
+}
+/** Options for the portable `convertTileset` operation. */
+export interface ConvertTilesetOptions<TInspection, TInput, TOutput> {
+    /** Injected input resolver and resource reader. */
+    readonly source: TileConversionSource<TInspection, TInput>;
+    /** Injected output codec. */
+    readonly codec: TileConversionCodec<TInspection, TInput, TOutput>;
+    /** Injected destination writer. */
+    readonly sink: TileConversionSink<TOutput>;
+    /** Return the decoded input byte size as a nonnegative safe integer. */
+    readonly measureInputBytes: (resource: TInput) => number;
+    /** Return the byte size of an output resource. */
+    readonly measureOutputBytes: (resource: TOutput) => number;
+    /** Reject a decoded input resource above this byte limit before encoding. Defaults to no limit. */
+    readonly maxInputResourceBytes?: number;
+    /** Reject any output resource larger than this configured byte limit. */
+    readonly maxOutputResourceBytes?: number;
+    /** Cancel inspection, conversion, validation, or writes. */
+    readonly signal?: AbortSignal;
+    /** Receive progress updates after each resource transition. */
+    readonly onProgress?: (progress: TileConversionProgress) => void;
+}
+/** Options for a standalone tileset validation pass. */
+export interface ValidateTilesetOptions<TTileset> {
+    /** Tileset or conversion result to validate. */
+    readonly tileset: TTileset;
+    /** Injected profile-specific validator. */
+    readonly validate: (tileset: TTileset, signal?: AbortSignal) => Promise<readonly TileConversionDiagnostic[]>;
+    /** Cancel validation. */
+    readonly signal?: AbortSignal;
+}
+/** Result of validating a tileset. */
+export interface TileValidationReport {
+    /** False when at least one error diagnostic was reported. */
+    readonly valid: boolean;
+    /** Diagnostics returned by the injected validator. */
+    readonly diagnostics: readonly TileConversionDiagnostic[];
+}
+/** Inspects a tileset with an injected, platform-specific source adapter. */
+export declare function inspectTileset<TInspection, TInput>(source: TileConversionSource<TInspection, TInput>, signal?: AbortSignal): Promise<TInspection>;
+/**
+ * Converts a stream of tileset resources through injected source, codec, and sink adapters.
+ * Decoded inputs are measured and checked against `maxInputResourceBytes` before encoding.
+ * This does not limit source decoding allocations or content retained by a source.
+ * Writes are awaited one resource at a time, keeping queued output bytes bounded by the
+ * largest emitted resource and the configured `maxOutputResourceBytes` limit.
+ */
+export declare function convertTileset<TInspection, TInput, TOutput>(options: ConvertTilesetOptions<TInspection, TInput, TOutput>): Promise<TileConversionReport>;
+/** Validates a tileset through an injected profile-specific validator. */
+export declare function validateTileset<TTileset>(options: ValidateTilesetOptions<TTileset>): Promise<TileValidationReport>;

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

@@ -0,0 +1,32 @@
+import type { BrowserTileConversionFile } from '@loaders.gl/tile-converter/v5/core';
+/** Output profile and required budget for packaging finalized conversion resources. */
+export interface TileConversionArchiveOptions {
+    /** Archive format; resources must already use the selected format's layout and encoding. */
+    readonly format: '3tz' | 'slpk';
+    /** Maximum final archive bytes, including headers/index; not peak serialization memory. */
+    readonly maxArchiveBytes: number;
+    /** Cooperative packaging cancellation; active block reads and header encodes finish first. */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Packages finalized, already-authored resources as a bounded 3TZ or SLPK Blob.
+ * 3TZ requires tileset.json; SLPK requires 3dSceneLayer.json.gz and precompressed I3S resources.
+ * Selecting an archive format does not convert geometry, metadata, or coordinate systems.
+ * Applications own input qualification, object URLs, and downloads. Inputs must remain unchanged.
+ * @param files - Unmodified files from a successfully finalized browser sink.
+ * @param options - Archive format and complete output-size budget.
+ * @returns Archive Blob to save using the selected .3tz or .slpk extension.
+ */
+export declare function createTileConversionArchive(files: readonly BrowserTileConversionFile[], options: TileConversionArchiveOptions): Promise<Blob>;
+/**
+ * Streams finalized resources as a bounded 3TZ or SLPK archive without a complete output buffer.
+ * Checks declarations and the full budget on first pull, before output. Await each chunk write
+ * for backpressure; callers finalize storage only after successful completion and discard partial
+ * output on failure, cancellation, or early exit. Resource inputs remain caller-owned and immutable.
+ * Uses payload blocks of at most 64 KiB and retains index/directory metadata and caller inputs.
+ * Each resource is read once for its checksum, then again for output; this is not a total heap guarantee.
+ * @param files - Files from a successfully finalized browser conversion sink.
+ * @param options - Format, complete archive-size budget, and optional cancellation signal.
+ * @returns Uint8Array views to write to application-owned storage, respecting their byte ranges.
+ */
+export declare function encodeTileConversionArchiveInBatches(files: readonly BrowserTileConversionFile[], options: TileConversionArchiveOptions): AsyncIterable<Uint8Array<ArrayBuffer>>;