@walkthru-earth/objex 1.1.0 → 1.2.1

package/dist/components/viewers/TableViewer.svelte

@@ -2,15 +2,24 @@
 import { format as formatSql } from 'sql-formatter';
 import { untrack } from 'svelte';
 import CodeMirrorEditor from '../editor/CodeMirrorEditor.svelte';
-import { buildDuckDbSource, isCloudNativeFormat } from '../../file-icons/index.js';
+import { DEFAULT_TARGET_CRS } from '../../constants.js';
+import { isCloudNativeFormat } from '../../file-icons/index.js';
 import { t } from '../../i18n/index.svelte.js';
 import type { MapQueryResult, SchemaField } from '../../query/engine';
-import { getQueryEngine, QueryCancelledError, type QueryHandle } from '../../query/index.js';
+import {
+	getQueryEngine,
+	QueryCancelledError,
+	type QueryHandle,
+	type ResolvedTableSource,
+	resolveTableSource,
+	resolveTableSourceAsync
+} from '../../query/index.js';
 import { queryHistory } from '../../stores/query-history.svelte.js';
 import { settings } from '../../stores/settings.svelte.js';
 import { tabResources } from '../../stores/tab-resources.svelte.js';
 import type { Tab } from '../../types';
 import type { GeoArrowGeomType } from '../../utils/geoarrow.js';
+import { buildTransformExpr, wrapWkbWithCrs } from '../../utils/geometry-type.js';
 import {
 	extractBounds,
 	extractEpsgFromGeoMeta,
@@ -53,6 +62,8 @@ let viewMode = $state<'table' | 'map' | 'stac' | 'info'>(
 );
 let sqlQuery = $state('');
 let customSql = $state('');
+// Presigned URL for the source-cooperative parquet-table iframe (external fetcher).
+let parquetIframeUrl = $state('');
 let queryRunning = $state(false);
 let executionTimeMs = $state(0);
 
@@ -90,27 +101,28 @@ const columnTypes = $derived(Object.fromEntries(schema.map((f) => [f.name, f.typ
 // Columns for display — exclude internal __wkb helper
 const displayColumns = $derived(columns.filter((c) => c !== '__wkb'));
 
-function buildDefaultSql(offset = 0): string {
-	const fileUrl = buildDuckDbUrl(tab);
-	const source = buildDuckDbSource(tab.path, fileUrl);
+let resolvedSource: ResolvedTableSource | null = null;
+
+function buildDefaultSql(
+	offset = 0,
+	resolved: ResolvedTableSource = resolvedSource ?? resolveTableSource(tab)
+): string {
+	const source = resolved.ref;
 
 	let sql: string;
 	if (geoCol) {
 		const quoted = `"${geoCol}"`;
 		const upper = geoColType.toUpperCase();
-		// Spatial types that ST_AsWKB accepts directly (GEOMETRY, WKB_BLOB, etc.).
-		// Includes Arrow "Binary"/"LargeBinary" — DuckDB GEOMETRY columns from
-		// ST_ReadSHP/ST_Read appear as Arrow Binary but are NOT WKB blobs.
-		const isSpatialType =
-			upper === 'GEOMETRY' ||
-			upper === 'GEOGRAPHY' ||
+		// Spatial types that ST_AsWKB accepts directly: GEOMETRY, GEOMETRY('EPSG:...'),
+		// GEOGRAPHY, WKB_BLOB, POINT, LINESTRING, POLYGON, Binary (Arrow serialization).
+		const spatialType =
+			upper.startsWith('GEOMETRY') ||
+			upper.startsWith('GEOGRAPHY') ||
 			upper === 'WKB_BLOB' ||
 			upper.includes('POINT') ||
 			upper.includes('LINESTRING') ||
 			upper.includes('POLYGON') ||
-			upper.includes('BINARY'); // Arrow serialization of DuckDB GEOMETRY
-		// Actual WKB BLOB columns (e.g. GeoParquet) need explicit ST_GeomFromWKB
-		// because DuckDB has no implicit BLOB→GEOMETRY cast.
+			upper.includes('BINARY');
 		const isWkbBlob = upper === 'BLOB' || upper === 'BYTEA';
 
 		let wkbExpr: string;
@@ -118,13 +130,17 @@ function buildDefaultSql(offset = 0): string {
 			// Already WKB — use directly, no conversion needed
 			wkbExpr = `${quoted} AS __wkb`;
 		} else {
-			let geomExpr = isSpatialType
+			// For BLOB inputs with a known source CRS, attach it via ST_SetCRS so the
+			// 2-arg ST_Transform form can be used (DuckDB v1.5+).
+			let geomExpr = spatialType
 				? quoted
 				: isWkbBlob
-					? `ST_GeomFromWKB(${quoted})`
+					? wrapWkbWithCrs(quoted, sourceCrs)
 					: `ST_GeomFromGeoJSON(${quoted})`;
 			if (sourceCrs) {
-				geomExpr = `ST_Transform(${geomExpr}, '${sourceCrs}', 'EPSG:4326', always_xy := true)`;
+				// geometry_always_xy is set globally at DB init, so no per-call always_xy.
+				const effectiveType = isWkbBlob ? `GEOMETRY('${sourceCrs}')` : geoColType;
+				geomExpr = buildTransformExpr(geomExpr, effectiveType, sourceCrs, DEFAULT_TARGET_CRS);
 			}
 			wkbExpr = `ST_AsWKB(${geomExpr}) AS __wkb`;
 		}
@@ -195,6 +211,8 @@ $effect(() => {
 		geoCol = null;
 		knownGeomType = undefined;
 		metadataBounds = null;
+		resolvedSource = null;
+		parquetIframeUrl = '';
 		error = null;
 	});
 	return unregister;
@@ -259,6 +277,10 @@ async function forceCancel() {
 
 async function loadTable() {
 	const thisGen = ++loadGeneration;
+	// Snapshot reactive values once. Reading `$derived` across awaits after the
+	// component's effect is torn down returns Svelte's destroyed-signal sentinel,
+	// which throws "can't convert symbol to string" in downstream template literals.
+	const cid = connId;
 
 	// Cancel in-flight query from a previous load to prevent duplicate concurrent queries
 	if (activeHandle) {
@@ -278,25 +300,41 @@ async function loadTable() {
 	loadStage = t('table.preparingQuery');
 	loadProgress = [];
 
-	// Set SQL eagerly so editor shows the query while loading
-	const initialSql = buildDefaultSql(0);
-	sqlQuery = initialSql;
-	customSql = initialSql;
+	resolvedSource = null;
+	const eagerSql = buildDefaultSql(0);
+	sqlQuery = eagerSql;
+	customSql = eagerSql;
 
 	try {
-		const fileUrl = buildDuckDbUrl(tab);
-		const httpsUrl = buildHttpsUrl(tab);
-		const cloudNative = isCloudNativeFormat(tab.path);
-		const isParquet = /\.parquet$/i.test(tab.path);
-		const streamable = canStreamDirectly(tab);
+		const resolved: ResolvedTableSource = await resolveTableSourceAsync(tab);
+		if (thisGen !== loadGeneration) return;
+		resolvedSource = resolved;
+		const resolvedSql = buildDefaultSql(0, resolved);
+		sqlQuery = resolvedSql;
+		// Only overwrite the editor if the user hasn't edited it during the presign await.
+		if (customSql === eagerSql) customSql = resolvedSql;
+		const isFileSource = resolved.isFileSource;
+		const fileUrl = resolved.fileUrl ?? '';
+		const httpsUrl = isFileSource ? buildHttpsUrl(tab) : '';
+		const cloudNative = isFileSource && isCloudNativeFormat(tab.path);
+		const isParquet = isFileSource && /\.parquet$/i.test(tab.path);
+		const streamable = isFileSource && canStreamDirectly(tab);
+
+		// Parquet-table iframe fetches from its own origin. `resolved.fileUrl`
+		// is already the presigned HTTPS URL for signed-s3 (or the public URL
+		// for anonymous / SAS), so reuse it instead of signing a second time.
+		if (isParquet) parquetIframeUrl = fileUrl;
 
 		// Start DuckDB boot immediately (runs in parallel with hyparquet)
 		loadStage = t('table.initEngine');
 		const enginePromise = getQueryEngine();
 
 		// ── Fast metadata via hyparquet (runs concurrently with DuckDB boot) ──
+		// Only applies to file-backed sources. SQL-backed sources (attached
+		// DuckLake tables, etc.) go straight to DuckDB for schema + CRS.
 		let metaFromHyparquet = false;
 		let needsDuckDbCrs = false;
+		let isLegacyGeoParquet = false;
 		if (cloudNative && isParquet && streamable) {
 			try {
 				loadStage = t('table.readingMetadata');
@@ -357,11 +395,9 @@ async function loadTable() {
 
 				if (meta.geo) {
 					geoCol = meta.geo.primaryColumn;
-					// With enable_geoparquet_conversion=false, DuckDB reads ALL
-					// GeoParquet geometry columns as BLOB regardless of Parquet
-					// logical type. Native Parquet GEOMETRY (Format 2.11+) is a
-					// DuckDB v1.5 feature not yet in WASM (v1.33).
-					geoColType = 'BLOB';
+					// DuckDB v1.5 reads GeoParquet columns as GEOMETRY('EPSG:...').
+					// Set GEOMETRY here as placeholder — DuckDB schema will refine.
+					geoColType = 'GEOMETRY';
 					sourceCrs = extractEpsgFromGeoMeta(meta.geo);
 					const geomTypes = extractGeometryTypes(meta.geo);
 					if (geomTypes.length === 1) knownGeomType = geomTypes[0];
@@ -401,9 +437,8 @@ async function loadTable() {
 					const detectedGeoCol = findGeoColumn(schema);
 					if (detectedGeoCol) {
 						geoCol = detectedGeoCol;
-						// DuckDB WASM v1.33 doesn't support native Parquet GEOMETRY —
-						// columns are always BLOB with enable_geoparquet_conversion=false.
-						geoColType = 'BLOB';
+						// DuckDB v1.5 reads native Parquet GEOMETRY natively.
+						geoColType = 'GEOMETRY';
 						needsDuckDbCrs = true;
 						loadProgress = [
 							...loadProgress,
@@ -420,6 +455,7 @@ async function loadTable() {
 						{ label: t('progress.format'), value: t('progress.stacDetected') }
 					];
 				}
+				isLegacyGeoParquet = meta.legacyGeoParquet;
 				metaFromHyparquet = true;
 			} catch {
 				// hyparquet failed (CORS, auth, format) — fall back to DuckDB
@@ -431,11 +467,54 @@ async function loadTable() {
 		const engine = await enginePromise;
 		if (thisGen !== loadGeneration) return;
 
+		// Legacy GeoParquet (geopandas <0.12) — files with schema_version but no
+		// "version" field. DuckDB v1.5 may reject these with auto-conversion enabled.
+		// Disable conversion for this connection and fall back to BLOB handling.
+		if (metaFromHyparquet && isLegacyGeoParquet && geoCol) {
+			try {
+				await engine.query(cid, 'SET enable_geoparquet_conversion = false');
+				geoColType = 'BLOB';
+			} catch {
+				// Setting failed — DuckDB may still handle it gracefully
+			}
+		}
+
+		// DuckDB v1.5: refresh geoColType from DuckDB's actual schema.
+		// hyparquet reports BLOB for the physical Parquet type, but DuckDB v1.5
+		// reads GeoParquet as GEOMETRY('EPSG:...') with CRS embedded in the type.
+		if (metaFromHyparquet && geoCol && !isLegacyGeoParquet) {
+			try {
+				const duckSchema = await engine.getSchema(cid, resolved);
+				if (thisGen !== loadGeneration) return;
+				const duckGeoField = duckSchema.find((f: { name: string }) => f.name === geoCol);
+				if (duckGeoField) {
+					geoColType = duckGeoField.type;
+					// Extract CRS from type string — may override hyparquet CRS detection
+					const typeStr = duckGeoField.type.toUpperCase();
+					const crsMatch = duckGeoField.type.match(/^GEOMETRY\('([^']+)'\)/i);
+					if (crsMatch) {
+						const crsVal = crsMatch[1];
+						const isWgs84 =
+							crsVal === 'EPSG:4326' ||
+							crsVal === 'OGC:CRS84' ||
+							(crsVal.startsWith('EPSG:') && [4326, 4979].includes(Number(crsVal.split(':')[1])));
+						sourceCrs = isWgs84 ? null : crsVal;
+						needsDuckDbCrs = false;
+					} else if (typeStr.startsWith('GEOMETRY')) {
+						// GEOMETRY without CRS param — still need CRS from metadata
+						needsDuckDbCrs = !sourceCrs;
+					}
+				}
+			} catch {
+				// Schema refresh failed — continue with hyparquet-detected type
+			}
+		}
+
 		// If hyparquet detected a geo column but couldn't determine CRS
 		// (native Parquet GEOMETRY without "geo" KV metadata), use DuckDB
 		if (metaFromHyparquet && needsDuckDbCrs && geoCol) {
 			try {
-				sourceCrs = await engine.detectCrs(connId, fileUrl, geoCol);
+				sourceCrs = await engine.detectCrs(cid, resolved, geoCol);
 				if (thisGen !== loadGeneration) return;
 				if (sourceCrs) {
 					loadProgress = [...loadProgress, { label: t('progress.crs'), value: sourceCrs }];
@@ -450,16 +529,22 @@ async function loadTable() {
 			}
 		}
 
-		if (cloudNative && !metaFromHyparquet) {
-			// Fallback: DuckDB metadata queries
+		// DuckDB-backed schema + CRS pre-load. Runs when:
+		//   - the source is SQL-backed (attached table, no hyparquet path), OR
+		//   - it's a cloud-native file and hyparquet metadata failed (CORS, etc.)
+		if (!isFileSource || (cloudNative && !metaFromHyparquet)) {
+			// Fallback / SQL source: DuckDB metadata queries
 			loadStage = t('table.loadingSchema');
 			loadProgress = [
 				...loadProgress,
-				{ label: t('progress.source'), value: t('progress.duckdbFallback') }
+				{
+					label: t('progress.source'),
+					value: isFileSource ? t('progress.duckdbFallback') : resolved.label
+				}
 			];
 
 			if (engine.getSchemaAndCrs) {
-				const result = await engine.getSchemaAndCrs(connId, fileUrl, findGeoColumn);
+				const result = await engine.getSchemaAndCrs(cid, resolved, findGeoColumn);
 				if (thisGen !== loadGeneration) return;
 				schema = result.schema;
 				columns = schema.map((f) => f.name);
@@ -486,7 +571,7 @@ async function loadTable() {
 					}
 				}
 			} else {
-				schema = await engine.getSchema(connId, fileUrl);
+				schema = await engine.getSchema(cid, resolved);
 				if (thisGen !== loadGeneration) return;
 				columns = schema.map((f) => f.name);
 				const colPreview =
@@ -507,7 +592,7 @@ async function loadTable() {
 						...loadProgress,
 						{ label: t('progress.geometry'), value: `${detectedGeoCol} (${geoColType})` }
 					];
-					sourceCrs = await engine.detectCrs(connId, fileUrl, detectedGeoCol);
+					sourceCrs = await engine.detectCrs(cid, resolved, detectedGeoCol);
 					if (thisGen !== loadGeneration) return;
 					if (sourceCrs) {
 						loadProgress = [...loadProgress, { label: t('progress.crs'), value: sourceCrs }];
@@ -530,13 +615,34 @@ async function loadTable() {
 
 		loadStage = t('table.runningQuery');
 		const start = performance.now();
-		const result = await executeQuery(sqlQuery);
+		let result = await executeQuery(sqlQuery);
 		if (thisGen !== loadGeneration) return;
+
+		// If query failed and this is a GeoParquet file, the error may be from
+		// auto-conversion of CRS metadata (e.g. "stoi: no conversion").
+		// Retry with enable_geoparquet_conversion=false and BLOB handling.
+		if (!result && error && isParquet && geoCol && !isLegacyGeoParquet) {
+			try {
+				await engine.query(cid, 'SET enable_geoparquet_conversion = false');
+				geoColType = 'BLOB';
+				sqlQuery = buildDefaultSql(0);
+				customSql = sqlQuery;
+				error = null;
+				result = await executeQuery(sqlQuery);
+				if (thisGen !== loadGeneration) return;
+			} catch {
+				// Retry also failed — original error stands
+			}
+		}
+
 		executionTimeMs = Math.round(performance.now() - start);
 
-		if (!cloudNative && result) {
-			// Non-cloud-native (CSV, GeoJSON, etc.): derive schema from the
-			// query result so we avoid a second full-file download.
+		if (isFileSource && !cloudNative && result) {
+			// Non-cloud-native file (CSV, GeoJSON, etc.): derive schema from the
+			// query result so we avoid a second full-file download. Skipped for
+			// SQL-backed sources (attached DuckLake tables), which already have
+			// a proper schema from getSchemaAndCrs — re-deriving here would pick
+			// up the projected `__wkb` alias and clobber the real geo column.
 			schema = (result.columns ?? []).map((col, i) => ({
 				name: col,
 				type: result.types?.[i] ?? 'VARCHAR',
@@ -591,7 +697,7 @@ async function loadTable() {
 			} else {
 				loadStage = t('table.countingRows');
 				engine
-					.getRowCount(connId, fileUrl)
+					.getRowCount(cid, resolved)
 					.then((count) => {
 						if (thisGen === loadGeneration) {
 							totalRows = count;
@@ -613,11 +719,14 @@ async function loadTable() {
 }
 
 async function executeQuery(sql: string) {
+	// Snapshot `connId` — reading the $derived after the effect is destroyed
+	// returns a Symbol sentinel and crashes downstream template literals.
+	const cid = connId;
 	try {
 		const engine = await getQueryEngine();
 
 		if (engine.queryCancellable) {
-			const handle = engine.queryCancellable(connId, sql);
+			const handle = engine.queryCancellable(cid, sql);
 			activeHandle = handle;
 			try {
 				const result = await handle.result;
@@ -634,7 +743,7 @@ async function executeQuery(sql: string) {
 			}
 		}
 
-		const result = await engine.query(connId, sql);
+		const result = await engine.query(cid, sql);
 		columns = result.columns;
 		rows = result.rows;
 		return result;
@@ -664,6 +773,8 @@ async function loadPage(page: number) {
 }
 
 async function runCustomSql() {
+	// Snapshot before any await — see note in executeQuery.
+	const cid = connId;
 	queryRunning = true;
 	error = null;
 	isCustomQuery = true;
@@ -686,7 +797,7 @@ async function runCustomSql() {
 			timestamp: Date.now(),
 			durationMs: executionTimeMs,
 			rowCount: rows.length,
-			connectionId: connId || undefined
+			connectionId: cid || undefined
 		});
 	} catch (err) {
 		executionTimeMs = Math.round(performance.now() - start);
@@ -698,7 +809,7 @@ async function runCustomSql() {
 			durationMs: executionTimeMs,
 			rowCount: 0,
 			error: error ?? undefined,
-			connectionId: connId || undefined
+			connectionId: cid || undefined
 		});
 	} finally {
 		queryRunning = false;
@@ -902,7 +1013,7 @@ function setStacView() {
 			<FileInfo
 				entries={loadProgress}
 				{schema}
-				parquetUrl={/\.parquet$/i.test(tab.path) ? buildHttpsUrl(tab) : ''}
+				parquetUrl={/\.parquet$/i.test(tab.path) ? parquetIframeUrl : ''}
 			/>
 		</div>
 	{:else if viewMode === 'stac'}

package/dist/components/viewers/ZarrMapViewer.svelte

@@ -5,7 +5,7 @@ import { onDestroy, untrack } from 'svelte';
 import { t } from '../../i18n/index.svelte.js';
 import { tabResources } from '../../stores/tab-resources.svelte.js';
 import type { Tab } from '../../types';
-import { buildHttpsUrl } from '../../utils/url.js';
+import { buildHttpsUrlAsync } from '../../utils/url.js';
 import {
 	ensureCodecsRegistered,
 	extractZarrStoreUrl,
@@ -372,7 +372,7 @@ async function addZarrLayer(map: maplibregl.Map) {
 		await ensureCodecsRegistered();
 		const { ZarrLayer } = await import('@carbonplan/zarr-layer');
 
-		const storeUrl = buildStoreUrl();
+		const storeUrl = await buildStoreUrl();
 		const selector = buildSelector();
 
 		const opts: any = {
@@ -415,6 +415,35 @@ async function addZarrLayer(map: maplibregl.Map) {
 			opts.spatialDimensions = spatial;
 		}
 
+		// Safety: warn if the array is extremely large without multiscale support.
+		// A global-extent array at full resolution can trigger thousands of chunk
+		// requests simultaneously, hanging the browser.
+		const meta = selectedMeta;
+		if (meta?.shape) {
+			const dims = meta.dims?.length ? meta.dims : inferDims(meta.name, meta.shape);
+			const yIdx = dims.findIndex((d) => ['y', 'lat', 'latitude'].includes(d.toLowerCase()));
+			const xIdx = dims.findIndex((d) => ['x', 'lon', 'longitude'].includes(d.toLowerCase()));
+			if (yIdx >= 0 && xIdx >= 0) {
+				const ySize = meta.shape[yIdx];
+				const xSize = meta.shape[xIdx];
+				const yChunk = meta.chunks?.[yIdx] ?? ySize;
+				const xChunk = meta.chunks?.[xIdx] ?? xSize;
+				const yTiles = Math.ceil(ySize / yChunk);
+				const xTiles = Math.ceil(xSize / xChunk);
+				const totalTiles = yTiles * xTiles;
+				// If more than 10 000 tiles at base resolution and no multiscale,
+				// the layer will flood the browser with requests at global zoom.
+				if (totalTiles > 10_000) {
+					error = t('map.zarrTooLarge', {
+						tiles: totalTiles.toLocaleString(),
+						shape: `${ySize.toLocaleString()} × ${xSize.toLocaleString()}`
+					});
+					loading = false;
+					return;
+				}
+			}
+		}
+
 		zarrLayer = new ZarrLayer(opts);
 		map.addLayer(zarrLayer);
 	} catch (err) {
@@ -423,8 +452,8 @@ async function addZarrLayer(map: maplibregl.Map) {
 	}
 }
 
-function buildStoreUrl(): string {
-	const rawUrl = buildHttpsUrl(tab).replace(/\/+$/, '');
+async function buildStoreUrl(): Promise<string> {
+	const rawUrl = (await buildHttpsUrlAsync(tab)).replace(/\/+$/, '');
 	return extractZarrStoreUrl(rawUrl) ?? rawUrl;
 }
 

package/dist/components/viewers/ZarrViewer.svelte

@@ -9,7 +9,7 @@ import {
 } from '../ui/resizable/index.js';
 import { t } from '../../i18n/index.svelte.js';
 import type { Tab } from '../../types';
-import { buildHttpsUrl } from '../../utils/url.js';
+import { buildHttpsUrlAsync } from '../../utils/url.js';
 import { getUrlView, updateUrlView } from '../../utils/url-state.js';
 import {
 	computeChunkCount,
@@ -49,7 +49,6 @@ let showingStoreAttrs = $state(false);
  */
 const mapArrays = $derived.by(() => {
 	if (!hierarchy) return [];
-	// Collect root-level array names (coordinate arrays that zarr-layer can find)
 	const rootArrayNames = new Set(
 		hierarchy.root.children.filter((c) => c.kind === 'array').map((c) => c.name)
 	);
@@ -58,7 +57,6 @@ const mapArrays = $derived.by(() => {
 	function walk(n: ZarrNode) {
 		if (n.kind === 'array' && n.shape && n.shape.length >= 2) {
 			const dims = n.dims?.length ? n.dims : inferDims(n.name, n.shape);
-			// Must have at least one spatial dim pair
 			let hasLat = false;
 			let hasLon = false;
 			for (const d of dims) {
@@ -67,7 +65,6 @@ const mapArrays = $derived.by(() => {
 				if (lower === 'x' || lower === 'lon' || lower === 'longitude') hasLon = true;
 			}
 			if (hasLat && hasLon) {
-				// Non-spatial dims must have root-level coordinate arrays
 				const nonSpatialResolvable = dims.every(
 					(d) => spatialNames.has(d.toLowerCase()) || rootArrayNames.has(d)
 				);
@@ -123,7 +120,7 @@ async function loadHierarchy() {
 	error = null;
 
 	try {
-		const rawUrl = buildHttpsUrl(tab).replace(/\/+$/, '');
+		const rawUrl = (await buildHttpsUrlAsync(tab)).replace(/\/+$/, '');
 		const url = extractZarrStoreUrl(rawUrl) ?? rawUrl;
 		const storeName = tab.name.replace(/\.(zarr|zr3)$/, '');
 
@@ -454,7 +451,7 @@ function selectStoreAttrs() {
 					>
 						{t('zarr.map')}
 					</Button>
-				{/if}
+			{/if}
 			</div>
 		</div>
 	</div>

package/dist/components/viewers/pmtiles/PmtilesMapView.svelte

@@ -12,7 +12,6 @@ import type { Tab } from '../../../types';
 import { setupSelectionLayer, updateSelection } from '../../../utils/map-selection.js';
 import { buildPmtilesLayers, getPmtilesProtocol, type PmtilesMetadata } from '../../../utils/pmtiles';
 import { layerHue } from '../../../utils/pmtiles-tile.js';
-import { buildHttpsUrl } from '../../../utils/url.js';
 import AttributeTable from '../map/AttributeTable.svelte';
 import MapContainer from '../map/MapContainer.svelte';
 

package/dist/constants.d.ts

@@ -9,8 +9,12 @@ export declare const STORAGE_KEYS: {
 };
 /** EPSG codes considered WGS84 (no reprojection needed). */
 export declare const WGS84_CODES: Set<number>;
-/** Default target CRS for ST_Transform. */
-export declare const DEFAULT_TARGET_CRS = "EPSG:4326";
+/**
+ * Default target CRS for ST_Transform. Uses OGC:CRS84 (longitude, latitude)
+ * to match GeoParquet 1.1+ spec and DuckDB v1.5's canonical form.
+ * Functionally equivalent to EPSG:4326 under `geometry_always_xy = true`.
+ */
+export declare const DEFAULT_TARGET_CRS = "OGC:CRS84";
 /** DuckDB-WASM initialization timeout in ms. */
 export declare const DUCKDB_INIT_TIMEOUT_MS = 30000;
 /** Maximum entries kept in query history. */

package/dist/constants.js

@@ -11,8 +11,12 @@ export const STORAGE_KEYS = {
 // ── Geo / CRS constants ──
 /** EPSG codes considered WGS84 (no reprojection needed). */
 export const WGS84_CODES = new Set([4326, 4979]);
-/** Default target CRS for ST_Transform. */
-export const DEFAULT_TARGET_CRS = 'EPSG:4326';
+/**
+ * Default target CRS for ST_Transform. Uses OGC:CRS84 (longitude, latitude)
+ * to match GeoParquet 1.1+ spec and DuckDB v1.5's canonical form.
+ * Functionally equivalent to EPSG:4326 under `geometry_always_xy = true`.
+ */
+export const DEFAULT_TARGET_CRS = 'OGC:CRS84';
 // ── Query engine constants ──
 /** DuckDB-WASM initialization timeout in ms. */
 export const DUCKDB_INIT_TIMEOUT_MS = 30_000;

package/dist/file-icons/index.d.ts

@@ -53,4 +53,4 @@ export declare function isQueryable(extension: string): boolean;
 /** Returns the MIME type for a file extension. */
 export declare function getMimeType(extension: string): string;
 /** Re-export folder info for components that need it directly. */
-export { FOLDER_INFO, DEFAULT_INFO };
+export { DEFAULT_INFO, FOLDER_INFO };

package/dist/file-icons/index.js

@@ -883,6 +883,16 @@ const EXTENSIONS = {
         duckdbReadFn: null,
         mimeType: 'application/octet-stream'
     },
+    '.ducklake': {
+        icon: 'Database',
+        color: 'text-teal-600 dark:text-teal-400',
+        label: 'DuckLake',
+        category: 'database',
+        viewer: 'database',
+        queryable: true,
+        duckdbReadFn: null,
+        mimeType: 'application/octet-stream'
+    },
     '.sqlite': {
         icon: 'Database',
         color: 'text-sky-600 dark:text-sky-400',
@@ -1055,7 +1065,7 @@ export function buildDuckDbSource(pathOrExt, url) {
  * Other cloud-native formats (.fgb, .pmtiles, .zarr) also support range
  * requests but have dedicated viewers and don't go through DuckDB/TableViewer.
  */
-const CLOUD_NATIVE_EXTS = new Set(['.parquet', '.geoparquet', '.gpq', '.gparquet']);
+const CLOUD_NATIVE_EXTS = new Set(['.parquet', '.geoparquet', '.gpq', '.gparquet', '.ducklake']);
 export function isCloudNativeFormat(pathOrExt) {
     const ext = pathOrExt.includes('.') ? `.${pathOrExt.split('.').pop().toLowerCase()}` : '';
     return CLOUD_NATIVE_EXTS.has(ext);
@@ -1073,4 +1083,4 @@ export function getMimeType(extension) {
     return getFileTypeInfo(extension).mimeType;
 }
 /** Re-export folder info for components that need it directly. */
-export { FOLDER_INFO, DEFAULT_INFO };
+export { DEFAULT_INFO, FOLDER_INFO };

package/dist/i18n/ar.js

@@ -30,6 +30,14 @@ export const ar = {
     'connection.accessKey': 'مفتاح الوصول',
     'connection.secretKey': 'المفتاح السري',
     'connection.credentialNotice': 'يتم تخزين بيانات اعتمادك فقط في مدير كلمات المرور بمتصفحك إذا اخترت حفظها. لا تُرسل أبداً إلى أي خادم خارجي ولا تُخزّن في التخزين المحلي.',
+    'connection.corsTitle': 'إعداد CORS',
+    'connection.corsRequired': 'يتطلب الوصول عبر المتصفح تفعيل CORS على الحاوية. بدونه، سيتم حظر الطلبات.',
+    'connection.corsDefault': 'CORS مفعّل افتراضياً. لا حاجة لأي إعداد.',
+    'connection.corsDocs': 'توثيق CORS الرسمي',
+    'connection.corsCliTitle': 'تفعيل CORS عبر سطر الأوامر',
+    'connection.readOnlyTitle': 'الوصول للقراءة فقط',
+    'connection.readOnlyDocs': 'توثيق الصلاحيات الرسمي',
+    'connection.readOnlyCliTitle': 'تقييد عبر سطر الأوامر',
     'connection.testSuccess': 'الاتصال ناجح',
     'connection.testFail': 'فشل الاتصال. تحقق من الإعدادات وحاول مرة أخرى.',
     'connection.testButton': 'اختبار الاتصال',
@@ -194,6 +202,12 @@ export const ar = {
     'database.tablesHeader': 'الجداول',
     'database.loadingTable': 'جارٍ تحميل الجدول...',
     'database.selectTable': 'اختر جدولاً للتصفح',
+    // DuckLake
+    'ducklake.loading': 'جا��ٍ ربط كتالوج DuckLake...',
+    'ducklake.snapshot': 'لقطة',
+    'ducklake.snapshots': 'لقطات',
+    'ducklake.noTables': 'لا توجد جداول في هذا المخطط',
+    'ducklake.extensionHint': 'قد لا يكون امتداد DuckLake متاحاً لهذا الإصدار من DuckDB-WASM.',
     // PDF Viewer
     'pdf.badge': 'PDF',
     'pdf.loading': 'جارٍ تحميل PDF...',
@@ -317,6 +331,7 @@ export const ar = {
     'map.loadingFgb': 'جارٍ تحميل FlatGeobuf...',
     'map.loadingCog': 'جارٍ تحميل COG...',
     'map.loadingZarr': 'جارٍ تحميل بيانات Zarr...',
+    'map.zarrTooLarge': 'المصفوفة كبيرة جداً لعرض الخريطة ({shape}، ~{tiles} بلاطة). يحتاج هذا المجموعة إلى هرم متعدد المقاييس للعرض المبلط.',
     'map.features': 'معالم',
     'map.limit': '(الحد)',
     'map.of': 'من',
@@ -327,6 +342,7 @@ export const ar = {
     'map.flatgeobufInfo': 'معلومات FlatGeobuf',
     'map.cogInfo': 'معلومات COG',
     'map.cogCorsError': 'تعذّر تحميل COG: الخادم لا يسمح بطلبات عبر النطاقات (CORS). يجب استضافة الملف مع تفعيل ترويسات CORS.',
+    'map.cogInvalidTiff': 'هذا الملف ليس ملف TIFF صالح. نوع المحتوى image/tiff لكن الأجزاء الأولى من الملف لا تطابق توقيع TIFF، قد يكون الملف تالفاً أو مشفّراً أو مُعنوناً بشكل خاطئ.',
     'map.cogUnsupportedFormat': 'يستخدم هذا الملف صيغة {{type}} غير مدعومة لعرض الخريطة. يمكن عرض ملفات COG بصيغة RGB فقط.',
     'map.noGeoColumn': 'لم يتم اكتشاف عمود هندسي في المخطط',
     'map.noData': 'لا تتوفر بيانات لعرض الخريطة',
@@ -366,6 +382,15 @@ export const ar = {
     'mapInfo.columns': 'الأعمدة',
     'mapInfo.size': 'الحجم',
     'mapInfo.bands': 'النطاقات',
+    // COG Controls
+    'cog.style': 'النمط',
+    'cog.band': 'النطاق',
+    'cog.singleBand': 'نطاق واحد',
+    'cog.colorRamp': 'تدرج الألوان',
+    'cog.pixelValue': 'قيمة البكسل',
+    'cog.reading': 'قراءة البكسل...',
+    'cog.rescale': 'إعادة القياس',
+    'cog.rescaleReset': 'إعادة تعيين',
     // PMTiles Viewer
     'pmtiles.mapView': 'خريطة',
     'pmtiles.archiveView': 'الأرشيف',