ENOENT: no such file or directory, stat '/tmp/workspace/pointcloud/230110/raw/pointcloud_230110_voxels.csv'

run = async (targetId: number, msgObject?: any): Promise<void> => {
    const targetType = msgObject.type ?? 'capture';
    try {
        const serverRealityCapture = await this.realityCaptureManager.loadRealityCapture(targetId, targetType);
        const cpRealityCapture = this.realityCaptureManager.createCPRealityCapture(serverRealityCapture, targetType);
        if (!DEBUG_MODE) await this.realityCaptureManager.updateVoxelState(TESLA.VoxelState.Aggregating);
        await this.realityCaptureManager.loadEntityParameters(cpRealityCapture);
        await this.realityCaptureManager.loadSubModels(cpRealityCapture);

        const result = await this.voxelManager.calculateVoxels(cpRealityCapture);

        await this.voxelManager.saveRawVoxels(result, cpRealityCapture.rawVoxelFilePath);
        await this.voxelManager.saveXYPlaneVoxels(result, cpRealityCapture.voxelFilePath);
        // ...
    } catch (error: any) {
        logger.error('VoxelService::run | error', error);
        if (!DEBUG_MODE) await this.realityCaptureManager.updateVoxelState(TESLA.VoxelState.Error);
    }
};

async calculate(params: VoxelCalculator.Params): Promise<VoxelCalculator.Response> {
    try {
        const pco = await this.load(params);
        if (pco == null) {
            throw new Error('Failed to load point cloud octree');
        }
        const res = this.calculateOccupiedVoxels(pco, params);
        return res;
    } catch (ec) {
        console.warn(ec);
        return {
            voxelMap: new Map<number, Map<number, Map<number, number>>>(),
            params: params,
            calculated: false
        };
    }
}

private async load(params: VoxelCalculator.Params): Promise<EnginePotreeV2.PointCloudOctree | undefined> {
    try {
        const pco = await this.potree_.loadPointCloud(
            `${params.filename}`,
            url => `${params.baseURL}${url}`,
            true
        );
        return pco;
    } catch (ec) {
        console.warn(ec);
        return undefined;
    }
}

calculateVoxels = async (cpRealityCapture: CPRealityCapture): Promise<VoxelCalculator.Response> => {
    const params: VoxelCalculator.Params = cpRealityCapture.voxelParams;
    if (cpRealityCapture.isCapture) {
        this._voxelResult = CPCaptureOccupiedVoxelUtils.calculate(cpRealityCapture, params);
    } else if (cpRealityCapture.isPointcloud) {
        this._voxelResult = await new CPPointcloudVoxelCalculator().calculate(params);
    } else {
        throw new Error('unknown target type');
    }

    logger.info('VoxelManager::calculateVoxels | finished - %s ID: %d, voxelCount: %d, numNodes: %d, numLeaves: %d'
        , cpRealityCapture.modelType, cpRealityCapture.id
        , this._voxelResult.voxelCount, this._voxelResult.numNodes, this._voxelResult.numLeaves);
    return this._voxelResult;
};

writeVoxelStream = async (filePath: string, voxelMap: VoxelCalculator.VoxelMap, params: VoxelCalculator.Params, includesMeta = true): Promise<void> => {
    logger.debug('VoxelWriter::writeVoxelStream | begin - filePath: %s', filePath);

    const sortedFiles = this.writeVoxelStreamFromMap(voxelMap, params);
    // empty voxelMap → sortedFiles === []

    const writeStream = fs.createWriteStream(filePath, { flags: 'w', highWaterMark: this._BUFFER_SIZE });
    if (includesMeta) writeStream.write(this.metaString(params));
    writeStream.write(this.header);

    await mergeSortedFiles<VoxelCalculator.Voxel>(
        sortedFiles, writeStream, this.deserialize, this.serialize, this.compareFn, '\n'
    );
    // mergeSortedFiles returns immediately when files.length === 0:
    //   export async function mergeSortedFiles<TValue>(files, ...) {
    //       if (files.length === 0) return;   // large-sort.ts:427
    //       ...
    //   }

    writeStream.end();
    writeStream.close();

    logger.debug('VoxelWriter::writeVoxelStream | voxel file written to: %s, fileSize: %d'
        , filePath, fs.statSync(filePath).size);  // ← ENOENT throws here
};

export async function mergeSortedFiles<TValue>(
    files: string[],
    outputStream: Writable,
    /* ... */
): Promise<void> {
    if (files.length === 0) return;
    // ...
}

-    logger.error('VoxelService::run | end - error: %s', JSON.stringify(error.message));+    logger.error('VoxelService::run | error', error);

service:cupixworks-any-voxel-agent "230110"

service:cupixworks-any-voxel-agent "voxelCount: NaN"

service:cupixworks-any-voxel-agent "ENOENT"

{ "timestamp": "2026-06-24 14:32:24", "status": "info",  "message": "BaseService::runByMessage | id: 230110" }
{ "timestamp": "2026-06-24 14:32:25", "status": "info",  "message": "CPRealityCapture::setCaptureVoxelsParams | pointcloud ID: 230110 - voxelSize: 1, panoIndoorVoxelEffectiveRange: 5, panoOutdoorVoxelEffectiveRange: 5, pointcloudPotreeLevelThreshold: 3" }
{ "timestamp": "2026-06-24 14:32:25", "status": "info",  "message": "VoxelManager::calculateVoxels | finished - pointcloud ID: 230110, voxelCount: NaN, numNodes: NaN, numLeaves: NaN" }
{ "timestamp": "2026-06-24 14:32:25", "status": "error", "message": "ENOENT: no such file or directory, stat '/tmp/workspace/pointcloud/230110/raw/pointcloud_230110_voxels.csv'" }

2026-06-24 15:30:00  pointcloud ID: 230174  voxelCount: NaN
2026-06-24 14:32:25  pointcloud ID: 230110  voxelCount: NaN
2026-06-24 12:55:01  pointcloud ID: 230076  voxelCount: NaN
2026-06-24 12:45:56  pointcloud ID: 230072  voxelCount: NaN
2026-06-24 12:10:09  pointcloud ID: 230070  voxelCount: NaN
2026-06-24 12:03:13  pointcloud ID: 230062  voxelCount: NaN
2026-06-24 11:58:13  pointcloud ID: 230060  voxelCount: NaN
... (지난 24h 안에 동일 패턴 다수)

service:cupixworks-any-voxel-agent "Failed to load point cloud"   → 0 logs
service:cupixworks-any-voxel-agent "loadPointCloud"               → 0 logs

count:logs("service:cupixworks-any-voxel-agent voxelCount: NaN").index("*").rollup("count").by("region").last("1h")

count:logs("service:cupixworks-any-voxel-agent ENOENT voxels.csv").index("*").rollup("count").by("region").last("1h")

count:logs("service:cupixworks-any-voxel-agent VoxelService::run | error").index("*").rollup("count").by("region").last("1h")