@walkthru-earth/objex 1.0.0 → 1.2.0

package/dist/components/viewers/TableViewer.svelte

@@ -2,15 +2,23 @@
 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
+} 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,
@@ -91,26 +99,23 @@ const columnTypes = $derived(Object.fromEntries(schema.map((f) => [f.name, f.typ
 const displayColumns = $derived(columns.filter((c) => c !== '__wkb'));
 
 function buildDefaultSql(offset = 0): string {
-	const fileUrl = buildDuckDbUrl(tab);
-	const source = buildDuckDbSource(tab.path, fileUrl);
+	const resolved = resolveTableSource(tab);
+	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 +123,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`;
 		}
@@ -284,19 +293,24 @@ async function loadTable() {
 	customSql = initialSql;
 
 	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 = resolveTableSource(tab);
+		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);
 
 		// 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 +371,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 +413,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 +431,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 +443,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(connId, '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(connId, 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(connId, resolved, geoCol);
 				if (thisGen !== loadGeneration) return;
 				if (sourceCrs) {
 					loadProgress = [...loadProgress, { label: t('progress.crs'), value: sourceCrs }];
@@ -450,16 +505,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(connId, resolved, findGeoColumn);
 				if (thisGen !== loadGeneration) return;
 				schema = result.schema;
 				columns = schema.map((f) => f.name);
@@ -486,7 +547,7 @@ async function loadTable() {
 					}
 				}
 			} else {
-				schema = await engine.getSchema(connId, fileUrl);
+				schema = await engine.getSchema(connId, resolved);
 				if (thisGen !== loadGeneration) return;
 				columns = schema.map((f) => f.name);
 				const colPreview =
@@ -507,7 +568,7 @@ async function loadTable() {
 						...loadProgress,
 						{ label: t('progress.geometry'), value: `${detectedGeoCol} (${geoColType})` }
 					];
-					sourceCrs = await engine.detectCrs(connId, fileUrl, detectedGeoCol);
+					sourceCrs = await engine.detectCrs(connId, resolved, detectedGeoCol);
 					if (thisGen !== loadGeneration) return;
 					if (sourceCrs) {
 						loadProgress = [...loadProgress, { label: t('progress.crs'), value: sourceCrs }];
@@ -530,13 +591,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(connId, '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 +673,7 @@ async function loadTable() {
 			} else {
 				loadStage = t('table.countingRows');
 				engine
-					.getRowCount(connId, fileUrl)
+					.getRowCount(connId, resolved)
 					.then((count) => {
 						if (thisGen === loadGeneration) {
 							totalRows = count;

package/dist/components/viewers/ZarrMapViewer.svelte

@@ -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) {

package/dist/components/viewers/ZarrViewer.svelte

@@ -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)
 				);
@@ -454,7 +451,7 @@ function selectStoreAttrs() {
 					>
 						{t('zarr.map')}
 					</Button>
-				{/if}
+			{/if}
 			</div>
 		</div>
 	</div>

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': 'من',
@@ -366,6 +381,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': 'الأرشيف',

package/dist/i18n/en.js

@@ -30,6 +30,14 @@ export const en = {
     'connection.accessKey': 'Access Key',
     'connection.secretKey': 'Secret Key',
     'connection.credentialNotice': "Your credentials are stored only in your browser's password manager if you choose to save them. They are never sent to any external server or stored in local storage.",
+    'connection.corsTitle': 'CORS Configuration',
+    'connection.corsRequired': 'Browser access requires CORS to be enabled on your bucket. Without it, requests will be blocked.',
+    'connection.corsDefault': 'CORS is enabled by default. No configuration needed.',
+    'connection.corsDocs': 'Official CORS docs',
+    'connection.corsCliTitle': 'Enable CORS via CLI',
+    'connection.readOnlyTitle': 'Read-Only Access',
+    'connection.readOnlyDocs': 'Official permissions docs',
+    'connection.readOnlyCliTitle': 'Restrict via CLI',
     'connection.testSuccess': 'Connection successful',
     'connection.testFail': 'Connection failed. Check your settings and try again.',
     'connection.testButton': 'Test Connection',
@@ -194,6 +202,12 @@ export const en = {
     'database.tablesHeader': 'Tables',
     'database.loadingTable': 'Loading table...',
     'database.selectTable': 'Select a table to browse',
+    // DuckLake
+    'ducklake.loading': 'Attaching DuckLake catalog...',
+    'ducklake.snapshot': 'Snapshot',
+    'ducklake.snapshots': 'snapshots',
+    'ducklake.noTables': 'No tables in this schema',
+    'ducklake.extensionHint': 'The DuckLake extension may not be available for this DuckDB-WASM version.',
     // PDF Viewer
     'pdf.badge': 'PDF',
     'pdf.loading': 'Loading PDF...',
@@ -317,6 +331,7 @@ export const en = {
     'map.loadingFgb': 'Loading FlatGeobuf...',
     'map.loadingCog': 'Loading COG...',
     'map.loadingZarr': 'Loading Zarr data...',
+    'map.zarrTooLarge': 'Array too large for map view ({shape}, ~{tiles} tiles). This dataset needs a multiscale pyramid for tiled rendering.',
     'map.features': 'features',
     'map.limit': '(limit)',
     'map.of': 'of',
@@ -366,6 +381,15 @@ export const en = {
     'mapInfo.columns': 'Columns',
     'mapInfo.size': 'Size',
     'mapInfo.bands': 'Bands',
+    // COG Controls
+    'cog.style': 'Style',
+    'cog.band': 'Band',
+    'cog.singleBand': 'Single',
+    'cog.colorRamp': 'Color ramp',
+    'cog.pixelValue': 'Pixel Value',
+    'cog.reading': 'Reading pixel...',
+    'cog.rescale': 'Rescale',
+    'cog.rescaleReset': 'Reset',
     // PMTiles Viewer
     'pmtiles.mapView': 'Map',
     'pmtiles.archiveView': 'Archive',

package/dist/i18n/index.svelte.d.ts

@@ -1,5 +1,4 @@
 export type Locale = 'en' | 'ar';
-export declare function getLocale(): Locale;
 export declare function setLocale(l: Locale): void;
 export declare function getDir(): 'ltr' | 'rtl';
 /**

package/dist/i18n/index.svelte.js

@@ -3,9 +3,6 @@ import { en } from './en.js';
 const translations = { en, ar };
 const RTL_LOCALES = new Set(['ar']);
 let currentLocale = $state('en');
-export function getLocale() {
-    return currentLocale;
-}
 export function setLocale(l) {
     currentLocale = l;
 }

package/dist/index.d.ts

@@ -4,17 +4,28 @@ export { buildDuckDbSource, getDuckDbReadFn, getFileTypeInfo, getMimeType, getVi
 export type { MapQueryHandle, MapQueryResult, QueryEngine, QueryHandle, QueryResult, SchemaField } from './query/engine.js';
 export { QueryCancelledError } from './query/engine.js';
 export type { ListPage, StorageAdapter } from './storage/adapter.js';
+export type { ProviderDef, ProviderId, ProviderRegion } from './storage/providers.js';
+export { buildEndpointFromTemplate, buildProviderBaseUrl, getProvider, isGcsProvider, PROVIDER_IDS, PROVIDERS } from './storage/providers.js';
 export { UrlAdapter } from './storage/url-adapter.js';
 export type { Connection, ConnectionConfig, FileEntry, Tab, Theme, WriteResult } from './types.js';
 export { copyToClipboard, wireCodeCopyButtons } from './utils/clipboard.js';
+export { getNativeScheme, resolveCloudUrl, safeDecodeURIComponent } from './utils/cloud-url.js';
+export type { CogInfo, GeoBounds } from './utils/cog.js';
+export { buildDataTypeLabel, clampBounds, SF_LABELS, safeClamp } from './utils/cog.js';
 export type { TypeCategory } from './utils/column-types.js';
 export { classifyType, typeBadgeClass, typeColor, typeLabel } from './utils/column-types.js';
 export { handleLoadError } from './utils/error.js';
+export { escapeCsvField, serializeToCsv, serializeToJson } from './utils/export.js';
+export type { SortConfig, SortDirection, SortField } from './utils/file-sort.js';
+export { sortFileEntries, toggleSortField } from './utils/file-sort.js';
 export { formatDate, formatFileSize, formatValue, getFileExtension, jsonReplacerBigInt } from './utils/format.js';
 export type { GeoArrowGeomType, GeoArrowResult } from './utils/geoarrow.js';
 export { buildGeoArrowTables, normalizeGeomType } from './utils/geoarrow.js';
 export type { HexRow } from './utils/hex.js';
 export { generateHexDump } from './utils/hex.js';
+export { loadFromStorage, persistToStorage } from './utils/local-storage.js';
+export type { ParsedMarkdownDocument, SqlBlock } from './utils/markdown-sql.js';
+export { interpolateTemplates, markSqlBlocks, parseMarkdownDocument } from './utils/markdown-sql.js';
 export type { GeoColumnMeta, GeoParquetMeta, ParquetFileMetadata } from './utils/parquet-metadata.js';
 export { extractBounds, extractEpsgFromGeoMeta, extractGeometryTypes, readParquetMetadata } from './utils/parquet-metadata.js';
 export type { Defaults, ParsedStorageUrl, StorageProvider } from './utils/storage-url.js';

package/dist/index.js

@@ -4,15 +4,25 @@ export { COPY_FEEDBACK_MS, DEFAULT_TARGET_CRS, DUCKDB_INIT_TIMEOUT_MS, LAYER_HUE
 // File icons registry
 export { buildDuckDbSource, getDuckDbReadFn, getFileTypeInfo, getMimeType, getViewerKind, isCloudNativeFormat, isQueryable } from './file-icons/index.js';
 export { QueryCancelledError } from './query/engine.js';
+export { buildEndpointFromTemplate, buildProviderBaseUrl, getProvider, isGcsProvider, PROVIDER_IDS, PROVIDERS } from './storage/providers.js';
 export { UrlAdapter } from './storage/url-adapter.js';
 // Clipboard
 export { copyToClipboard, wireCodeCopyButtons } from './utils/clipboard.js';
+// Cloud URL resolution
+export { getNativeScheme, resolveCloudUrl, safeDecodeURIComponent } from './utils/cloud-url.js';
+export { buildDataTypeLabel, clampBounds, SF_LABELS, safeClamp } from './utils/cog.js';
 export { classifyType, typeBadgeClass, typeColor, typeLabel } from './utils/column-types.js';
 // Error handling
 export { handleLoadError } from './utils/error.js';
+// Data export / serialization
+export { escapeCsvField, serializeToCsv, serializeToJson } from './utils/export.js';
+export { sortFileEntries, toggleSortField } from './utils/file-sort.js';
 export { formatDate, formatFileSize, formatValue, getFileExtension, jsonReplacerBigInt } from './utils/format.js';
 export { buildGeoArrowTables, normalizeGeomType } from './utils/geoarrow.js';
 export { generateHexDump } from './utils/hex.js';
+// localStorage helpers
+export { loadFromStorage, persistToStorage } from './utils/local-storage.js';
+export { interpolateTemplates, markSqlBlocks, parseMarkdownDocument } from './utils/markdown-sql.js';
 export { extractBounds, extractEpsgFromGeoMeta, extractGeometryTypes, readParquetMetadata } from './utils/parquet-metadata.js';
 export { describeParseResult, looksLikeUrl, parseStorageUrl } from './utils/storage-url.js';
 // Utilities