@walkthru-earth/objex 1.1.0 → 1.2.1

package/dist/query/wasm.js

@@ -1,7 +1,9 @@
 import { DEFAULT_TARGET_CRS, DUCKDB_INIT_TIMEOUT_MS, WGS84_CODES } from '../constants.js';
-import { buildDuckDbSource } from '../file-icons/index.js';
+import { getAccessMode, resolveProviderEndpoint } from '../storage/providers.js';
 import { credentialStore } from '../stores/credentials.svelte.js';
+import { buildTransformExpr, wrapWkbWithCrs } from '../utils/geometry-type.js';
 import { QueryCancelledError } from './engine';
+import { isHttpsSourceRef } from './source.js';
 const DUCKDB_VERSION = __DUCKDB_WASM_VERSION__;
 const CDN_BASE = `https://cdn.jsdelivr.net/npm/@duckdb/duckdb-wasm@${DUCKDB_VERSION}/dist`;
 const duckdb_wasm = `${CDN_BASE}/duckdb-mvp.wasm`;
@@ -66,21 +68,29 @@ async function getDB() {
         const conn = await db.connect();
         try {
             const tExt = performance.now();
-            await withTimeout(conn.query('INSTALL httpfs; LOAD httpfs; INSTALL spatial; LOAD spatial;'), INIT_TIMEOUT_MS, 'extension install (httpfs + spatial)');
-            // Disable auto-conversion of GeoParquet metadata → GEOMETRY type.
-            // Some files use legacy GeoParquet metadata (schema_version 0.x without
-            // "version" field) which causes DuckDB's spatial extension to throw
-            // "Geoparquet metadata does not have a version". We handle geometry
-            // detection, CRS, and WKB conversion ourselves via hyparquet metadata
-            // and explicit ST_GeomFromWKB() calls, so auto-conversion is not needed.
+            // Workaround for duckdb/duckdb-wasm#2199: calling duckdb_coordinate_systems()
+            // FIRST autoloads spatial and registers default CRS properly. Running it
+            // AFTER an explicit LOAD spatial triggers a timing bug in PROJ (WASM-only)
+            // that causes "stoi: no conversion" on any GeoParquet with CRS metadata.
+            await withTimeout(conn.query('SELECT * FROM duckdb_coordinate_systems(); INSTALL httpfs; LOAD httpfs; INSTALL spatial; LOAD spatial;'), INIT_TIMEOUT_MS, 'extension install (httpfs + spatial)');
+            // DuckDB v1.5: GEOMETRY is a core type with optional CRS parameter.
+            // SET geometry_always_xy = true forces lon/lat (x/y) axis order globally,
+            // matching GeoJSON/GeoParquet convention. Without this, DuckDB v1.5 emits
+            // warnings on ST_Transform and other coordinate-sensitive functions.
             // SET GLOBAL applies to all future connections (no per-connection overhead).
             try {
-                await conn.query('SET GLOBAL enable_geoparquet_conversion = false');
-                geoConversionGlobal = true;
+                await conn.query('SET GLOBAL geometry_always_xy = true');
             }
             catch {
-                // SET GLOBAL not supported — fall back to per-connection SET
-                await conn.query('SET enable_geoparquet_conversion = false');
+                logWarn('geometry_always_xy not available — ST_Transform calls may warn');
+            }
+            // Raise httpfs force_download threshold so moderately sized remote files
+            // are fetched in one shot instead of many small range requests.
+            try {
+                await conn.query('SET GLOBAL force_download_threshold = 2000000');
+            }
+            catch {
+                logWarn('force_download_threshold not available');
             }
             log(`getDB → extensions loaded in ${elapsed(tExt)}`);
         }
@@ -96,19 +106,41 @@ async function getDB() {
     });
     return dbPromise;
 }
-let geoConversionGlobal = false;
+// ─── Geometry type helpers ────────────────────────────────────────────
 /**
- * Ensure GeoParquet auto-conversion is disabled on this connection.
- * If SET GLOBAL succeeded during init, this is a no-op.
- * Otherwise falls back to per-connection SET.
+ * Check if a DuckDB column type string is a spatial type that ST_AsWKB accepts directly.
+ * Handles DuckDB v1.5 parameterized types like GEOMETRY('EPSG:4326').
  */
-async function ensureGeoConversionDisabled(conn) {
-    if (geoConversionGlobal)
-        return;
-    await conn.query('SET enable_geoparquet_conversion = false');
+function isSpatialColumnType(typeUpper) {
+    return (typeUpper.startsWith('GEOMETRY') ||
+        typeUpper.startsWith('GEOGRAPHY') ||
+        typeUpper === 'WKB_BLOB' ||
+        typeUpper.includes('POINT') ||
+        typeUpper.includes('LINESTRING') ||
+        typeUpper.includes('POLYGON') ||
+        typeUpper.includes('BINARY') // Arrow serialization of DuckDB GEOMETRY
+    );
 }
 // ─── CRS detection helpers ───────────────────────────────────────────
 // WGS84_CODES imported from constants.ts
+/**
+ * Extract CRS from DuckDB v1.5 parameterized GEOMETRY type string.
+ * e.g., "GEOMETRY('EPSG:4326')" → { found: true, crs: null } (WGS84)
+ * e.g., "GEOMETRY('EPSG:27700')" → { found: true, crs: 'EPSG:27700' }
+ * e.g., "GEOMETRY" → { found: false, crs: null } (no CRS in type)
+ */
+function extractCrsFromTypeString(typeStr) {
+    const match = typeStr.match(/^GEOMETRY\('([^']+)'\)/i);
+    if (!match)
+        return { found: false, crs: null };
+    const crs = match[1];
+    if (crs === 'EPSG:4326' || crs === 'OGC:CRS84')
+        return { found: true, crs: null };
+    const epsgMatch = crs.match(/^EPSG:(\d+)$/);
+    if (epsgMatch && WGS84_CODES.has(Number(epsgMatch[1])))
+        return { found: true, crs: null };
+    return { found: true, crs };
+}
 /** Extract EPSG code from a PROJJSON object. Returns null for WGS84/CRS84. */
 function extractEpsgFromProjjson(crs) {
     if (!crs)
@@ -203,13 +235,18 @@ async function extractCrsFromLogicalType(logicalType, conn, path) {
 // DuckDB Arrow type strings that represent binary/blob data — not useful
 // for map tooltips and expensive to extract row-by-row.
 const BINARY_TYPES = new Set(['BLOB', 'BYTEA', 'BINARY', 'LARGEBINARY', 'WKB_BLOB']);
-/** True if the Arrow type string represents a numeric primitive (zero-copy .toArray()). */
+/**
+ * True if the Arrow type string represents a numeric primitive whose `.toArray()`
+ * returns a plain typed array (zero-copy fast path). DECIMAL is excluded: Arrow
+ * emits decimals as multi-word BigInt buffers that need scale-aware formatting.
+ */
 function isNumericArrowType(typeStr) {
     const t = typeStr.toUpperCase();
+    if (t.startsWith('DECIMAL'))
+        return false;
     return (t.includes('INT') ||
         t.includes('FLOAT') ||
         t.includes('DOUBLE') ||
-        t.includes('DECIMAL') ||
         t === 'TINYINT' ||
         t === 'SMALLINT' ||
         t === 'BIGINT' ||
@@ -219,6 +256,53 @@ function isNumericArrowType(typeStr) {
         t === 'USMALLINT' ||
         t === 'UTINYINT');
 }
+/**
+ * Parse DuckDB/Arrow DECIMAL type string → scale. Returns -1 if not a decimal.
+ *
+ * DuckDB DESCRIBE emits `DECIMAL(10,2)`. Arrow's `Decimal.toString()` emits
+ * `Decimal[10e+2]` (precision `e` signed-scale). Accept both.
+ */
+function decimalScale(typeStr) {
+    const m = /^(?:DECIMAL\(\s*\d+\s*,\s*(-?\d+)\s*\)|Decimal\[\s*\d+e([+-]?\d+)\s*\])/i.exec(typeStr);
+    if (!m)
+        return -1;
+    return Number(m[1] ?? m[2]);
+}
+/**
+ * Format an Arrow Decimal value (BigInt or Uint32Array of little-endian words)
+ * into a human-readable decimal string, applying the column scale.
+ */
+function formatDecimal(raw, scale) {
+    if (raw == null)
+        return null;
+    let bn;
+    if (typeof raw === 'bigint') {
+        bn = raw;
+    }
+    else if (raw instanceof Uint32Array || raw instanceof Int32Array) {
+        const hi = BigInt(raw[raw.length - 1] >>> 0);
+        const signed = hi >= 0x80000000n;
+        let acc = 0n;
+        for (let w = raw.length - 1; w >= 0; w--) {
+            acc = (acc << 32n) | BigInt(raw[w] >>> 0);
+        }
+        bn = signed ? acc - (1n << BigInt(raw.length * 32)) : acc;
+    }
+    else if (typeof raw === 'number') {
+        bn = BigInt(raw);
+    }
+    else {
+        return String(raw);
+    }
+    const neg = bn < 0n;
+    const abs = neg ? -bn : bn;
+    if (scale <= 0)
+        return (neg ? '-' : '') + abs.toString();
+    const divisor = 10n ** BigInt(scale);
+    const intPart = abs / divisor;
+    const fracPart = (abs % divisor).toString().padStart(scale, '0');
+    return `${neg ? '-' : ''}${intPart}.${fracPart}`;
+}
 /**
  * Extract column values using the fastest available method:
  * - Numeric primitives → .toArray() returns a typed array view (zero-copy),
@@ -226,6 +310,14 @@ function isNumericArrowType(typeStr) {
  * - Other types → per-element .get(i) for correctness (strings, structs, etc.)
  */
 function extractColumnBulk(col, numRows, typeStr) {
+    const scale = decimalScale(typeStr);
+    if (scale >= 0) {
+        const values = new Array(numRows);
+        for (let i = 0; i < numRows; i++) {
+            values[i] = formatDecimal(col.get(i), scale);
+        }
+        return values;
+    }
     if (isNumericArrowType(typeStr)) {
         // .toArray() returns a TypedArray (Float64Array, Int32Array, etc.)
         // which is a zero-copy view over the Arrow buffer.
@@ -242,6 +334,13 @@ function extractColumnBulk(col, numRows, typeStr) {
  * Same optimisation as extractColumnBulk but appends instead of creating new.
  */
 function appendColumnBulk(target, col, numRows, typeStr) {
+    const scale = decimalScale(typeStr);
+    if (scale >= 0) {
+        for (let i = 0; i < numRows; i++) {
+            target.push(formatDecimal(col.get(i), scale));
+        }
+        return;
+    }
     if (isNumericArrowType(typeStr)) {
         const arr = col.toArray();
         for (let i = 0; i < arr.length; i++) {
@@ -264,12 +363,11 @@ export class WasmQueryEngine {
         log(`query → ${sqlPreview}`);
         const db = await getDB();
         const conn = await db.connect();
-        await ensureGeoConversionDisabled(conn);
         const tConn = performance.now();
         log(`query → connected in ${elapsed(t0)}`);
         try {
             if (connId) {
-                await this.configureStorage(conn, connId);
+                await this.configureStorage(conn, connId, sql);
                 log(`query → storage configured in ${elapsed(tConn)}`);
             }
             const tQuery = performance.now();
@@ -290,14 +388,25 @@ export class WasmQueryEngine {
                     rows: []
                 };
             }
+            // Arrow emits DECIMAL columns as multi-word BigInt / Uint32Array buffers.
+            // `String(rawDecimal)` yields the unscaled integer (or "0,0,0,0"),
+            // so rewrite each decimal cell through formatDecimal with the column scale.
+            const decimalCols = [];
+            for (let i = 0; i < cols.length; i++) {
+                const s = decimalScale(types[i]);
+                if (s >= 0)
+                    decimalCols.push({ name: cols[i], scale: s });
+            }
             // Extract rows directly — avoids Arrow version mismatch
             const rows = result.toArray().map((row) => {
-                if (typeof row.toJSON === 'function')
-                    return row.toJSON();
-                // Fallback: manually build row object
-                const obj = {};
-                for (const col of cols)
-                    obj[col] = row[col];
+                const obj = typeof row.toJSON === 'function' ? row.toJSON() : {};
+                if (typeof row.toJSON !== 'function') {
+                    for (const col of cols)
+                        obj[col] = row[col];
+                }
+                for (const { name, scale } of decimalCols) {
+                    obj[name] = formatDecimal(obj[name], scale);
+                }
                 return obj;
             });
             log(`query → done in ${elapsed(t0)}, ${numRows} rows, ${cols.length} cols`);
@@ -316,50 +425,39 @@ export class WasmQueryEngine {
         log(`queryForMap → geomCol: ${geomCol}, type: ${geomColType}, crs: ${sourceCrs ?? 'WGS84'}`);
         const db = await getDB();
         const conn = await db.connect();
-        await ensureGeoConversionDisabled(conn);
         try {
             if (connId) {
-                await this.configureStorage(conn, connId);
+                await this.configureStorage(conn, connId, sql);
             }
             // Build geometry expression based on column type:
-            // - Native spatial types (GEOMETRY, WKB_BLOB, POINT, etc.) → use directly
-            // - BLOB/BINARY → DuckDB implicitly casts BLOB→GEOMETRY, use directly
+            // - Native spatial types (GEOMETRY, GEOMETRY('EPSG:...'), WKB_BLOB, etc.) → use directly
+            // - BLOB/BINARY → need explicit ST_GeomFromWKB
             // - Everything else (VARCHAR, JSON, STRUCT, ...) → GeoJSON text
             const quoted = `"${geomCol}"`;
             const upper = geomColType.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' ||
-                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.
+            const spatialType = isSpatialColumnType(upper);
             const isWkbBlob = upper === 'BLOB' || upper === 'BYTEA';
             let wkbExpr;
             let geomExpr;
             if (isWkbBlob && !sourceCrs) {
                 // Already WKB — use directly, no spatial function calls needed.
-                // Avoids ST_GeomFromWKB which can fail if DuckDB auto-converted
-                // the column to GEOMETRY despite enable_geoparquet_conversion=false.
                 wkbExpr = quoted;
                 geomExpr = null; // geometry type detected client-side from WKB headers
             }
             else {
-                geomExpr = isSpatialType
+                // For BLOB inputs with a known source CRS, attach it via ST_SetCRS so
+                // downstream ST_Transform can use the 2-arg form and the CRS propagates
+                // through any subsequent spatial ops (DuckDB v1.5+).
+                geomExpr = spatialType
                     ? quoted
                     : isWkbBlob
-                        ? `ST_GeomFromWKB(${quoted})`
+                        ? wrapWkbWithCrs(quoted, sourceCrs)
                         : `ST_GeomFromGeoJSON(${quoted})`;
                 // Re-project to WGS84 if the source CRS is not EPSG:4326/CRS84.
-                // always_xy := true forces lon/lat (x/y) axis order for both source and
-                // target, matching the GeoParquet convention regardless of CRS authority.
+                // geometry_always_xy is set globally at DB init, so no per-call always_xy needed.
                 if (sourceCrs) {
-                    geomExpr = `ST_Transform(${geomExpr}, '${sourceCrs}', '${DEFAULT_TARGET_CRS}', always_xy := true)`;
+                    const effectiveType = isWkbBlob ? `GEOMETRY('${sourceCrs}')` : geomColType;
+                    geomExpr = buildTransformExpr(geomExpr, effectiveType, sourceCrs, DEFAULT_TARGET_CRS);
                 }
                 // ST_AsWKB needed — DuckDB GEOMETRY columns (from ST_ReadSHP, ST_Read)
                 // use an internal binary format, not WKB, even though Arrow reports Binary type.
@@ -416,18 +514,16 @@ export class WasmQueryEngine {
             await conn.close();
         }
     }
-    async getSchema(connId, path) {
+    async getSchema(connId, source) {
         const t0 = performance.now();
-        log('getSchema →', path);
+        log('getSchema →', source.ref);
         const db = await getDB();
         const conn = await db.connect();
-        await ensureGeoConversionDisabled(conn);
         try {
             if (connId) {
-                await this.configureStorage(conn, connId);
+                await this.configureStorage(conn, connId, source.ref);
             }
-            const source = buildDuckDbSource(path, path);
-            const result = await conn.query(`DESCRIBE SELECT * FROM ${source}`);
+            const result = await conn.query(`DESCRIBE SELECT * FROM ${source.ref}`);
             const rows = result.toArray();
             const schema = rows.map((row) => ({
                 name: row.column_name,
@@ -445,23 +541,24 @@ export class WasmQueryEngine {
             await conn.close();
         }
     }
-    async getRowCount(connId, path) {
+    async getRowCount(connId, source) {
         const t0 = performance.now();
-        log('getRowCount →', path);
+        log('getRowCount →', source.ref);
         const db = await getDB();
         const conn = await db.connect();
-        await ensureGeoConversionDisabled(conn);
         try {
             if (connId) {
-                await this.configureStorage(conn, connId);
+                await this.configureStorage(conn, connId, source.ref);
             }
             // For Parquet files, try reading row count from file footer metadata first.
             // This avoids parsing column types (which can fail on exotic geometry types)
             // and is faster than SELECT COUNT(*) since it reads only footer bytes.
-            const isParquet = /\.parquet$/i.test(path);
-            if (isParquet) {
+            // Only applicable when we have a concrete file path — SQL-backed sources
+            // (attached DuckLake/DuckDB/SQLite tables) fall through to COUNT(*).
+            const isParquet = source.filePath ? /\.parquet$/i.test(source.filePath) : false;
+            if (isParquet && source.filePath) {
                 try {
-                    const metaResult = await conn.query(`SELECT SUM(num_rows)::BIGINT as cnt FROM parquet_file_metadata('${path}')`);
+                    const metaResult = await conn.query(`SELECT SUM(num_rows)::BIGINT as cnt FROM parquet_file_metadata('${source.filePath}')`);
                     const metaRows = metaResult.toArray();
                     const count = Number(metaRows[0].cnt);
                     log(`getRowCount → ${count} via parquet_file_metadata in ${elapsed(t0)}`);
@@ -471,8 +568,7 @@ export class WasmQueryEngine {
                     logWarn('getRowCount → parquet_file_metadata failed, falling back to COUNT(*):', metaErr?.message ?? metaErr);
                 }
             }
-            const source = buildDuckDbSource(path, path);
-            const result = await conn.query(`SELECT COUNT(*) as cnt FROM ${source}`);
+            const result = await conn.query(`SELECT COUNT(*) as cnt FROM ${source.ref}`);
             const rows = result.toArray();
             const count = Number(rows[0].cnt);
             log(`getRowCount → ${count} via COUNT(*) in ${elapsed(t0)}`);
@@ -486,20 +582,18 @@ export class WasmQueryEngine {
             await conn.close();
         }
     }
-    async getSchemaAndCrs(connId, path, findGeoCol) {
+    async getSchemaAndCrs(connId, source, findGeoCol) {
         const t0 = performance.now();
-        log('getSchemaAndCrs →', path);
+        log('getSchemaAndCrs →', source.ref);
         const db = await getDB();
         const conn = await db.connect();
-        await ensureGeoConversionDisabled(conn);
         try {
             if (connId) {
-                await this.configureStorage(conn, connId);
+                await this.configureStorage(conn, connId, source.ref);
             }
             // Schema detection
             const tSchema = performance.now();
-            const source = buildDuckDbSource(path, path);
-            const result = await conn.query(`DESCRIBE SELECT * FROM ${source}`);
+            const result = await conn.query(`DESCRIBE SELECT * FROM ${source.ref}`);
             const schemaRows = result.toArray();
             const schema = schemaRows.map((row) => ({
                 name: row.column_name,
@@ -516,7 +610,7 @@ export class WasmQueryEngine {
             // CRS detection reusing the same connection
             log(`getSchemaAndCrs → geo column: ${geomCol}, detecting CRS...`);
             const tCrs = performance.now();
-            const crs = await this.detectCrsWithConn(conn, path, geomCol);
+            const crs = await this.detectCrsWithConn(conn, source, geomCol);
             log(`getSchemaAndCrs → CRS: ${crs ?? 'WGS84/null'} in ${elapsed(tCrs)}, total ${elapsed(t0)}`);
             return { schema, geomCol, crs };
         }
@@ -528,9 +622,18 @@ export class WasmQueryEngine {
             await conn.close();
         }
     }
-    async configureStorage(conn, connId) {
+    async configureStorage(conn, connId, sourceRef) {
         try {
-            // Read connection metadata from localStorage
+            // Defensive: callers may pass a destroyed Svelte $derived (returns a
+            // Symbol sentinel) across async boundaries. Template literals below
+            // would throw "can't convert symbol to string" and pollute logs.
+            if (typeof connId !== 'string' || !connId)
+                return;
+            // Presigned HTTPS refs are self-authenticating; no S3 SETs needed.
+            if (sourceRef && isHttpsSourceRef(sourceRef)) {
+                log('configureStorage → presigned HTTPS source, skipping S3 config');
+                return;
+            }
             const stored = localStorage.getItem('obstore-explore-connections');
             if (!stored) {
                 log('configureStorage → no connections in localStorage');
@@ -542,9 +645,13 @@ export class WasmQueryEngine {
                 logWarn(`configureStorage → connection "${connId}" not found`);
                 return;
             }
-            // Azure uses direct HTTPS URLs with SAS token — no S3 config needed
-            if (connection.provider === 'azure') {
-                log('configureStorage → Azure provider, skipping S3 config');
+            // For public and SAS-signed connections DuckDB hits the HTTPS URL
+            // directly — no S3 signing config needed. Saves a worker round-trip
+            // on every query for anonymous/public buckets (AWS, GCS, R2, etc.)
+            // and Azure Blob (SAS token embedded in the URL).
+            const mode = getAccessMode(connection);
+            if (mode !== 'signed-s3') {
+                log(`configureStorage → ${mode}, skipping S3 config`);
                 return;
             }
             // Batch all SET commands into a single query to minimize web worker round-trips
@@ -558,10 +665,16 @@ export class WasmQueryEngine {
             if (connection.region) {
                 sets.push(`SET s3_region = '${connection.region}'`);
             }
-            if (connection.endpoint) {
-                const endpoint = connection.endpoint.replace(/^https?:\/\//, '');
-                sets.push(`SET s3_endpoint = '${endpoint}'`);
-                if (connection.endpoint.startsWith('http://')) {
+            // Non-AWS providers with an empty `endpoint` field fall back to the
+            // provider registry's template, otherwise DuckDB routes them to AWS.
+            let endpoint = connection.endpoint;
+            if (!endpoint && connection.provider && connection.provider !== 's3') {
+                endpoint = resolveProviderEndpoint(connection.provider, connection.region);
+            }
+            if (endpoint) {
+                const endpointHost = endpoint.replace(/^https?:\/\//, '');
+                sets.push(`SET s3_endpoint = '${endpointHost}'`);
+                if (endpoint.startsWith('http://')) {
                     sets.push(`SET s3_use_ssl = false`);
                 }
             }
@@ -577,17 +690,16 @@ export class WasmQueryEngine {
             console.error(LOG_PREFIX, 'configureStorage error:', err);
         }
     }
-    async detectCrs(connId, path, geomCol) {
+    async detectCrs(connId, source, geomCol) {
         const t0 = performance.now();
-        log(`detectCrs → standalone call for "${geomCol}"`, path);
+        log(`detectCrs → standalone call for "${geomCol}"`, source.ref);
         const db = await getDB();
         const conn = await db.connect();
-        await ensureGeoConversionDisabled(conn);
         try {
             if (connId) {
-                await this.configureStorage(conn, connId);
+                await this.configureStorage(conn, connId, source.ref);
             }
-            const crs = await this.detectCrsWithConn(conn, path, geomCol);
+            const crs = await this.detectCrsWithConn(conn, source, geomCol);
             log(`detectCrs → ${crs ?? 'WGS84/null'} in ${elapsed(t0)}`);
             return crs;
         }
@@ -599,7 +711,36 @@ export class WasmQueryEngine {
             await conn.close();
         }
     }
-    async detectCrsWithConn(conn, path, geomCol) {
+    async detectCrsWithConn(conn, source, geomCol) {
+        // Strategy 0: DuckDB v1.5 — CRS embedded in GEOMETRY column type
+        // e.g., GEOMETRY('EPSG:4326') → extract CRS directly from type string.
+        // Works uniformly for file-backed and SQL-backed (attached) sources.
+        try {
+            const t0 = performance.now();
+            const descResult = await conn.query(`SELECT column_type FROM (DESCRIBE SELECT * FROM ${source.ref}) WHERE column_name = '${geomCol}'`);
+            const descRows = descResult.toArray();
+            log(`detectCrs strategy 0 (column type) → ${descRows.length} rows in ${elapsed(t0)}`);
+            if (descRows.length > 0) {
+                const colType = String(descRows[0].column_type);
+                log(`detectCrs strategy 0 → type: "${colType}"`);
+                const result = extractCrsFromTypeString(colType);
+                if (result.found) {
+                    log(`detectCrs strategy 0 → authoritative: ${result.crs ?? 'WGS84/null'} (skipping strategies 1-2)`);
+                    return result.crs;
+                }
+            }
+        }
+        catch (err) {
+            log('detectCrs strategy 0 → skipped:', err?.message ?? err);
+        }
+        // Strategies 1 and 2 rely on file-level Parquet metadata functions.
+        // SQL-backed sources (attached DuckLake/DuckDB/SQLite tables) don't have
+        // a Parquet file path, so strategy 0 is authoritative for them.
+        if (!source.filePath) {
+            log('detectCrs → no filePath, skipping Parquet metadata strategies');
+            return null;
+        }
+        const path = source.filePath;
         // Strategy 1: GeoParquet file-level metadata (geo key in KV metadata)
         try {
             const t1 = performance.now();
@@ -656,11 +797,10 @@ export class WasmQueryEngine {
             log(`queryCancellable → ${sqlPreview}`);
             const db = await getDB();
             conn = await db.connect();
-            await ensureGeoConversionDisabled(conn);
             log(`queryCancellable → connected in ${elapsed(t0)}`);
             try {
                 if (connId) {
-                    await this.configureStorage(conn, connId);
+                    await this.configureStorage(conn, connId, sql);
                 }
                 const tQuery = performance.now();
                 const reader = await conn.send(sql);
@@ -668,6 +808,7 @@ export class WasmQueryEngine {
                 const rows = [];
                 let cols = [];
                 let types = [];
+                let decimalCols = [];
                 const batches = reader[Symbol.asyncIterator]();
                 let first = true;
                 while (true) {
@@ -679,6 +820,12 @@ export class WasmQueryEngine {
                     if (first && batch.schema) {
                         cols = batch.schema.fields.map((f) => f.name);
                         types = batch.schema.fields.map((f) => String(f.type));
+                        decimalCols = [];
+                        for (let i = 0; i < cols.length; i++) {
+                            const s = decimalScale(types[i]);
+                            if (s >= 0)
+                                decimalCols.push({ name: cols[i], scale: s });
+                        }
                         first = false;
                     }
                     for (const row of batch.toArray()) {
@@ -692,6 +839,12 @@ export class WasmQueryEngine {
                                 json[key] = json[key].slice();
                             }
                         }
+                        // DECIMAL raw values are BigInt / Uint32Array (unscaled). Convert
+                        // to a human-readable string via formatDecimal — also drops the
+                        // Uint32Array view, so stale-buffer reuse across batches is moot.
+                        for (const { name, scale } of decimalCols) {
+                            json[name] = formatDecimal(json[name], scale);
+                        }
                         rows.push(json);
                     }
                 }
@@ -732,37 +885,30 @@ export class WasmQueryEngine {
             log(`queryForMapCancellable → geomCol: ${geomCol}, type: ${geomColType}, crs: ${sourceCrs ?? 'WGS84'}`);
             const db = await getDB();
             conn = await db.connect();
-            await ensureGeoConversionDisabled(conn);
             try {
                 if (connId) {
-                    await this.configureStorage(conn, connId);
+                    await this.configureStorage(conn, connId, sql);
                 }
                 // Build geometry expression (same logic as queryForMap)
                 const quoted = `"${geomCol}"`;
                 const upper = geomColType.toUpperCase();
-                const isSpatialType = upper === 'GEOMETRY' ||
-                    upper === 'GEOGRAPHY' ||
-                    upper === 'WKB_BLOB' ||
-                    upper.includes('POINT') ||
-                    upper.includes('LINESTRING') ||
-                    upper.includes('POLYGON') ||
-                    upper.includes('BINARY');
+                const spatialType = isSpatialColumnType(upper);
                 const isWkbBlob = upper === 'BLOB' || upper === 'BYTEA';
                 let wkbExpr;
                 let geomExpr;
                 if (isWkbBlob && !sourceCrs) {
-                    // Already WKB — use directly, no spatial function calls needed.
                     wkbExpr = quoted;
-                    geomExpr = null; // geometry type detected client-side from WKB headers
+                    geomExpr = null;
                 }
                 else {
-                    geomExpr = isSpatialType
+                    geomExpr = spatialType
                         ? quoted
                         : isWkbBlob
-                            ? `ST_GeomFromWKB(${quoted})`
+                            ? wrapWkbWithCrs(quoted, sourceCrs)
                             : `ST_GeomFromGeoJSON(${quoted})`;
                     if (sourceCrs) {
-                        geomExpr = `ST_Transform(${geomExpr}, '${sourceCrs}', '${DEFAULT_TARGET_CRS}', always_xy := true)`;
+                        const effectiveType = isWkbBlob ? `GEOMETRY('${sourceCrs}')` : geomColType;
+                        geomExpr = buildTransformExpr(geomExpr, effectiveType, sourceCrs, DEFAULT_TARGET_CRS);
                     }
                     wkbExpr = `ST_AsWKB(${geomExpr})`;
                 }
@@ -867,10 +1013,24 @@ export class WasmQueryEngine {
         }
         finally {
             dbPromise = null;
-            geoConversionGlobal = false;
             log('forceCancel → done, next getDB() will reinitialize');
         }
     }
+    async registerFileBuffer(name, buffer) {
+        const db = await getDB();
+        await db.registerFileBuffer(name, buffer);
+        log(`registerFileBuffer → "${name}" (${buffer.byteLength} bytes)`);
+    }
+    async dropFile(name) {
+        const db = await getDB();
+        try {
+            await db.dropFile(name);
+            log(`dropFile → "${name}"`);
+        }
+        catch {
+            // Ignore — file may not exist
+        }
+    }
     async releaseMemory() {
         const db = await getDB();
         const conn = await db.connect();

package/dist/storage/adapter.d.ts

@@ -5,6 +5,15 @@ export interface ListPage {
     continuationToken?: string;
     hasMore: boolean;
 }
+/**
+ * Thrown by adapters when the server returns 401 or 403 on an anonymous
+ * request. The browser store catches this to trigger a credential prompt
+ * for auto-detected `?url=` connections that turned out to be private.
+ */
+export declare class AuthRequiredError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
 export interface StorageAdapter {
     list(path: string, signal?: AbortSignal): Promise<FileEntry[]>;
     read(path: string, offset?: number, length?: number, signal?: AbortSignal): Promise<Uint8Array>;