@manycore/aholo-splat-transform 1.2.7 → 1.2.9

package/dist/index.d.ts

@@ -1,33 +1,33 @@
-import { Config as AutoChunkLodConfig } from './tasks/AutoChunkLodTask.js';
-import { Config as AutoLodConfig } from './tasks/AutoLodTask.js';
-import { Config as FlexLodConfig } from './tasks/FlexLodTask.js';
-import { Config as SkeletonLodConfig } from './tasks/SkeletonLodTask.js';
-import { Config as ModifyConfig } from './tasks/ModifyTask.js';
-import { Config as ReadConfig } from './tasks/ReadTask.js';
-import { Config as WriteConfig } from './tasks/WriteTask.js';
-import { VoxelTaskConfig } from './tasks/VoxelTask.js';
-interface TaskConfigMap {
-    Read: ReadConfig;
-    Write: WriteConfig;
-    Voxel: VoxelTaskConfig;
-    Modify: ModifyConfig;
-    SkeletonLod: SkeletonLodConfig;
-    FlexLod: FlexLodConfig;
-    AutoLod: AutoLodConfig;
-    AutoChunkLod: AutoChunkLodConfig;
-}
-type PipelineTask = {
-    [K in keyof TaskConfigMap]: {
-        id: string;
-        type: K;
-        config: TaskConfigMap[K];
-        release?: string[];
-    };
-}[keyof TaskConfigMap];
-interface PipelineConfig {
-    version: number;
-    gpu?: number;
-    tasks: PipelineTask[];
-}
-export declare function runner(config: PipelineConfig): Promise<void>;
-export {};
+import { type Config as AutoChunkLodConfig } from './tasks/AutoChunkLodTask.js';
+import { type Config as AutoLodConfig } from './tasks/AutoLodTask.js';
+import { type Config as FlexLodConfig } from './tasks/FlexLodTask.js';
+import { type Config as SkeletonLodConfig } from './tasks/SkeletonLodTask.js';
+import { type Config as ModifyConfig } from './tasks/ModifyTask.js';
+import { type Config as ReadConfig } from './tasks/ReadTask.js';
+import { type Config as WriteConfig } from './tasks/WriteTask.js';
+import { type VoxelTaskConfig } from './tasks/VoxelTask.js';
+interface TaskConfigMap {
+    Read: ReadConfig;
+    Write: WriteConfig;
+    Voxel: VoxelTaskConfig;
+    Modify: ModifyConfig;
+    SkeletonLod: SkeletonLodConfig;
+    FlexLod: FlexLodConfig;
+    AutoLod: AutoLodConfig;
+    AutoChunkLod: AutoChunkLodConfig;
+}
+type PipelineTask = {
+    [K in keyof TaskConfigMap]: {
+        id: string;
+        type: K;
+        config: TaskConfigMap[K];
+        release?: string[];
+    };
+}[keyof TaskConfigMap];
+interface PipelineConfig {
+    version: number;
+    gpu?: number;
+    tasks: PipelineTask[];
+}
+export declare function runner(config: PipelineConfig): Promise<void>;
+export {};

package/dist/index.js

@@ -1,54 +1,54 @@
-import { AutoChunkLodTask } from './tasks/AutoChunkLodTask.js';
-import { AutoLodTask } from './tasks/AutoLodTask.js';
-import { FlexLodTask } from './tasks/FlexLodTask.js';
-import { SkeletonLodTask } from './tasks/SkeletonLodTask.js';
-import { ModifyTask } from './tasks/ModifyTask.js';
-import { ReadTask } from './tasks/ReadTask.js';
-import { WriteTask } from './tasks/WriteTask.js';
-import { VoxelTask } from './tasks/VoxelTask.js';
-import { enumerateAdapters, logger, releaseSharedDevice, initGPUAdapter } from './utils/index.js';
-const TaskMap = {
-    Read: new ReadTask(),
-    Write: new WriteTask(),
-    Voxel: new VoxelTask(),
-    Modify: new ModifyTask(),
-    SkeletonLod: new SkeletonLodTask(),
-    FlexLod: new FlexLodTask(),
-    AutoLod: new AutoLodTask(),
-    AutoChunkLod: new AutoChunkLodTask(),
-};
-function anyTaskRequireGPU(tasks) {
-    for (const t of tasks) {
-        if (TaskMap[t.type].requiresGPU(t.config)) {
-            return true;
-        }
-    }
-    return false;
-}
-export async function runner(config) {
-    console.time('Total elapsed time');
-    const ctx = {
-        logger,
-        resources: new Map(),
-    };
-    if (anyTaskRequireGPU(config.tasks)) {
-        logger.prefix = `[Task:GPU]`;
-        logger.info('Any task requires GPU detected, initialize GPU adapter.');
-        const adapter = (await enumerateAdapters())[config.gpu ?? 0];
-        initGPUAdapter([`adapter=${adapter.name}`]);
-    }
-    for (const taskDef of config.tasks) {
-        const { id, type, config: taskConfig, release = [] } = taskDef;
-        const task = TaskMap[type];
-        if (!task) {
-            throw new Error(`Task not found: ${type} (id: ${id})`);
-        }
-        logger.prefix = `[Task:${type}#${id}]`;
-        logger.time('elapsed time');
-        await task.exec(taskConfig, ctx);
-        release.forEach(v => ctx.resources.delete(v));
-        logger.timeEnd('elapsed time');
-    }
-    releaseSharedDevice();
-    console.timeEnd('Total elapsed time');
-}
+import { AutoChunkLodTask } from './tasks/AutoChunkLodTask.js';
+import { AutoLodTask } from './tasks/AutoLodTask.js';
+import { FlexLodTask } from './tasks/FlexLodTask.js';
+import { SkeletonLodTask } from './tasks/SkeletonLodTask.js';
+import { ModifyTask } from './tasks/ModifyTask.js';
+import { ReadTask } from './tasks/ReadTask.js';
+import { WriteTask } from './tasks/WriteTask.js';
+import { VoxelTask } from './tasks/VoxelTask.js';
+import { enumerateAdapters, logger, releaseSharedDevice, initGPUAdapter } from './utils/index.js';
+const TaskMap = {
+    Read: new ReadTask(),
+    Write: new WriteTask(),
+    Voxel: new VoxelTask(),
+    Modify: new ModifyTask(),
+    SkeletonLod: new SkeletonLodTask(),
+    FlexLod: new FlexLodTask(),
+    AutoLod: new AutoLodTask(),
+    AutoChunkLod: new AutoChunkLodTask(),
+};
+function anyTaskRequireGPU(tasks) {
+    for (const t of tasks) {
+        if (TaskMap[t.type].requiresGPU(t.config)) {
+            return true;
+        }
+    }
+    return false;
+}
+export async function runner(config) {
+    console.time('Total elapsed time');
+    const ctx = {
+        logger,
+        resources: new Map(),
+    };
+    if (anyTaskRequireGPU(config.tasks)) {
+        logger.prefix = `[Task:GPU]`;
+        logger.info('Any task requires GPU detected, initialize GPU adapter.');
+        const adapter = (await enumerateAdapters())[config.gpu ?? 0];
+        initGPUAdapter([`adapter=${adapter.name}`]);
+    }
+    for (const taskDef of config.tasks) {
+        const { id, type, config: taskConfig, release = [] } = taskDef;
+        const task = TaskMap[type];
+        if (!task) {
+            throw new Error(`Task not found: ${type} (id: ${id})`);
+        }
+        logger.prefix = `[Task:${type}#${id}]`;
+        logger.time('elapsed time');
+        await task.exec(taskConfig, ctx);
+        release.forEach(v => ctx.resources.delete(v));
+        logger.timeEnd('elapsed time');
+    }
+    releaseSharedDevice();
+    console.timeEnd('Total elapsed time');
+}

package/dist/native/index.d.ts

@@ -1,54 +1,54 @@
-import { SplatData } from '../SplatData.js';
-import { Buffer } from 'node:buffer';
-export interface LevelParameter {
-    precision: number;
-    scaleBoost: number;
-}
-export interface BlockedSplats {
-    box: {
-        min: [number, number, number];
-        max: [number, number, number];
-    };
-    /**
-     * current block referenced splats, level ordered.
-     */
-    refs: number[];
-}
-export interface BlockedResult {
-    splats: SplatData[];
-    blocks: BlockedSplats[];
-}
-export declare function generateLod(splat: SplatData, levelParameters: LevelParameter[], blockPrecision: number, minSize: number, maxStep: number): BlockedResult;
-export declare class WebPLosslessProfile {
-    readonly lossless = true;
-}
-export declare class WebPQualityProfile {
-    readonly quality: number;
-    readonly lossless = false;
-    constructor(quality: number);
-}
-export declare function encodeWebP(data: Uint8Array | Buffer, width: number, height: number, profile: WebPLosslessProfile | WebPQualityProfile): Buffer<ArrayBufferLike>;
-export declare function decodeWebP(data: Uint8Array | Buffer): {
-    data: Buffer;
-    width: number;
-    height: number;
-};
-export declare function encodeAVIF(data: Uint8Array | Buffer, width: number, height: number, quality: number): Buffer<ArrayBufferLike>;
-export interface AVIFEncodeInput {
-    data: Uint8Array | Buffer;
-    width: number;
-    height: number;
-    quality: number;
-}
-export declare function encodeAVIFBatched(inputs: AVIFEncodeInput[]): Buffer<ArrayBufferLike>[];
-export declare function decodeAVIF(data: Uint8Array | Buffer): {
-    data: Buffer;
-    width: number;
-    height: number;
-};
-export declare function decodeAVIFBatched(inputs: Array<Uint8Array | Buffer>): {
-    data: Buffer;
-    width: number;
-    height: number;
-}[];
-export declare function clusterAverage(dataTable: Float32Array[], clusters: Uint32Array[], output: Float32Array[]): void;
+import { SplatData } from '../SplatData.js';
+import { Buffer } from 'node:buffer';
+export interface LevelParameter {
+    precision: number;
+    scaleBoost: number;
+}
+export interface BlockedSplats {
+    box: {
+        min: [number, number, number];
+        max: [number, number, number];
+    };
+    /**
+     * current block referenced splats, level ordered.
+     */
+    refs: number[];
+}
+export interface BlockedResult {
+    splats: SplatData[];
+    blocks: BlockedSplats[];
+}
+export declare function generateLod(splat: SplatData, levelParameters: LevelParameter[], blockPrecision: number, minSize: number, maxStep: number): BlockedResult;
+export declare class WebPLosslessProfile {
+    readonly lossless = true;
+}
+export declare class WebPQualityProfile {
+    readonly quality: number;
+    readonly lossless = false;
+    constructor(quality: number);
+}
+export declare function encodeWebP(data: Uint8Array | Buffer, width: number, height: number, profile: WebPLosslessProfile | WebPQualityProfile): Buffer<ArrayBufferLike>;
+export declare function decodeWebP(data: Uint8Array | Buffer): {
+    data: Buffer;
+    width: number;
+    height: number;
+};
+export declare function encodeAVIF(data: Uint8Array | Buffer, width: number, height: number, quality: number): Buffer<ArrayBufferLike>;
+export interface AVIFEncodeInput {
+    data: Uint8Array | Buffer;
+    width: number;
+    height: number;
+    quality: number;
+}
+export declare function encodeAVIFBatched(inputs: AVIFEncodeInput[]): Buffer<ArrayBufferLike>[];
+export declare function decodeAVIF(data: Uint8Array | Buffer): {
+    data: Buffer;
+    width: number;
+    height: number;
+};
+export declare function decodeAVIFBatched(inputs: Array<Uint8Array | Buffer>): {
+    data: Buffer;
+    width: number;
+    height: number;
+}[];
+export declare function clusterAverage(dataTable: Float32Array[], clusters: Uint32Array[], output: Float32Array[]): void;

package/dist/native/index.js

@@ -1,128 +1,122 @@
-import * as child_process from 'node:child_process';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { createRequire } from 'node:module';
-import { SplatData } from '../SplatData.js';
-import { Buffer } from 'node:buffer';
-const getModule = (function () {
-    let m = undefined;
-    const require = createRequire(import.meta.url);
-    const platform = os.platform();
-    const binaryPath = `./cpp/bin/${platform === 'win32' ? 'windows' : platform}/binding.node`;
-    return function () {
-        if (!m) {
-            try {
-                m = require(binaryPath);
-            }
-            catch {
-                console.warn(`cannot find a valid binary at: ${binaryPath}, try rebuild`);
-                child_process.spawnSync('node', [
-                    require.resolve('cmake-js/bin/cmake-js'),
-                    'build',
-                    '--',
-                    '--preset',
-                    'default'
-                ], {
-                    cwd: path.join(import.meta.dirname, 'cpp'),
-                    stdio: 'inherit'
-                });
-                m = require(binaryPath);
-            }
-        }
-        return m;
-    };
-})();
-export function generateLod(splat, levelParameters, blockPrecision, minSize, maxStep) {
-    if (splat.counts === 0) {
-        return {
-            splats: [splat],
-            blocks: [{
-                    box: { min: [0, 0, 0], max: [0, 0, 0] },
-                    refs: new Array(levelParameters.length).fill(0),
-                }],
-        };
-    }
-    const levels = levelParameters.length;
-    const inputBuffers = splat.table.map(b => Buffer.from(b.buffer, b.byteOffset, b.byteLength));
-    const buffer = Buffer.alloc(levels * 8);
-    {
-        const parameters = new Float32Array(buffer.buffer, buffer.byteOffset, levels * 2);
-        for (let i = 0; i < levelParameters.length; i++) {
-            const { precision, scaleBoost } = levelParameters[i];
-            parameters[i * 2] = precision;
-            parameters[i * 2 + 1] = scaleBoost;
-        }
-    }
-    const { blockBoxes, blockRefs, gaussianCount, data, } = getModule().generate_lod(inputBuffers, splat.shCounts, buffer, blockPrecision, minSize, maxStep);
-    const blockView = new Float32Array(blockBoxes.buffer, blockBoxes.byteOffset, blockBoxes.byteLength / 4);
-    const blockRefsView = new Uint32Array(blockRefs.buffer, blockRefs.byteOffset, blockRefs.byteLength / 4);
-    const blockCount = blockView.length / 6;
-    const gaussianCountView = new Uint32Array(gaussianCount.buffer, gaussianCount.byteOffset, gaussianCount.byteLength / 4);
-    const blocks = [];
-    const splats = [];
-    // read splats
-    {
-        let gaussianOffset = 0;
-        for (const count of gaussianCountView) {
-            const splatData = new SplatData(1, splat.shDegree);
-            splatData.shDegree = splat.shDegree;
-            splatData.shCounts = splat.shCounts;
-            splatData.counts = count;
-            splatData.table = data.map(buffer => new Float32Array(buffer.buffer, buffer.byteOffset + gaussianOffset * 4, count));
-            splats.push(splatData);
-            gaussianOffset += count;
-        }
-    }
-    for (let i = 0; i < blockCount; i++) {
-        const block = {
-            box: {
-                min: [blockView[i * 6], blockView[i * 6 + 1], blockView[i * 6 + 2]],
-                max: [blockView[i * 6 + 3], blockView[i * 6 + 4], blockView[i * 6 + 5]]
-            },
-            refs: Array.from(blockRefsView.subarray(i * levels, i * levels + levels)),
-        };
-        blocks.push(block);
-    }
-    return { splats, blocks };
-}
-export class WebPLosslessProfile {
-    lossless = true;
-}
-export class WebPQualityProfile {
-    quality;
-    lossless = false;
-    constructor(quality) {
-        this.quality = quality;
-    }
-    ;
-}
-export function encodeWebP(data, width, height, profile) {
-    const buffer = data instanceof Buffer ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-    if (profile.lossless) {
-        return getModule().webp_encode_rgba_lossless(buffer, width, height);
-    }
-    else {
-        return getModule().webp_encode_rgba(buffer, width, height, profile.quality);
-    }
-}
-export function decodeWebP(data) {
-    const buffer = data instanceof Buffer ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-    return getModule().webp_decode_rgba(buffer);
-}
-export function encodeAVIF(data, width, height, quality) {
-    const buffer = data instanceof Buffer ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-    return getModule().avif_encode_rgba(buffer, width, height, quality);
-}
-export function encodeAVIFBatched(inputs) {
-    return getModule().avif_encode_rgba_batched(inputs.map(i => ({ ...i, data: i.data instanceof Buffer ? i.data : Buffer.from(i.data.buffer, i.data.byteOffset, i.data.byteLength) })));
-}
-export function decodeAVIF(data) {
-    const buffer = data instanceof Buffer ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-    return getModule().avif_decode_rgba(buffer);
-}
-export function decodeAVIFBatched(inputs) {
-    return getModule().avif_decode_rgba_batched(inputs.map(i => i instanceof Buffer ? i : Buffer.from(i.buffer, i.byteOffset, i.byteLength)));
-}
-export function clusterAverage(dataTable, clusters, output) {
-    return getModule().cluster_average(dataTable.map(t => Buffer.from(t.buffer, t.byteOffset, t.byteLength)), clusters.map(t => Buffer.from(t.buffer, t.byteOffset, t.byteLength)), output.map(t => Buffer.from(t.buffer, t.byteOffset, t.byteLength)));
-}
+import { createRequire } from 'node:module';
+import { SplatData } from '../SplatData.js';
+import { Buffer } from 'node:buffer';
+import { isMusl } from './utils.js';
+import p from '../../package.json' with { type: 'json' };
+const getModule = (function () {
+    let m = undefined;
+    const require = createRequire(import.meta.url);
+    let runtime = undefined;
+    if (process.platform === 'win32') {
+        runtime = 'msvc';
+    }
+    else if (process.platform === 'linux') {
+        runtime = isMusl() ? 'musl' : 'gnu';
+    }
+    const binaryPackage = `${p.name}-${process.platform}-${process.arch}${runtime ? `-${runtime}` : ''}`;
+    return function () {
+        if (!m) {
+            m = require(binaryPackage);
+        }
+        return m;
+    };
+})();
+export function generateLod(splat, levelParameters, blockPrecision, minSize, maxStep) {
+    if (splat.counts === 0) {
+        return {
+            splats: [splat],
+            blocks: [
+                {
+                    box: { min: [0, 0, 0], max: [0, 0, 0] },
+                    refs: new Array(levelParameters.length).fill(0),
+                },
+            ],
+        };
+    }
+    const levels = levelParameters.length;
+    const inputBuffers = splat.table.map(b => Buffer.from(b.buffer, b.byteOffset, b.byteLength));
+    const buffer = Buffer.alloc(levels * 8);
+    {
+        const parameters = new Float32Array(buffer.buffer, buffer.byteOffset, levels * 2);
+        for (let i = 0; i < levelParameters.length; i++) {
+            const { precision, scaleBoost } = levelParameters[i];
+            parameters[i * 2] = precision;
+            parameters[i * 2 + 1] = scaleBoost;
+        }
+    }
+    const { blockBoxes, blockRefs, gaussianCount, data } = getModule().generate_lod(inputBuffers, splat.shCounts, buffer, blockPrecision, minSize, maxStep);
+    const blockView = new Float32Array(blockBoxes.buffer, blockBoxes.byteOffset, blockBoxes.byteLength / 4);
+    const blockRefsView = new Uint32Array(blockRefs.buffer, blockRefs.byteOffset, blockRefs.byteLength / 4);
+    const blockCount = blockView.length / 6;
+    const gaussianCountView = new Uint32Array(gaussianCount.buffer, gaussianCount.byteOffset, gaussianCount.byteLength / 4);
+    const blocks = [];
+    const splats = [];
+    // read splats
+    {
+        let gaussianOffset = 0;
+        for (const count of gaussianCountView) {
+            const splatData = new SplatData(1, splat.shDegree);
+            splatData.shDegree = splat.shDegree;
+            splatData.shCounts = splat.shCounts;
+            splatData.counts = count;
+            splatData.table = data.map(buffer => new Float32Array(buffer.buffer, buffer.byteOffset + gaussianOffset * 4, count));
+            splats.push(splatData);
+            gaussianOffset += count;
+        }
+    }
+    for (let i = 0; i < blockCount; i++) {
+        const block = {
+            box: {
+                min: [blockView[i * 6], blockView[i * 6 + 1], blockView[i * 6 + 2]],
+                max: [blockView[i * 6 + 3], blockView[i * 6 + 4], blockView[i * 6 + 5]],
+            },
+            refs: Array.from(blockRefsView.subarray(i * levels, i * levels + levels)),
+        };
+        blocks.push(block);
+    }
+    return { splats, blocks };
+}
+export class WebPLosslessProfile {
+    constructor() {
+        this.lossless = true;
+    }
+}
+export class WebPQualityProfile {
+    constructor(quality) {
+        this.quality = quality;
+        this.lossless = false;
+    }
+}
+export function encodeWebP(data, width, height, profile) {
+    const buffer = data instanceof Buffer ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    if (profile.lossless) {
+        return getModule().webp_encode_rgba_lossless(buffer, width, height);
+    }
+    else {
+        return getModule().webp_encode_rgba(buffer, width, height, profile.quality);
+    }
+}
+export function decodeWebP(data) {
+    const buffer = data instanceof Buffer ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    return getModule().webp_decode_rgba(buffer);
+}
+export function encodeAVIF(data, width, height, quality) {
+    const buffer = data instanceof Buffer ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    return getModule().avif_encode_rgba(buffer, width, height, quality);
+}
+export function encodeAVIFBatched(inputs) {
+    return getModule().avif_encode_rgba_batched(inputs.map(i => ({
+        ...i,
+        data: i.data instanceof Buffer ? i.data : Buffer.from(i.data.buffer, i.data.byteOffset, i.data.byteLength),
+    })));
+}
+export function decodeAVIF(data) {
+    const buffer = data instanceof Buffer ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    return getModule().avif_decode_rgba(buffer);
+}
+export function decodeAVIFBatched(inputs) {
+    return getModule().avif_decode_rgba_batched(inputs.map(i => (i instanceof Buffer ? i : Buffer.from(i.buffer, i.byteOffset, i.byteLength))));
+}
+export function clusterAverage(dataTable, clusters, output) {
+    return getModule().cluster_average(dataTable.map(t => Buffer.from(t.buffer, t.byteOffset, t.byteLength)), clusters.map(t => Buffer.from(t.buffer, t.byteOffset, t.byteLength)), output.map(t => Buffer.from(t.buffer, t.byteOffset, t.byteLength)));
+}

package/dist/native/utils.d.ts

@@ -0,0 +1 @@
+export declare function isMusl(): boolean;

package/dist/native/utils.js

@@ -0,0 +1,54 @@
+import { readFileSync } from 'node:fs';
+import child_process from 'node:child_process';
+export function isMusl() {
+    let musl = false;
+    if (process.platform === 'linux') {
+        musl = isMuslFromFilesystem();
+        if (musl == null) {
+            musl = isMuslFromReport();
+        }
+        if (musl == null) {
+            musl = isMuslFromChildProcess();
+        }
+    }
+    return musl;
+}
+function isFileMusl(f) {
+    return f.includes('libc.musl-') || f.includes('ld-musl-');
+}
+function isMuslFromFilesystem() {
+    try {
+        return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl');
+    }
+    catch {
+        return null;
+    }
+}
+function isMuslFromReport() {
+    let report = null;
+    if (typeof process.report?.getReport === 'function') {
+        process.report.excludeNetwork = true;
+        report = process.report.getReport();
+    }
+    if (!report) {
+        return null;
+    }
+    if (report.header && report.header.glibcVersionRuntime) {
+        return false;
+    }
+    if (Array.isArray(report.sharedObjects)) {
+        if (report.sharedObjects.some(isFileMusl)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isMuslFromChildProcess() {
+    try {
+        return child_process.execSync('ldd --version', { encoding: 'utf8' }).includes('musl');
+    }
+    catch {
+        // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+        return false;
+    }
+}

package/dist/tasks/AutoChunkLodTask.d.ts

@@ -1,13 +1,13 @@
-import { Context, BaseTask } from './BaseTask.js';
-import { LevelParameter } from '../native/index.js';
-export interface Config {
-    input: string;
-    output: string;
-    type: string;
-    maxChunkCounts?: number;
-    levels?: LevelParameter[];
-}
-export declare class AutoChunkLodTask extends BaseTask<Config> {
-    exec(config: Config, { logger, resources }: Context): Promise<void>;
-    requiresGPU(config: Config): boolean;
-}
+import { type Context, BaseTask } from './BaseTask.js';
+import { type LevelParameter } from '../native/index.js';
+export interface Config {
+    input: string;
+    output: string;
+    type: string;
+    maxChunkCounts?: number;
+    levels?: LevelParameter[];
+}
+export declare class AutoChunkLodTask extends BaseTask<Config> {
+    exec(config: Config, { logger, resources }: Context): Promise<void>;
+    requiresGPU(config: Config): boolean;
+}