@jupytergis/base 0.15.0 → 0.16.0-alpha.1

package/lib/features/processing/index.js

@@ -0,0 +1,1246 @@
+import { processingList, } from '@jupytergis/schema';
+import { Notification, showErrorMessage } from '@jupyterlab/apputils';
+import { UUID } from '@lumino/coreutils';
+import { ProcessingFormDialog } from './ProcessingFormDialog';
+import { processingFormToParam } from './processingFormToParam';
+import { isServerProcessingEnabled, runServerProcessing, runServerProcessingUrl, runServerProcessingUrlWithCutline, } from './serverProcessing';
+import { getGdal } from '../../gdal';
+import { getGeoJSONDataFromLayerSource } from '../../tools';
+/**
+ * Get the currently selected layer from the shared model. Returns null if there is no selection or multiple layer is selected.
+ */
+export function getSingleSelectedLayer(tracker) {
+    var _a, _b, _c;
+    const model = (_a = tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.model;
+    if (!model) {
+        return null;
+    }
+    const localState = model.sharedModel.awareness.getLocalState();
+    if (!localState || !((_b = localState['selected']) === null || _b === void 0 ? void 0 : _b.value)) {
+        return null;
+    }
+    const selectedLayers = Object.keys(localState['selected'].value);
+    // Ensure only one layer is selected
+    if (selectedLayers.length !== 1) {
+        return null;
+    }
+    const selectedLayerId = selectedLayers[0];
+    const layers = (_c = model.sharedModel.layers) !== null && _c !== void 0 ? _c : {};
+    const selectedLayer = layers[selectedLayerId];
+    return selectedLayer && selectedLayer.parameters ? selectedLayer : null;
+}
+/**
+ * Check if the selected layer is of one of the specified types
+ */
+export function selectedLayerIsOfType(allowedTypes, tracker) {
+    const selectedLayer = getSingleSelectedLayer(tracker);
+    return selectedLayer ? allowedTypes.includes(selectedLayer.type) : false;
+}
+/**
+ * Extract GeoJSON from selected layer's source
+ */
+export async function getLayerGeoJSON(layer, sources, model) {
+    if (!layer.parameters || !layer.parameters.source) {
+        console.error('Selected layer does not have a valid source.');
+        return null;
+    }
+    const source = sources[layer.parameters.source];
+    if (!source || !source.parameters) {
+        console.error(`Source with ID ${layer.parameters.source} not found or missing path.`);
+        return null;
+    }
+    return await getGeoJSONDataFromLayerSource(source, model);
+}
+/**
+ * Generalized processing function for Buffer & Dissolve
+ */
+export async function processLayer(tracker, formSchemaRegistry, processingType, processingOptions, app, filePath, processingInputs) {
+    var _a, _b, _c, _d;
+    // Resolve widget
+    const widget = filePath
+        ? tracker.find(w => w.model.filePath === filePath)
+        : tracker.currentWidget;
+    if (!widget) {
+        return;
+    }
+    const model = widget.model;
+    const sources = (_a = model.sharedModel.sources) !== null && _a !== void 0 ? _a : {};
+    const layers = (_b = model.sharedModel.layers) !== null && _b !== void 0 ? _b : {};
+    // Resolve layer
+    let selected = null;
+    if (processingInputs === null || processingInputs === void 0 ? void 0 : processingInputs.inputLayer) {
+        selected = layers[processingInputs.inputLayer];
+    }
+    else {
+        selected = getSingleSelectedLayer(tracker);
+    }
+    if (!selected) {
+        return;
+    }
+    const geojsonString = await getLayerGeoJSON(selected, sources, model);
+    if (!geojsonString) {
+        return;
+    }
+    // Resolve params
+    let processParam;
+    let embedOutputLayer = true;
+    let outputLayerName = selected.name;
+    if (processingInputs) {
+        processParam = processingInputs;
+        outputLayerName = `${processingType} Layer`;
+    }
+    else {
+        const schema = Object.assign({}, formSchemaRegistry.getSchemas().get(processingType));
+        const selectedLayerId = Object.keys(((_d = (_c = model.sharedModel.awareness.getLocalState()) === null || _c === void 0 ? void 0 : _c.selected) === null || _d === void 0 ? void 0 : _d.value) || {})[0];
+        // Open ProcessingFormDialog
+        const formValues = await new Promise(resolve => {
+            const dialog = new ProcessingFormDialog({
+                title: processingType.charAt(0).toUpperCase() + processingType.slice(1),
+                schema,
+                model,
+                sourceData: {
+                    inputLayer: selectedLayerId,
+                    outputLayerName: selected.name,
+                },
+                formContext: 'create',
+                processingType,
+                syncData: (props) => {
+                    resolve(props);
+                    dialog.dispose();
+                },
+            });
+            dialog.launch();
+        });
+        if (!formValues) {
+            return;
+        }
+        if (!processingList.includes(processingType)) {
+            console.error(`Unsupported processing type: ${processingType}`);
+            return;
+        }
+        processParam = processingFormToParam(formValues, processingType);
+        embedOutputLayer = formValues.embedOutputLayer;
+        outputLayerName = formValues.outputLayerName;
+    }
+    // GDAL pre-processing
+    const fileBlob = new Blob([geojsonString], {
+        type: 'application/geo+json',
+    });
+    const geoFile = new File([fileBlob], 'data.geojson', {
+        type: 'application/geo+json',
+    });
+    const Gdal = await getGdal();
+    const result = await Gdal.open(geoFile);
+    const dataset = result.datasets[0];
+    const layerName = dataset.info.layers[0].name;
+    const sqlQuery = processingOptions.sqlQueryFn(layerName, processParam);
+    const fullOptions = processingOptions.options(sqlQuery);
+    await executeSQLProcessing(model, geojsonString, processingOptions.gdalFunction, fullOptions, outputLayerName, processingType, embedOutputLayer, tracker, app);
+}
+/**
+ * Rasterize a vector layer to a GeoTIFF on disk and add it as a WebGlLayer.
+ */
+export async function rasterizeLayer(tracker, formSchemaRegistry, processingType, gdalFunction, app, filePath, processingInputs) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const widget = filePath
+        ? tracker.find(w => w.model.filePath === filePath)
+        : tracker.currentWidget;
+    if (!widget) {
+        return;
+    }
+    const model = widget.model;
+    const sources = (_a = model.sharedModel.sources) !== null && _a !== void 0 ? _a : {};
+    const layers = (_b = model.sharedModel.layers) !== null && _b !== void 0 ? _b : {};
+    let selected = null;
+    if (processingInputs === null || processingInputs === void 0 ? void 0 : processingInputs.inputLayer) {
+        selected = layers[processingInputs.inputLayer];
+    }
+    else {
+        selected = getSingleSelectedLayer(tracker);
+    }
+    if (!selected) {
+        return;
+    }
+    const geojsonString = await getLayerGeoJSON(selected, sources, model);
+    if (!geojsonString) {
+        return;
+    }
+    let processParam;
+    let outputFileName = 'rasterized.tif';
+    let embedOutputLayer = false;
+    if (processingInputs) {
+        processParam = processingInputs;
+        outputFileName = processingInputs.outputFileName || outputFileName;
+        embedOutputLayer = !!processingInputs.embedOutputLayer;
+    }
+    else {
+        const schema = Object.assign({}, formSchemaRegistry.getSchemas().get(processingType));
+        const selectedLayerId = Object.keys(((_d = (_c = model.sharedModel.awareness.getLocalState()) === null || _c === void 0 ? void 0 : _c.selected) === null || _d === void 0 ? void 0 : _d.value) || {})[0];
+        const formValues = await new Promise(resolve => {
+            const dialog = new ProcessingFormDialog({
+                title: processingType.charAt(0).toUpperCase() + processingType.slice(1),
+                schema,
+                model,
+                sourceData: {
+                    inputLayer: selectedLayerId,
+                    outputFileName: `${selected.name.replace(/\s+/g, '_')}_rasterized.tif`,
+                },
+                formContext: 'create',
+                processingType,
+                syncData: (props) => {
+                    resolve(props);
+                    dialog.dispose();
+                },
+            });
+            dialog.launch();
+        });
+        if (!formValues) {
+            return;
+        }
+        processParam = processingFormToParam(formValues, processingType);
+        outputFileName = formValues.outputFileName || outputFileName;
+        embedOutputLayer = !!formValues.embedOutputLayer;
+    }
+    const pixelSize = String((_e = processParam.pixelSize) !== null && _e !== void 0 ? _e : 0.01);
+    const noDataValue = String((_f = processParam.noDataValue) !== null && _f !== void 0 ? _f : 0);
+    const burnValue = String((_g = processParam.burnValue) !== null && _g !== void 0 ? _g : 1);
+    const attributeField = (processParam.attributeField || '').trim();
+    // Compute the min/max of the burned values so the GeoTIFF source can
+    // normalize correctly. gdal_rasterize doesn't write band statistics, so
+    // without this OL falls back to the data-type range (e.g. 0..255).
+    let bandMin;
+    let bandMax;
+    if (attributeField) {
+        const features = ((_j = (_h = JSON.parse(geojsonString)) === null || _h === void 0 ? void 0 : _h.features) !== null && _j !== void 0 ? _j : []);
+        const values = [];
+        for (const f of features) {
+            const v = (_k = f.properties) === null || _k === void 0 ? void 0 : _k[attributeField];
+            const n = typeof v === 'number' ? v : Number(v);
+            if (Number.isFinite(n)) {
+                values.push(n);
+            }
+        }
+        bandMin = values.length ? Math.min(...values) : 0;
+        bandMax = values.length ? Math.max(...values) : 1;
+    }
+    else {
+        // Burn mode: pixels are nodata or burnValue. min/max must be ordered and
+        // non-equal so normalization doesn't divide by zero.
+        const burn = Number(burnValue) || 1;
+        bandMin = Math.min(0, burn);
+        bandMax = Math.max(0, burn) || 1;
+    }
+    const options = [
+        '-of',
+        'GTiff',
+        '-at',
+        '-tr',
+        pixelSize,
+        pixelSize,
+    ];
+    if (attributeField) {
+        options.push('-a', attributeField);
+    }
+    else {
+        options.push('-burn', burnValue);
+    }
+    options.push('-a_nodata', noDataValue);
+    const outputName = 'output.tif';
+    const doRasterize = async () => {
+        if (isServerProcessingEnabled()) {
+            console.debug(`[JupyterGIS] Processing "${processingType}" via SERVER GDAL (${gdalFunction})`);
+            const t0 = performance.now();
+            const response = await runServerProcessing({
+                operation: gdalFunction,
+                options,
+                geojson: geojsonString,
+                outputName,
+            });
+            if (response.format !== 'base64') {
+                throw new Error('Expected base64 response for raster output');
+            }
+            const binary = atob(response.result);
+            const bytes = new Uint8Array(binary.length);
+            for (let i = 0; i < binary.length; i++) {
+                bytes[i] = binary.charCodeAt(i);
+            }
+            console.debug(`[JupyterGIS] SERVER GDAL "${processingType}" finished in ${(performance.now() - t0).toFixed(0)}ms`);
+            return bytes;
+        }
+        else {
+            console.debug(`[JupyterGIS] Processing "${processingType}" via BROWSER WASM GDAL (${gdalFunction})`);
+            const t0 = performance.now();
+            const geoFile = new File([new Blob([geojsonString], { type: 'application/geo+json' })], 'data.geojson', { type: 'application/geo+json' });
+            const Gdal = await getGdal();
+            const result = await Gdal.open(geoFile);
+            const dataset = result.datasets[0];
+            const outputFilePath = await Gdal[gdalFunction](dataset, options, outputName);
+            const bytes = await Gdal.getFileBytes(outputFilePath);
+            Gdal.close(dataset);
+            console.debug(`[JupyterGIS] BROWSER WASM GDAL "${processingType}" finished in ${(performance.now() - t0).toFixed(0)}ms`);
+            return bytes;
+        }
+    };
+    const rasterizePromise = doRasterize();
+    Notification.promise(rasterizePromise.then(() => null), {
+        pending: { message: 'Rasterizing…', options: { autoClose: false } },
+        success: {
+            message: () => `${processingType} completed.`,
+            options: { autoClose: 3000 },
+        },
+        error: {
+            message: (err) => { var _a; return `${processingType} failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`; },
+        },
+    });
+    let tiffBytes;
+    try {
+        tiffBytes = await rasterizePromise;
+    }
+    catch (_l) {
+        return;
+    }
+    const base64Content = await new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            const dataUrl = reader.result;
+            const comma = dataUrl.indexOf(',');
+            resolve(comma >= 0 ? dataUrl.slice(comma + 1) : '');
+        };
+        reader.onerror = () => reject(reader.error);
+        reader.readAsDataURL(new Blob([tiffBytes], { type: 'image/tiff' }));
+    });
+    let sourceUrl;
+    if (embedOutputLayer) {
+        // Embed the GeoTIFF as a data URL inside the .jGIS document.
+        sourceUrl = `data:image/tiff;base64,${base64Content}`;
+    }
+    else {
+        // Save .tif to disk next to the .jGIS project file. If a file already
+        // exists at the chosen path, append `_1`, `_2`, ... so repeated runs don't
+        // overwrite previous outputs.
+        const jgisFilePath = widget.model.filePath;
+        const jgisDir = jgisFilePath
+            ? jgisFilePath.substring(0, jgisFilePath.lastIndexOf('/'))
+            : '';
+        const dotIdx = outputFileName.lastIndexOf('.');
+        const baseName = dotIdx > 0 ? outputFileName.slice(0, dotIdx) : outputFileName;
+        const ext = dotIdx > 0 ? outputFileName.slice(dotIdx) : '';
+        const candidatePath = (name) => jgisDir ? `${jgisDir}/${name}` : name;
+        const pathExists = async (path) => {
+            try {
+                await app.serviceManager.contents.get(path, { content: false });
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        };
+        let suffix = 0;
+        while (await pathExists(candidatePath(suffix === 0 ? outputFileName : `${baseName}_${suffix}${ext}`))) {
+            suffix += 1;
+        }
+        if (suffix > 0) {
+            outputFileName = `${baseName}_${suffix}${ext}`;
+        }
+        const savePath = candidatePath(outputFileName);
+        await app.serviceManager.contents.save(savePath, {
+            type: 'file',
+            format: 'base64',
+            content: base64Content,
+        });
+        sourceUrl = outputFileName;
+    }
+    const newSourceId = UUID.uuid4();
+    const sourceModel = {
+        type: 'GeoTiffSource',
+        name: `${selected.name} Rasterized Source`,
+        parameters: {
+            urls: [
+                { url: sourceUrl, min: bandMin, max: bandMax, nodata: noDataValue },
+            ],
+            normalize: true,
+            wrapX: false,
+            interpolate: false,
+        },
+    };
+    const layerModel = {
+        type: 'GeoTiffLayer',
+        parameters: { source: newSourceId },
+        visible: true,
+        name: `${selected.name} Rasterized`,
+    };
+    model.sharedModel.addSource(newSourceId, sourceModel);
+    model.addLayer(UUID.uuid4(), layerModel);
+}
+/**
+ * Load raw bytes for a GeoTiffSource — handles both embedded data URLs and
+ * file paths resolved relative to the .jGIS document.
+ */
+async function getRasterBytes(source, model, app) {
+    var _a, _b;
+    const params = source.parameters;
+    const url = (_b = (_a = params === null || params === void 0 ? void 0 : params.urls) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.url;
+    if (!url) {
+        return null;
+    }
+    // Embedded data URL
+    if (url.startsWith('data:')) {
+        const commaIdx = url.indexOf(',');
+        if (commaIdx < 0) {
+            return null;
+        }
+        const binary = atob(url.slice(commaIdx + 1));
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes;
+    }
+    // Remote URL — fetch directly
+    if (url.startsWith('http://') || url.startsWith('https://')) {
+        const response = await fetch(url);
+        if (!response.ok) {
+            console.error(`Failed to fetch raster from ${url}: ${response.statusText}`);
+            return null;
+        }
+        const buffer = await response.arrayBuffer();
+        return new Uint8Array(buffer);
+    }
+    // Local file path — resolve relative to the .jGIS document
+    const jgisDir = model.filePath
+        ? model.filePath.substring(0, model.filePath.lastIndexOf('/'))
+        : '';
+    const absolutePath = jgisDir ? `${jgisDir}/${url}` : url;
+    const file = await app.serviceManager.contents.get(absolutePath, {
+        content: true,
+        format: 'base64',
+    });
+    if (!(file === null || file === void 0 ? void 0 : file.content)) {
+        return null;
+    }
+    const binary = atob(file.content);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+/**
+ * Clip a GeoTiff raster layer to a bounding-box extent using gdal_translate -projwin.
+ */
+export async function clipRasterByExtent(tracker, formSchemaRegistry, app, filePath, processingInputs) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+    const widget = filePath
+        ? tracker.find(w => w.model.filePath === filePath)
+        : tracker.currentWidget;
+    if (!widget) {
+        return;
+    }
+    const model = widget.model;
+    const sources = (_a = model.sharedModel.sources) !== null && _a !== void 0 ? _a : {};
+    const layers = (_b = model.sharedModel.layers) !== null && _b !== void 0 ? _b : {};
+    let selected = null;
+    if (processingInputs === null || processingInputs === void 0 ? void 0 : processingInputs.inputLayer) {
+        selected = layers[processingInputs.inputLayer];
+    }
+    else {
+        selected = getSingleSelectedLayer(tracker);
+    }
+    if (!selected) {
+        return;
+    }
+    if (!((_c = selected.parameters) === null || _c === void 0 ? void 0 : _c.source)) {
+        await showErrorMessage('Clip failed', 'Selected layer has no source.');
+        return;
+    }
+    let source = sources[selected.parameters.source];
+    if (!source || source.type !== 'GeoTiffSource') {
+        await showErrorMessage('Clip failed', 'Selected layer is not a GeoTiff raster layer.');
+        return;
+    }
+    let xMin;
+    let yMin;
+    let xMax;
+    let yMax;
+    let outputFileName = `${selected.name.replace(/\s+/g, '_')}_clipped.tif`;
+    let embedOutputLayer = false;
+    if (processingInputs) {
+        xMin = processingInputs.xMin;
+        yMin = processingInputs.yMin;
+        xMax = processingInputs.xMax;
+        yMax = processingInputs.yMax;
+        outputFileName = (_d = processingInputs.outputFileName) !== null && _d !== void 0 ? _d : outputFileName;
+        embedOutputLayer = !!processingInputs.embedOutputLayer;
+    }
+    else {
+        const schema = Object.assign({}, formSchemaRegistry.getSchemas().get('ClipRasterByExtent'));
+        const selectedLayerId = Object.keys(((_f = (_e = model.sharedModel.awareness.getLocalState()) === null || _e === void 0 ? void 0 : _e.selected) === null || _f === void 0 ? void 0 : _f.value) || {})[0];
+        const formValues = await new Promise(resolve => {
+            const dialog = new ProcessingFormDialog({
+                title: 'Clip Raster by Extent',
+                schema,
+                model,
+                sourceData: {
+                    inputLayer: selectedLayerId,
+                    outputFileName,
+                },
+                formContext: 'create',
+                processingType: 'ClipRasterByExtent',
+                syncData: (props) => {
+                    resolve(props);
+                    dialog.dispose();
+                },
+            });
+            dialog.launch();
+        });
+        if (!formValues) {
+            return;
+        }
+        // Re-resolve selected/source in case the user changed inputLayer in the form
+        const resolvedLayerId = (_g = formValues.inputLayer) !== null && _g !== void 0 ? _g : selectedLayerId;
+        if (resolvedLayerId && resolvedLayerId !== selectedLayerId) {
+            const resolvedLayer = layers[resolvedLayerId];
+            if (!((_h = resolvedLayer === null || resolvedLayer === void 0 ? void 0 : resolvedLayer.parameters) === null || _h === void 0 ? void 0 : _h.source)) {
+                await showErrorMessage('Clip failed', 'Selected layer has no source.');
+                return;
+            }
+            const resolvedSource = sources[resolvedLayer.parameters.source];
+            if (!resolvedSource || resolvedSource.type !== 'GeoTiffSource') {
+                await showErrorMessage('Clip failed', 'Selected layer is not a GeoTiff raster layer.');
+                return;
+            }
+            selected = resolvedLayer;
+            source = resolvedSource;
+        }
+        xMin = formValues.xMin;
+        yMin = formValues.yMin;
+        xMax = formValues.xMax;
+        yMax = formValues.yMax;
+        outputFileName = (_j = formValues.outputFileName) !== null && _j !== void 0 ? _j : outputFileName;
+        embedOutputLayer = !!formValues.embedOutputLayer;
+    }
+    const sourceParams = source.parameters;
+    const firstUrl = sourceParams.urls[0];
+    const bandMin = (_k = firstUrl.min) !== null && _k !== void 0 ? _k : 0;
+    const bandMax = (_l = firstUrl.max) !== null && _l !== void 0 ? _l : 1;
+    const nodata = firstUrl.nodata !== undefined ? String(firstUrl.nodata) : undefined;
+    // gdal_translate -projwin: upper-left (xmin, ymax) → lower-right (xmax, ymin)
+    // -projwin_srs EPSG:4326 tells GDAL the coordinates are in WGS84 so it
+    // reprojects them to the raster's native CRS before computing the pixel window.
+    const options = [
+        '-of',
+        'GTiff',
+        '-projwin',
+        String(xMin),
+        String(yMax),
+        String(xMax),
+        String(yMin),
+        '-projwin_srs',
+        'EPSG:4326',
+    ];
+    if (nodata !== undefined) {
+        options.push('-a_nodata', nodata);
+    }
+    const outputName = 'output.tif';
+    const rasterUrl = (_m = firstUrl === null || firstUrl === void 0 ? void 0 : firstUrl.url) !== null && _m !== void 0 ? _m : '';
+    const isRemoteUrl = rasterUrl.startsWith('http://') || rasterUrl.startsWith('https://');
+    const doClip = async () => {
+        if (isRemoteUrl && isServerProcessingEnabled()) {
+            console.debug('[JupyterGIS] Clipping raster by extent via SERVER GDAL (vsicurl)');
+            const t0 = performance.now();
+            const response = await runServerProcessingUrl({
+                operation: 'gdal_translate',
+                options,
+                url: rasterUrl,
+                outputName,
+            });
+            if (response.format !== 'base64') {
+                throw new Error('Expected base64 response for raster output');
+            }
+            const binary = atob(response.result);
+            const bytes = new Uint8Array(binary.length);
+            for (let i = 0; i < binary.length; i++) {
+                bytes[i] = binary.charCodeAt(i);
+            }
+            console.debug(`[JupyterGIS] SERVER GDAL raster clip finished in ${(performance.now() - t0).toFixed(0)}ms`);
+            return bytes;
+        }
+        else {
+            const tiffBytes = await getRasterBytes(source, model, app);
+            if (!tiffBytes) {
+                throw new Error('Could not load raster data from source.');
+            }
+            console.debug('[JupyterGIS] Clipping raster by extent via BROWSER WASM GDAL');
+            const t0 = performance.now();
+            const Gdal = await getGdal();
+            const tiffFile = new File([new Blob([tiffBytes], { type: 'image/tiff' })], 'input.tif', { type: 'image/tiff' });
+            const result = await Gdal.open(tiffFile);
+            if (result.datasets.length === 0) {
+                throw new Error('Failed to open raster in GDAL.');
+            }
+            const dataset = result.datasets[0];
+            const outputPath = await Gdal.gdal_translate(dataset, options, outputName);
+            const bytes = new Uint8Array(await Gdal.getFileBytes(outputPath));
+            Gdal.close(dataset);
+            console.debug(`[JupyterGIS] BROWSER WASM GDAL raster clip finished in ${(performance.now() - t0).toFixed(0)}ms`);
+            return bytes;
+        }
+    };
+    const clipPromise = doClip();
+    Notification.promise(clipPromise.then(() => null), {
+        pending: { message: 'Clipping raster…', options: { autoClose: false } },
+        success: {
+            message: () => 'Raster clipped successfully.',
+            options: { autoClose: 3000 },
+        },
+        error: {
+            message: (err) => { var _a; return `Raster clip failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`; },
+        },
+    });
+    let outputTiffBytes;
+    try {
+        outputTiffBytes = await clipPromise;
+    }
+    catch (_r) {
+        return;
+    }
+    const base64Content = await new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            const dataUrl = reader.result;
+            const comma = dataUrl.indexOf(',');
+            resolve(comma >= 0 ? dataUrl.slice(comma + 1) : '');
+        };
+        reader.onerror = () => reject(reader.error);
+        reader.readAsDataURL(new Blob([outputTiffBytes], { type: 'image/tiff' }));
+    });
+    let sourceUrl;
+    if (embedOutputLayer) {
+        sourceUrl = `data:image/tiff;base64,${base64Content}`;
+    }
+    else {
+        const jgisFilePath = widget.model.filePath;
+        const jgisDir = jgisFilePath
+            ? jgisFilePath.substring(0, jgisFilePath.lastIndexOf('/'))
+            : '';
+        const dotIdx = outputFileName.lastIndexOf('.');
+        const baseName = dotIdx > 0 ? outputFileName.slice(0, dotIdx) : outputFileName;
+        const ext = dotIdx > 0 ? outputFileName.slice(dotIdx) : '';
+        const candidatePath = (name) => jgisDir ? `${jgisDir}/${name}` : name;
+        const pathExists = async (path) => {
+            try {
+                await app.serviceManager.contents.get(path, { content: false });
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        };
+        let suffix = 0;
+        while (await pathExists(candidatePath(suffix === 0 ? outputFileName : `${baseName}_${suffix}${ext}`))) {
+            suffix += 1;
+        }
+        if (suffix > 0) {
+            outputFileName = `${baseName}_${suffix}${ext}`;
+        }
+        const savePath = candidatePath(outputFileName);
+        await app.serviceManager.contents.save(savePath, {
+            type: 'file',
+            format: 'base64',
+            content: base64Content,
+        });
+        sourceUrl = outputFileName;
+    }
+    const newSourceId = UUID.uuid4();
+    const newSource = {
+        type: 'GeoTiffSource',
+        name: `${selected.name} Clipped Source`,
+        parameters: {
+            urls: [{ url: sourceUrl, min: bandMin, max: bandMax, nodata }],
+            normalize: (_o = sourceParams.normalize) !== null && _o !== void 0 ? _o : true,
+            wrapX: (_p = sourceParams.wrapX) !== null && _p !== void 0 ? _p : false,
+            interpolate: (_q = sourceParams.interpolate) !== null && _q !== void 0 ? _q : false,
+        },
+    };
+    const newLayer = {
+        type: 'GeoTiffLayer',
+        parameters: { source: newSourceId },
+        visible: true,
+        name: `${selected.name} Clipped`,
+    };
+    model.sharedModel.addSource(newSourceId, newSource);
+    model.addLayer(UUID.uuid4(), newLayer);
+}
+/**
+ * Clip a GeoTiff raster layer using a vector layer as the cutline.
+ * Uses gdalwarp with -cutline (and optionally -crop_to_cutline).
+ */
+export async function clipRasterByVector(tracker, formSchemaRegistry, app, filePath, processingInputs) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+    const widget = filePath
+        ? tracker.find(w => w.model.filePath === filePath)
+        : tracker.currentWidget;
+    if (!widget) {
+        return;
+    }
+    const model = widget.model;
+    const sources = (_a = model.sharedModel.sources) !== null && _a !== void 0 ? _a : {};
+    const layers = (_b = model.sharedModel.layers) !== null && _b !== void 0 ? _b : {};
+    let selected = null;
+    let inputLayerId;
+    if (processingInputs === null || processingInputs === void 0 ? void 0 : processingInputs.inputLayer) {
+        inputLayerId = processingInputs.inputLayer;
+        selected = (_c = layers[inputLayerId]) !== null && _c !== void 0 ? _c : null;
+    }
+    else {
+        selected = getSingleSelectedLayer(tracker);
+        inputLayerId = Object.keys(((_e = (_d = model.sharedModel.awareness.getLocalState()) === null || _d === void 0 ? void 0 : _d.selected) === null || _e === void 0 ? void 0 : _e.value) || {})[0];
+    }
+    if (!selected) {
+        return;
+    }
+    if (!((_f = selected.parameters) === null || _f === void 0 ? void 0 : _f.source)) {
+        await showErrorMessage('Clip failed', 'Selected layer has no source.');
+        return;
+    }
+    let source = sources[selected.parameters.source];
+    if (!source || source.type !== 'GeoTiffSource') {
+        await showErrorMessage('Clip failed', 'Selected layer is not a GeoTiff raster layer.');
+        return;
+    }
+    let clipLayerId;
+    let cropToCutline = true;
+    let outputFileName = `${selected.name.replace(/\s+/g, '_')}_clipped.tif`;
+    let embedOutputLayer = false;
+    if (processingInputs) {
+        clipLayerId = processingInputs.clipLayer;
+        cropToCutline = (_g = processingInputs.cropToCutline) !== null && _g !== void 0 ? _g : true;
+        outputFileName = (_h = processingInputs.outputFileName) !== null && _h !== void 0 ? _h : outputFileName;
+        embedOutputLayer = !!processingInputs.embedOutputLayer;
+    }
+    else {
+        const schema = Object.assign({}, formSchemaRegistry.getSchemas().get('ClipRasterByVector'));
+        const formValues = await new Promise(resolve => {
+            const dialog = new ProcessingFormDialog({
+                title: 'Clip Raster by Vector',
+                schema,
+                model,
+                sourceData: {
+                    inputLayer: inputLayerId,
+                    outputFileName,
+                    cropToCutline: true,
+                },
+                formContext: 'create',
+                processingType: 'ClipRasterByVector',
+                syncData: (props) => {
+                    resolve(props);
+                    dialog.dispose();
+                },
+            });
+            dialog.launch();
+        });
+        if (!formValues) {
+            return;
+        }
+        // Re-resolve the selected raster if the user changed inputLayer in the form
+        const resolvedLayerId = (_j = formValues.inputLayer) !== null && _j !== void 0 ? _j : inputLayerId;
+        if (resolvedLayerId && resolvedLayerId !== inputLayerId) {
+            const resolvedLayer = layers[resolvedLayerId];
+            if (!((_k = resolvedLayer === null || resolvedLayer === void 0 ? void 0 : resolvedLayer.parameters) === null || _k === void 0 ? void 0 : _k.source)) {
+                await showErrorMessage('Clip failed', 'Selected layer has no source.');
+                return;
+            }
+            const resolvedSource = sources[resolvedLayer.parameters.source];
+            if (!resolvedSource || resolvedSource.type !== 'GeoTiffSource') {
+                await showErrorMessage('Clip failed', 'Selected layer is not a GeoTiff raster layer.');
+                return;
+            }
+            selected = resolvedLayer;
+            source = resolvedSource;
+        }
+        clipLayerId = formValues.clipLayer;
+        cropToCutline = (_l = formValues.cropToCutline) !== null && _l !== void 0 ? _l : true;
+        outputFileName = (_m = formValues.outputFileName) !== null && _m !== void 0 ? _m : outputFileName;
+        embedOutputLayer = !!formValues.embedOutputLayer;
+    }
+    const clipLayer = layers[clipLayerId];
+    if (!clipLayer) {
+        await showErrorMessage('Clip failed', 'Clip layer not found.');
+        return;
+    }
+    const clipGeoJSON = await getLayerGeoJSON(clipLayer, sources, model);
+    if (!clipGeoJSON) {
+        await showErrorMessage('Clip failed', 'Could not read the clip layer geometry.');
+        return;
+    }
+    const sourceParams = source.parameters;
+    const firstUrl = sourceParams.urls[0];
+    const bandMin = (_o = firstUrl.min) !== null && _o !== void 0 ? _o : 0;
+    const bandMax = (_p = firstUrl.max) !== null && _p !== void 0 ? _p : 1;
+    const nodata = firstUrl.nodata !== undefined ? String(firstUrl.nodata) : undefined;
+    const outputName = 'output.tif';
+    const rasterUrl = (_q = firstUrl === null || firstUrl === void 0 ? void 0 : firstUrl.url) !== null && _q !== void 0 ? _q : '';
+    const isRemoteUrl = rasterUrl.startsWith('http://') || rasterUrl.startsWith('https://');
+    // Cutline GeoJSON is assumed to be in EPSG:4326 (the canonical projection
+    // for JupyterGIS sources). gdalwarp will reproject it to the raster's CRS
+    // when -cutline_srs is provided.
+    //
+    // Output is written as a Cloud-Optimized GeoTIFF so the clipped layer
+    // renders fast in OpenLayers via pyramid overviews instead of forcing the
+    // browser to read every full-resolution strip. Multi-threaded warping
+    // (-wo NUM_THREADS=ALL_CPUS, -multi) saturates available CPUs and overlaps
+    // I/O with compute, which dominates runtime for /vsicurl/ COG sources.
+    const buildOptions = (cutlinePath) => {
+        const opts = [
+            // /vsicurl/ tuning. Defaults are tiny (16 KB chunks, 16 MB cache) which
+            // forces hundreds of tiny range requests per warp. The flags below:
+            //   - prefer HTTP/2 + multiplex so range requests run concurrently
+            //   - merge nearby ranges into single fetches
+            //   - skip directory listing / HEAD probes that S3 doesn't need
+            //   - bump per-read chunk to 1 MB and the vsicurl cache to 512 MB
+            // No effect for non-URL sources, all harmless.
+            '--config',
+            'GDAL_HTTP_VERSION',
+            '2',
+            '--config',
+            'GDAL_HTTP_MULTIPLEX',
+            'YES',
+            '--config',
+            'GDAL_HTTP_MERGE_CONSECUTIVE_RANGES',
+            'YES',
+            '--config',
+            'GDAL_DISABLE_READDIR_ON_OPEN',
+            'EMPTY_DIR',
+            '--config',
+            'CPL_VSIL_CURL_USE_HEAD',
+            'NO',
+            '--config',
+            'CPL_VSIL_CURL_CHUNK_SIZE',
+            '1048576',
+            '--config',
+            'CPL_VSIL_CURL_CACHE_SIZE',
+            '536870912',
+            // Block-level cache for decoded raster data.
+            '--config',
+            'GDAL_CACHEMAX',
+            '1024',
+            '-of',
+            'COG',
+            // LZW compresses faster than DEFLATE (and decompresses fast on the
+            // client side too). Slightly larger output files, but the user's
+            // bottleneck is wall-clock time, not disk.
+            '-co',
+            'COMPRESS=LZW',
+            '-co',
+            'BIGTIFF=IF_SAFER',
+            // Parallel warp + 1 GB warp memory so each pass covers a larger output
+            // area, reducing the number of /vsicurl/ round-trips.
+            '-multi',
+            '-wo',
+            'NUM_THREADS=ALL_CPUS',
+            '-wm',
+            '1024',
+            '-cutline',
+            cutlinePath,
+            '-cutline_srs',
+            'EPSG:4326',
+        ];
+        if (cropToCutline) {
+            opts.push('-crop_to_cutline');
+        }
+        if (nodata !== undefined) {
+            opts.push('-dstnodata', nodata);
+        }
+        return opts;
+    };
+    const doClip = async () => {
+        if (isRemoteUrl && isServerProcessingEnabled()) {
+            // {cutlinePath} is substituted by the server with the temp path of the
+            // cutline file it writes from `cutlineGeojson`.
+            const response = await runServerProcessingUrlWithCutline({
+                operation: 'gdalwarp',
+                options: buildOptions('{cutlinePath}'),
+                url: rasterUrl,
+                cutlineGeojson: clipGeoJSON,
+                outputName,
+            });
+            if (response.format !== 'base64') {
+                throw new Error('Expected base64 response for raster output');
+            }
+            const binary = atob(response.result);
+            const bytes = new Uint8Array(binary.length);
+            for (let i = 0; i < binary.length; i++) {
+                bytes[i] = binary.charCodeAt(i);
+            }
+            return bytes;
+        }
+        else {
+            const tiffBytes = await getRasterBytes(source, model, app);
+            if (!tiffBytes) {
+                throw new Error('Could not load raster data from source.');
+            }
+            console.debug('[JupyterGIS] Clipping raster by vector via BROWSER WASM GDAL');
+            const t0 = performance.now();
+            const Gdal = await getGdal();
+            // Open both the raster and the cutline. gdal3.js writes each into the
+            // WASM virtual filesystem; we reference the cutline by its VFS path.
+            const tiffFile = new File([new Blob([tiffBytes], { type: 'image/tiff' })], 'input.tif', { type: 'image/tiff' });
+            const cutlineFile = new File([new Blob([clipGeoJSON], { type: 'application/geo+json' })], 'cutline.geojson', { type: 'application/geo+json' });
+            const rasterOpen = await Gdal.open(tiffFile);
+            if (rasterOpen.datasets.length === 0) {
+                throw new Error('Failed to open raster in GDAL.');
+            }
+            const rasterDataset = rasterOpen.datasets[0];
+            const cutlineOpen = await Gdal.open(cutlineFile);
+            if (cutlineOpen.datasets.length === 0) {
+                Gdal.close(rasterDataset);
+                throw new Error('Failed to open cutline in GDAL.');
+            }
+            const cutlineDataset = cutlineOpen.datasets[0];
+            try {
+                const options = buildOptions(cutlineDataset.path);
+                const outputPath = await Gdal.gdalwarp(rasterDataset, options, outputName);
+                const bytes = new Uint8Array(await Gdal.getFileBytes(outputPath));
+                console.debug(`[JupyterGIS] BROWSER WASM GDAL raster clip-by-vector finished in ${(performance.now() - t0).toFixed(0)}ms`);
+                return bytes;
+            }
+            finally {
+                Gdal.close(rasterDataset);
+                Gdal.close(cutlineDataset);
+            }
+        }
+    };
+    const clipPromise = doClip();
+    Notification.promise(clipPromise.then(() => null), {
+        pending: { message: 'Clipping raster…', options: { autoClose: false } },
+        success: {
+            message: () => 'Raster clipped successfully.',
+            options: { autoClose: 3000 },
+        },
+        error: {
+            message: (err) => { var _a; return `Raster clip failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`; },
+        },
+    });
+    let outputTiffBytes;
+    try {
+        outputTiffBytes = await clipPromise;
+    }
+    catch (_u) {
+        return;
+    }
+    const base64Content = await new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            const dataUrl = reader.result;
+            const comma = dataUrl.indexOf(',');
+            resolve(comma >= 0 ? dataUrl.slice(comma + 1) : '');
+        };
+        reader.onerror = () => reject(reader.error);
+        reader.readAsDataURL(new Blob([outputTiffBytes], { type: 'image/tiff' }));
+    });
+    let sourceUrl;
+    if (embedOutputLayer) {
+        sourceUrl = `data:image/tiff;base64,${base64Content}`;
+    }
+    else {
+        const jgisFilePath = widget.model.filePath;
+        const jgisDir = jgisFilePath
+            ? jgisFilePath.substring(0, jgisFilePath.lastIndexOf('/'))
+            : '';
+        const dotIdx = outputFileName.lastIndexOf('.');
+        const baseName = dotIdx > 0 ? outputFileName.slice(0, dotIdx) : outputFileName;
+        const ext = dotIdx > 0 ? outputFileName.slice(dotIdx) : '';
+        const candidatePath = (name) => jgisDir ? `${jgisDir}/${name}` : name;
+        const pathExists = async (path) => {
+            try {
+                await app.serviceManager.contents.get(path, { content: false });
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        };
+        let suffix = 0;
+        while (await pathExists(candidatePath(suffix === 0 ? outputFileName : `${baseName}_${suffix}${ext}`))) {
+            suffix += 1;
+        }
+        if (suffix > 0) {
+            outputFileName = `${baseName}_${suffix}${ext}`;
+        }
+        const savePath = candidatePath(outputFileName);
+        await app.serviceManager.contents.save(savePath, {
+            type: 'file',
+            format: 'base64',
+            content: base64Content,
+        });
+        sourceUrl = outputFileName;
+    }
+    const newSourceId = UUID.uuid4();
+    const newSource = {
+        type: 'GeoTiffSource',
+        name: `${selected.name} Clipped Source`,
+        parameters: {
+            urls: [{ url: sourceUrl, min: bandMin, max: bandMax, nodata }],
+            normalize: (_r = sourceParams.normalize) !== null && _r !== void 0 ? _r : true,
+            wrapX: (_s = sourceParams.wrapX) !== null && _s !== void 0 ? _s : false,
+            interpolate: (_t = sourceParams.interpolate) !== null && _t !== void 0 ? _t : false,
+        },
+    };
+    const newLayer = {
+        type: 'GeoTiffLayer',
+        parameters: { source: newSourceId },
+        visible: true,
+        name: `${selected.name} Clipped`,
+    };
+    model.sharedModel.addSource(newSourceId, newSource);
+    model.addLayer(UUID.uuid4(), newLayer);
+}
+/**
+ * Compute the WKT of the union of all features in a GeoJSON string using WASM GDAL.
+ */
+async function computeUnionWkt(geojsonString) {
+    const Gdal = await getGdal();
+    const file = new File([new Blob([geojsonString], { type: 'application/geo+json' })], 'clip_data.geojson', { type: 'application/geo+json' });
+    const result = await Gdal.open(file);
+    if (result.datasets.length === 0) {
+        return null;
+    }
+    const dataset = result.datasets[0];
+    const layerName = dataset.info.layers[0].name;
+    const options = [
+        '-f',
+        'CSV',
+        '-dialect',
+        'SQLITE',
+        '-sql',
+        `SELECT ST_AsText(ST_Union(geometry)) AS wkt FROM "${layerName}"`,
+        'clip_union.csv',
+    ];
+    const outputPath = await Gdal.ogr2ogr(dataset, options);
+    const bytes = await Gdal.getFileBytes(outputPath);
+    Gdal.close(dataset);
+    const csv = new TextDecoder().decode(bytes);
+    const lines = csv.split('\n').filter((l) => l.trim());
+    if (lines.length < 2) {
+        return null;
+    }
+    // ogr2ogr CSV wraps fields containing commas in double-quotes; strip them
+    let wkt = lines[1].trim();
+    if (wkt.startsWith('"') && wkt.endsWith('"')) {
+        wkt = wkt.slice(1, -1).replace(/""/g, '"');
+    }
+    return wkt || null;
+}
+/**
+ * Clip a vector layer by another vector layer using ST_Intersection.
+ */
+export async function clipVectorByMaskLayer(tracker, formSchemaRegistry, app, filePath, processingInputs) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const widget = filePath
+        ? tracker.find(w => w.model.filePath === filePath)
+        : tracker.currentWidget;
+    if (!widget) {
+        return;
+    }
+    const model = widget.model;
+    const sources = (_a = model.sharedModel.sources) !== null && _a !== void 0 ? _a : {};
+    const layers = (_b = model.sharedModel.layers) !== null && _b !== void 0 ? _b : {};
+    let selected = null;
+    let inputLayerId;
+    if (processingInputs === null || processingInputs === void 0 ? void 0 : processingInputs.inputLayer) {
+        inputLayerId = processingInputs.inputLayer;
+        selected = (_c = layers[inputLayerId]) !== null && _c !== void 0 ? _c : null;
+    }
+    else {
+        selected = getSingleSelectedLayer(tracker);
+        inputLayerId = Object.keys(((_e = (_d = model.sharedModel.awareness.getLocalState()) === null || _d === void 0 ? void 0 : _d.selected) === null || _e === void 0 ? void 0 : _e.value) || {})[0];
+    }
+    if (!selected) {
+        return;
+    }
+    const inputGeoJSON = await getLayerGeoJSON(selected, sources, model);
+    if (!inputGeoJSON) {
+        return;
+    }
+    let clipLayerId;
+    let embedOutputLayer = true;
+    let outputLayerName = `${selected.name} Clipped`;
+    if (processingInputs) {
+        clipLayerId = processingInputs.clipLayer;
+        embedOutputLayer = (_f = processingInputs.embedOutputLayer) !== null && _f !== void 0 ? _f : true;
+        outputLayerName =
+            (_g = processingInputs.outputLayerName) !== null && _g !== void 0 ? _g : `${selected.name} Clipped`;
+    }
+    else {
+        const schema = Object.assign({}, formSchemaRegistry
+            .getSchemas()
+            .get('ClipVectorByMaskLayer'));
+        const formValues = await new Promise(resolve => {
+            const dialog = new ProcessingFormDialog({
+                title: 'Clip',
+                schema,
+                model,
+                sourceData: {
+                    inputLayer: inputLayerId,
+                    outputLayerName: `${selected.name} Clipped`,
+                },
+                formContext: 'create',
+                processingType: 'ClipVectorByMaskLayer',
+                syncData: (props) => {
+                    resolve(props);
+                    dialog.dispose();
+                },
+            });
+            dialog.launch();
+        });
+        if (!formValues) {
+            return;
+        }
+        clipLayerId = formValues.clipLayer;
+        embedOutputLayer = formValues.embedOutputLayer;
+        outputLayerName = formValues.outputLayerName;
+    }
+    if (clipLayerId === inputLayerId) {
+        await showErrorMessage('Clip failed', 'The clip layer and input layer must be different.');
+        return;
+    }
+    const clipLayer = layers[clipLayerId];
+    if (!clipLayer) {
+        await showErrorMessage('Clip failed', 'Clip layer not found.');
+        return;
+    }
+    const clipGeoJSON = await getLayerGeoJSON(clipLayer, sources, model);
+    if (!clipGeoJSON) {
+        await showErrorMessage('Clip failed', 'Could not read the clip layer geometry.');
+        return;
+    }
+    const clipWkt = await computeUnionWkt(clipGeoJSON);
+    if (!clipWkt) {
+        await showErrorMessage('Clip failed', 'Could not compute clip boundary geometry. The clip layer may be empty.');
+        return;
+    }
+    const Gdal = await getGdal();
+    const inputFile = new File([new Blob([inputGeoJSON], { type: 'application/geo+json' })], 'data.geojson', { type: 'application/geo+json' });
+    const openResult = await Gdal.open(inputFile);
+    const dataset = openResult.datasets[0];
+    const inputLayerName = dataset.info.layers[0].name;
+    Gdal.close(dataset);
+    const escapedWkt = clipWkt.replace(/'/g, "''");
+    const sql = `SELECT ST_Intersection(geometry, ST_GeomFromText('${escapedWkt}')) AS geometry, * FROM "${inputLayerName}" WHERE ST_Intersects(geometry, ST_GeomFromText('${escapedWkt}'))`;
+    const options = [
+        '-f',
+        'GeoJSON',
+        '-dialect',
+        'SQLITE',
+        '-sql',
+        sql,
+        '{outputName}',
+    ];
+    await executeSQLProcessing(model, inputGeoJSON, 'ogr2ogr', options, outputLayerName, 'ClipVectorByMaskLayer', embedOutputLayer, tracker, app, outputLayerName);
+}
+export async function executeSQLProcessing(model, geojsonString, gdalFunction, options, layerNamePrefix, processingType, embedOutputLayer, tracker, app, exactLayerName) {
+    var _a;
+    const doProcessing = async () => {
+        if (isServerProcessingEnabled()) {
+            console.debug(`[JupyterGIS] Processing "${processingType}" via SERVER GDAL (${gdalFunction})`);
+            const t0 = performance.now();
+            const outputName = 'output.geojson';
+            const response = await runServerProcessing({
+                operation: gdalFunction,
+                options,
+                geojson: geojsonString,
+                outputName,
+            });
+            console.debug(`[JupyterGIS] SERVER GDAL "${processingType}" finished in ${(performance.now() - t0).toFixed(0)}ms`);
+            return response.result;
+        }
+        else {
+            console.debug(`[JupyterGIS] Processing "${processingType}" via BROWSER WASM GDAL (${gdalFunction})`);
+            const t0 = performance.now();
+            const geoFile = new File([new Blob([geojsonString], { type: 'application/geo+json' })], 'data.geojson', { type: 'application/geo+json' });
+            const Gdal = await getGdal();
+            const result = await Gdal.open(geoFile);
+            if (result.datasets.length === 0) {
+                throw new Error('Could not open layer in GDAL.');
+            }
+            const dataset = result.datasets[0];
+            const wasmOptions = options.map(o => o.replace('{outputName}', 'output.geojson'));
+            const outputFilePath = await Gdal[gdalFunction](dataset, wasmOptions);
+            const processedBytes = await Gdal.getFileBytes(outputFilePath);
+            const output = new TextDecoder().decode(processedBytes);
+            Gdal.close(dataset);
+            console.debug(`[JupyterGIS] BROWSER WASM GDAL "${processingType}" finished in ${(performance.now() - t0).toFixed(0)}ms`);
+            return output;
+        }
+    };
+    const processingPromise = doProcessing();
+    Notification.promise(processingPromise.then(() => null), {
+        pending: {
+            message: `Running ${processingType}…`,
+            options: { autoClose: false },
+        },
+        success: {
+            message: () => `${processingType} completed.`,
+            options: { autoClose: 3000 },
+        },
+        error: {
+            message: (err) => { var _a; return `${processingType} failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`; },
+        },
+    });
+    let processedGeoJSONString;
+    try {
+        processedGeoJSONString = await processingPromise;
+    }
+    catch (_b) {
+        return;
+    }
+    const layerName = exactLayerName !== null && exactLayerName !== void 0 ? exactLayerName : `${layerNamePrefix} ${processingType.charAt(0).toUpperCase() + processingType.slice(1)}`;
+    if (!embedOutputLayer) {
+        // Save the output as a file
+        const jgisFilePath = (_a = tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.model.filePath;
+        const jgisDir = jgisFilePath
+            ? jgisFilePath.substring(0, jgisFilePath.lastIndexOf('/'))
+            : '';
+        const outputFileName = `${layerNamePrefix}_${processingType}.json`;
+        const savePath = jgisDir ? `${jgisDir}/${outputFileName}` : outputFileName;
+        await app.serviceManager.contents.save(savePath, {
+            type: 'file',
+            format: 'text',
+            content: processedGeoJSONString,
+        });
+        const newSourceId = UUID.uuid4();
+        const sourceModel = {
+            type: 'GeoJSONSource',
+            name: outputFileName,
+            parameters: {
+                path: outputFileName,
+            },
+        };
+        const layerModel = {
+            type: 'VectorLayer',
+            parameters: { source: newSourceId },
+            visible: true,
+            name: layerName,
+        };
+        model.sharedModel.addSource(newSourceId, sourceModel);
+        model.addLayer(UUID.uuid4(), layerModel);
+    }
+    else {
+        // Embed the output directly into the model
+        const processedGeoJSON = JSON.parse(processedGeoJSONString);
+        const newSourceId = UUID.uuid4();
+        const sourceModel = {
+            type: 'GeoJSONSource',
+            name: `${layerName} Source`,
+            parameters: { data: processedGeoJSON },
+        };
+        const layerModel = {
+            type: 'VectorLayer',
+            parameters: { source: newSourceId },
+            visible: true,
+            name: layerName,
+        };
+        model.sharedModel.addSource(newSourceId, sourceModel);
+        model.addLayer(UUID.uuid4(), layerModel);
+    }
+}