@walkthru-earth/objex 1.1.0 → 1.2.0

package/dist/query/source.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Resolve a Tab to a QuerySource — the abstraction every engine helper
+ * consumes. A tab is either file-backed (path → `read_parquet('url')`) or
+ * SQL-backed (`tab.sourceRef` is a pre-built FROM-clause target, such as an
+ * attached DuckLake table).
+ *
+ * This module is the only place that knows how to map a Tab to both a SQL
+ * FROM target AND a resolved file URL, so TableViewer and DatabaseViewer
+ * stay free of ad-hoc branching.
+ */
+import type { Tab } from '../types.js';
+import type { QuerySource } from './engine.js';
+export interface ResolvedTableSource extends QuerySource {
+    /**
+     * True when the tab is file-backed and hyparquet / parquet metadata
+     * shortcuts apply. False for SQL-backed sources like attached DuckLake
+     * tables.
+     */
+    isFileSource: boolean;
+    /** File URL used for hyparquet metadata fetches. Null for SQL-backed sources. */
+    fileUrl: string | null;
+    /** Display label, typically the tab name. */
+    label: string;
+}
+/**
+ * Resolve a tab to its QuerySource. Must be called lazily (inside reactive
+ * expressions or functions) because `tab.sourceRef` and `tab.path` can change
+ * over a tab's lifetime.
+ */
+export declare function resolveTableSource(tab: Tab): ResolvedTableSource;

package/dist/query/source.js

@@ -0,0 +1,37 @@
+/**
+ * Resolve a Tab to a QuerySource — the abstraction every engine helper
+ * consumes. A tab is either file-backed (path → `read_parquet('url')`) or
+ * SQL-backed (`tab.sourceRef` is a pre-built FROM-clause target, such as an
+ * attached DuckLake table).
+ *
+ * This module is the only place that knows how to map a Tab to both a SQL
+ * FROM target AND a resolved file URL, so TableViewer and DatabaseViewer
+ * stay free of ad-hoc branching.
+ */
+import { buildDuckDbSource } from '../file-icons/index.js';
+import { buildDuckDbUrl } from '../utils/url.js';
+/**
+ * Resolve a tab to its QuerySource. Must be called lazily (inside reactive
+ * expressions or functions) because `tab.sourceRef` and `tab.path` can change
+ * over a tab's lifetime.
+ */
+export function resolveTableSource(tab) {
+    if (tab.sourceRef) {
+        return {
+            ref: tab.sourceRef,
+            filePath: undefined,
+            isFileSource: false,
+            fileUrl: null,
+            label: tab.name
+        };
+    }
+    const fileUrl = buildDuckDbUrl(tab);
+    const ref = buildDuckDbSource(tab.path, fileUrl);
+    return {
+        ref,
+        filePath: tab.path,
+        isFileSource: true,
+        fileUrl,
+        label: tab.name
+    };
+}

package/dist/query/wasm.d.ts

@@ -1,20 +1,22 @@
-import { type MapQueryHandle, type MapQueryResult, type QueryEngine, type QueryHandle, type QueryResult, type SchemaField } from './engine';
+import { type MapQueryHandle, type MapQueryResult, type QueryEngine, type QueryHandle, type QueryResult, type QuerySource, type SchemaField } from './engine';
 export declare class WasmQueryEngine implements QueryEngine {
     query(connId: string, sql: string): Promise<QueryResult>;
     queryForMap(connId: string, sql: string, geomCol: string, geomColType: string, sourceCrs?: string | null): Promise<MapQueryResult>;
-    getSchema(connId: string, path: string): Promise<SchemaField[]>;
-    getRowCount(connId: string, path: string): Promise<number>;
-    getSchemaAndCrs(connId: string, path: string, findGeoCol: (schema: SchemaField[]) => string | null): Promise<{
+    getSchema(connId: string, source: QuerySource): Promise<SchemaField[]>;
+    getRowCount(connId: string, source: QuerySource): Promise<number>;
+    getSchemaAndCrs(connId: string, source: QuerySource, findGeoCol: (schema: SchemaField[]) => string | null): Promise<{
         schema: SchemaField[];
         geomCol: string | null;
         crs: string | null;
     }>;
     private configureStorage;
-    detectCrs(connId: string, path: string, geomCol: string): Promise<string | null>;
+    detectCrs(connId: string, source: QuerySource, geomCol: string): Promise<string | null>;
     private detectCrsWithConn;
     queryCancellable(connId: string, sql: string): QueryHandle;
     queryForMapCancellable(connId: string, sql: string, geomCol: string, geomColType: string, sourceCrs?: string | null): MapQueryHandle;
     forceCancel(): Promise<void>;
+    registerFileBuffer(name: string, buffer: Uint8Array): Promise<void>;
+    dropFile(name: string): Promise<void>;
     releaseMemory(): Promise<void>;
     dispose(): Promise<void>;
 }

package/dist/query/wasm.js

@@ -1,6 +1,7 @@
 import { DEFAULT_TARGET_CRS, DUCKDB_INIT_TIMEOUT_MS, WGS84_CODES } from '../constants.js';
-import { buildDuckDbSource } from '../file-icons/index.js';
+import { getAccessMode } from '../storage/providers.js';
 import { credentialStore } from '../stores/credentials.svelte.js';
+import { buildTransformExpr, wrapWkbWithCrs } from '../utils/geometry-type.js';
 import { QueryCancelledError } from './engine';
 const DUCKDB_VERSION = __DUCKDB_WASM_VERSION__;
 const CDN_BASE = `https://cdn.jsdelivr.net/npm/@duckdb/duckdb-wasm@${DUCKDB_VERSION}/dist`;
@@ -66,21 +67,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 +105,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)
@@ -264,7 +295,6 @@ 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 {
@@ -316,50 +346,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);
             }
             // 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 +435,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);
             }
-            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,12 +462,11 @@ 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);
@@ -458,10 +474,12 @@ export class WasmQueryEngine {
             // 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 +489,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 +503,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);
             }
             // 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 +531,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 };
         }
@@ -542,9 +557,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
@@ -577,17 +596,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);
             }
-            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 +617,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,7 +703,6 @@ 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) {
@@ -732,7 +778,6 @@ 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);
@@ -740,29 +785,23 @@ export class WasmQueryEngine {
                 // 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 +906,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/providers.d.ts

@@ -38,6 +38,26 @@ export interface ProviderDef {
     schemes: string[];
 }
 export declare const PROVIDERS: Record<ProviderId, ProviderDef>;
+export interface CorsHelp {
+    /** True if the provider returns CORS headers by default. */
+    defaultEnabled: boolean;
+    /** Official CORS configuration docs URL. */
+    docsUrl?: string;
+    /** Brief note shown in the UI. */
+    note?: string;
+    /** CLI steps when no console UI or docs are insufficient. */
+    cliSteps?: string[];
+}
+export declare const CORS_HELP: Record<ProviderId, CorsHelp>;
+export interface ReadOnlyHelp {
+    /** Brief note shown in the UI. */
+    note: string;
+    /** Official docs URL. */
+    docsUrl?: string;
+    /** CLI steps to apply a read-only bucket policy. */
+    cliSteps?: string[];
+}
+export declare const READ_ONLY_HELP: Partial<Record<ProviderId, ReadOnlyHelp>>;
 /** All provider IDs, ordered for the UI. */
 export declare const PROVIDER_IDS: ProviderId[];
 /** Get provider def, falling back to S3 for unknown. */
@@ -51,3 +71,30 @@ export declare function buildEndpointFromTemplate(id: ProviderId, region: string
 export declare function buildProviderBaseUrl(provider: ProviderId, endpoint: string, bucket: string, region: string): string;
 /** Check if a provider uses the GCS JSON API (not S3 XML). */
 export declare function isGcsProvider(provider: string, endpoint: string): boolean;
+/**
+ * Minimal connection shape needed to decide access mode.
+ * Kept loose so callers don't need to import the full Connection type.
+ */
+export interface AccessModeInput {
+    provider: string;
+    anonymous?: boolean;
+    endpoint?: string;
+}
+/**
+ * How a connection's files can be read by the browser:
+ *
+ * - `public-https`: plain HTTPS via any HTTP client. No auth, no signing.
+ *   Covers anonymous AWS/GCS/R2/Storj/Wasabi/etc.
+ * - `sas-https`: HTTPS with SAS token embedded in the URL. Still works with
+ *   any HTTP client. Azure only.
+ * - `signed-s3`: requires SigV4 signing. DuckDB uses the `s3://` URI and
+ *   signs it via its S3 config; other viewers must go through the storage
+ *   adapter (which returns a blob) instead of streaming the HTTPS URL.
+ */
+export type AccessMode = 'public-https' | 'sas-https' | 'signed-s3';
+export declare function getAccessMode(conn: AccessModeInput): AccessMode;
+/**
+ * True when the connection's files can be fetched by any HTTP client
+ * (fetch/img/video/DuckDB httpfs/COG/Zarr/etc.) without the storage adapter.
+ */
+export declare function isPubliclyStreamable(conn: AccessModeInput): boolean;