@walkthru-earth/objex 0.1.0

package/dist/i18n/en.js

@@ -0,0 +1,404 @@
+export const en = {
+    // Sidebar
+    'sidebar.deleteConfirm': 'Delete connection "{name}"?',
+    'sidebar.browseDetected': 'Browse detected bucket: {name}',
+    'sidebar.addConnection': 'Add connection',
+    'sidebar.edit': 'Edit',
+    'sidebar.delete': 'Delete',
+    // Connection Dialog
+    'connection.editTitle': 'Edit Connection',
+    'connection.newTitle': 'New Connection',
+    'connection.editDescription': 'Update the connection settings below.',
+    'connection.newDescription': 'Configure a new cloud storage connection.',
+    'connection.name': 'Name',
+    'connection.provider': 'Provider',
+    'connection.bucket': 'Bucket',
+    'connection.container': 'Container',
+    'connection.bucketPlaceholder': 'my-bucket or s3://bucket or https://endpoint/bucket',
+    'connection.containerPlaceholder': 'my-container',
+    'connection.clickToApply': '— click to apply',
+    'connection.azureBucketHelper': 'Azure Blob container name.',
+    'connection.s3BucketHelper': 'Paste an S3 URL or bucket name. URLs are auto-detected.',
+    'connection.region': 'Region',
+    'connection.endpoint': 'Endpoint',
+    'connection.azureEndpointHelper': 'Azure Blob Storage endpoint, e.g. https://myaccount.blob.core.windows.net',
+    'connection.storjEndpointHelper': 'Storj S3 gateway. Use gateway.us1/eu1/ap1.storjshare.io for a specific region.',
+    'connection.endpointHelper': 'Leave empty for default AWS endpoint. Required for MinIO, R2, and other S3-compatible services.',
+    'connection.anonymous': 'Anonymous Access',
+    'connection.sasToken': 'SAS Token',
+    'connection.sasTokenHelper': 'Shared Access Signature token for Azure Blob Storage.',
+    '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.testSuccess': 'Connection successful',
+    'connection.testFail': 'Connection failed. Check your settings and try again.',
+    'connection.testButton': 'Test Connection',
+    'connection.testing': 'Testing...',
+    'connection.cancel': 'Cancel',
+    'connection.update': 'Update',
+    'connection.create': 'Create',
+    'connection.saving': 'Saving...',
+    // Theme
+    'theme.light': 'Light',
+    'theme.dark': 'Dark',
+    'theme.system': 'System',
+    'theme.tooltip': '{mode} mode',
+    // Safe Lock
+    'safeLock.enabledAria': 'Safe lock enabled (read-only)',
+    'safeLock.disabledAria': 'Safe lock disabled (writes allowed)',
+    'safeLock.enabledTooltip': 'Safe lock ON — write operations disabled',
+    'safeLock.disabledTooltip': 'Safe lock OFF — write operations enabled',
+    // Status Bar
+    'statusBar.item': 'item',
+    'statusBar.items': 'items',
+    'statusBar.web': 'Web',
+    // Tab Bar
+    'tabBar.closeTab': 'Close tab {name}',
+    'tabBar.copyHttps': 'Copy HTTPS link',
+    'tabBar.copyStorage': 'Copy S3 link',
+    'tabBar.copied': 'Copied!',
+    'tabBar.closeOtherTabs': 'Close other tabs',
+    // File Tree Sidebar
+    'fileTree.refresh': 'Refresh',
+    'fileTree.filterPlaceholder': 'Filter files...',
+    'fileTree.noMatch': 'No matching files',
+    'fileTree.emptyBucket': 'Empty bucket',
+    'fileTree.expandDir': 'Expand directory',
+    'fileTree.copyHttpUrl': 'Copy HTTPS URL',
+    'fileTree.copyNativeUri': 'Copy {scheme} URI',
+    'fileTree.copyPath': 'Copy path',
+    'fileTree.copyName': 'Copy name',
+    'fileTree.open': 'Open',
+    'fileTree.copied': 'Copied!',
+    // File Row
+    'fileRow.rename': 'Rename {name}',
+    'fileRow.delete': 'Delete {name}',
+    // Upload
+    'upload.uploading': 'Uploading',
+    'upload.upload': 'Upload',
+    // Create Folder
+    'createFolder.title': 'New Folder',
+    'createFolder.description': 'Create a new folder in the current directory.',
+    'createFolder.placeholder': 'Folder name',
+    'createFolder.cancel': 'Cancel',
+    'createFolder.creating': 'Creating...',
+    'createFolder.create': 'Create',
+    // Breadcrumb
+    'breadcrumb.root': 'Navigate to root',
+    // Drop Zone
+    'dropZone.message': 'Drop files to upload',
+    // File Browser
+    'fileBrowser.newFolder': 'New Folder',
+    'fileBrowser.name': 'Name',
+    'fileBrowser.size': 'Size',
+    'fileBrowser.modified': 'Modified',
+    'fileBrowser.noMatch': 'No files matching "{query}"',
+    'fileBrowser.empty': 'This folder is empty',
+    // Search Bar
+    'searchBar.label': 'Filter files',
+    'searchBar.placeholder': 'Filter files...',
+    'searchBar.clear': 'Clear search',
+    // Delete Confirm
+    'deleteConfirm.title': 'Confirm Delete',
+    'deleteConfirm.description': 'This action cannot be undone.',
+    'deleteConfirm.message': 'Are you sure you want to delete',
+    'deleteConfirm.andContents': 'and all its contents',
+    'deleteConfirm.cancel': 'Cancel',
+    'deleteConfirm.delete': 'Delete',
+    'deleteConfirm.deleting': 'Deleting...',
+    // Rename Dialog
+    'rename.title': 'Rename',
+    'rename.description': 'Enter a new name for',
+    'rename.placeholder': 'New name',
+    'rename.cancel': 'Cancel',
+    'rename.rename': 'Rename',
+    'rename.renaming': 'Renaming...',
+    // Table Viewer
+    'table.queryCancelled': 'Query cancelled',
+    'table.preparingQuery': 'Preparing query...',
+    'table.initEngine': 'Initializing query engine...',
+    'table.loadingSchema': 'Loading schema...',
+    'table.runningQuery': 'Running query...',
+    'table.runningCustomQuery': 'Running custom query...',
+    'table.countingRows': 'Counting total rows...',
+    'table.run': 'Run',
+    'table.running': 'Running...',
+    'table.format': 'Format',
+    'table.loading': 'Loading...',
+    'table.cancel': 'Cancel',
+    'table.readingMetadata': 'Reading file metadata...',
+    'table.bootingEngine': 'Booting DuckDB-WASM...',
+    'table.enterSql': 'Enter SQL query... (Cmd+Enter to run)',
+    'table.copyCell': 'Copy Cell',
+    'table.copyRow': 'Copy Row (JSON)',
+    'table.copyColumn': 'Copy Column',
+    'table.forceStop': 'Force Stop',
+    'table.forceStopWarning': 'Terminates the database worker. Use as a last resort.',
+    'table.cancellingQuery': 'Cancelling query...',
+    'sql.cancel': 'Cancel',
+    // Load Progress labels
+    'progress.format': 'Format',
+    'progress.source': 'Source',
+    'progress.columns': 'Columns',
+    'progress.rows': 'Rows',
+    'progress.geometry': 'Geometry',
+    'progress.crs': 'CRS',
+    'progress.bounds': 'Bounds',
+    'progress.encoding': 'Encoding',
+    'progress.compression': 'Compress.',
+    'progress.rowGroups': 'Row Groups',
+    'progress.createdBy': 'Created By',
+    'progress.rangeRequest': 'Range request (hyparquet)',
+    'progress.duckdbFallback': 'DuckDB-WASM',
+    'progress.stacDetected': 'STAC catalog detected',
+    // File Info view
+    'fileInfo.fileMetadata': 'File Metadata',
+    'fileInfo.geometry': 'Geometry',
+    'fileInfo.schema': 'Schema',
+    'fileInfo.column': 'Column',
+    'fileInfo.type': 'Type',
+    'fileInfo.noMetadata': 'No metadata available',
+    'fileInfo.parquetExplorer': 'Parquet Table Explorer',
+    // Table Toolbar
+    'toolbar.copied': 'Copied!',
+    'toolbar.https': 'HTTPS',
+    'toolbar.s3': 'S3',
+    'toolbar.copyHttps': 'Copy HTTPS link',
+    'toolbar.copyS3': 'Copy S3 link',
+    'toolbar.copyUrl': 'Copy URL',
+    'toolbar.copyHttpsLink': 'HTTPS link',
+    'toolbar.copyProviderLink': '{provider} link',
+    'toolbar.map': 'Map',
+    'toolbar.table': 'Table',
+    'toolbar.stacMap': 'STAC Map',
+    'toolbar.switchToMap': 'Switch to Map',
+    'toolbar.switchToTable': 'Switch to Table',
+    'toolbar.history': 'History',
+    'toolbar.showHistory': 'Show History',
+    'toolbar.hideHistory': 'Hide History',
+    'toolbar.info': 'Info',
+    'toolbar.pageSize': 'Page size',
+    'toolbar.rows': 'rows',
+    'toolbar.firstPage': 'First page',
+    'toolbar.prev': 'Prev',
+    'toolbar.next': 'Next',
+    'toolbar.lastPage': 'Last page',
+    'toolbar.jumpToPage': 'Click to jump to page',
+    // Database Viewer
+    'database.badge': 'Database',
+    'database.tables': 'tables',
+    'database.sql': 'SQL',
+    'database.loading': 'Loading database...',
+    'database.tablesHeader': 'Tables',
+    'database.loadingTable': 'Loading table...',
+    'database.selectTable': 'Select a table to browse',
+    // PDF Viewer
+    'pdf.badge': 'PDF',
+    'pdf.loading': 'Loading PDF...',
+    'pdf.prev': 'Prev',
+    'pdf.next': 'Next',
+    'pdf.zoomIn': 'Zoom in',
+    'pdf.zoomOut': 'Zoom out',
+    'pdf.zoom': 'Zoom',
+    // Image Viewer
+    'image.loading': 'Loading image...',
+    'image.zoomIn': 'Zoom in',
+    'image.zoomOut': 'Zoom out',
+    'image.fit': 'Fit',
+    'image.rotate': 'Rotate',
+    'image.fullscreen': 'Fullscreen',
+    // 3D Model Viewer
+    'model.badge': '3D',
+    'model.meshes': 'meshes',
+    'model.vertices': 'vertices',
+    'model.wireframe': 'Wireframe',
+    'model.reset': 'Reset',
+    'model.fullscreen': 'Fullscreen',
+    'model.loading': 'Loading 3D model...',
+    // Markdown Viewer
+    'markdown.badge': 'Markdown',
+    'markdown.evidence': 'Evidence',
+    'markdown.edit': 'Edit',
+    'markdown.view': 'View',
+    // Zarr Viewer
+    'zarr.badge': 'Zarr',
+    'zarr.variables': 'variables',
+    'zarr.inspect': 'Inspect',
+    'zarr.map': 'Map',
+    'zarr.loading': 'Loading Zarr metadata...',
+    // Archive Viewer
+    'archive.badge': 'Archive',
+    'archive.entries': 'entries',
+    'archive.streamed': 'Streamed',
+    'archive.fullDownload': 'Full Download',
+    'archive.loading': 'Loading archive...',
+    'archive.scanning': 'Scanning...',
+    'archive.scanningProgress': 'Scanning archive... {count} entries found',
+    'archive.empty': 'Empty directory',
+    'archive.unsupported': 'Unsupported archive format',
+    'archive.contents': 'Contents',
+    'archive.fileDetails': 'File Details',
+    'archive.fileName': 'Name',
+    'archive.path': 'Path',
+    'archive.size': 'Size',
+    'archive.compressed': 'Compressed',
+    'archive.modified': 'Modified',
+    'archive.download': 'Download',
+    'archive.selectFolder': 'Select a folder',
+    'archive.selectFile': 'Select a file',
+    // Raw Viewer
+    'raw.loading': 'Loading hex dump...',
+    'raw.showingFirst': 'showing first {size}',
+    // Code Viewer
+    'code.maplibreStyle': 'MapLibre Style',
+    'code.editStyle': 'Edit Style',
+    'code.tileJson': 'TileJSON',
+    'code.noWrap': 'No Wrap',
+    'code.wrap': 'Wrap',
+    'code.copied': 'Copied!',
+    'code.copy': 'Copy',
+    'code.format': 'Format',
+    'code.raw': 'Raw',
+    'code.loading': 'Loading...',
+    'code.stacCatalog': 'STAC Catalog',
+    'code.stacCollection': 'STAC Collection',
+    'code.stacItem': 'STAC Item',
+    'code.browseStac': 'Browse',
+    'code.keplerGl': 'Kepler.gl',
+    'code.openKepler': 'Open Map',
+    'code.code': 'Code',
+    'code.marimoNotebook': 'marimo Notebook',
+    'code.openPlayground': 'Playground',
+    'code.preview': 'Preview',
+    'code.viewSource': 'View Source',
+    // Table Status Bar
+    'statusBar.runningQuery': 'Running query...',
+    'statusBar.rowsLabel': 'rows',
+    'statusBar.inTime': 'in {time}ms',
+    'statusBar.noResults': 'No results',
+    'statusBar.export': 'Export',
+    'statusBar.exportCsv': 'Export as CSV',
+    'statusBar.exportJson': 'Export as JSON',
+    // Query History
+    'queryHistory.title': 'Query History',
+    'queryHistory.clearAll': 'Clear all',
+    'queryHistory.searchPlaceholder': 'Search queries...',
+    'queryHistory.justNow': 'just now',
+    'queryHistory.minsAgo': '{n}m ago',
+    'queryHistory.hoursAgo': '{n}h ago',
+    'queryHistory.daysAgo': '{n}d ago',
+    // Map Viewers
+    'map.loadingData': 'Loading map data...',
+    'map.loadingGeometry': 'Loading geometry data...',
+    'map.loadingPmtiles': 'Loading PMTiles...',
+    'map.loadingFgb': 'Loading FlatGeobuf...',
+    'map.loadingCog': 'Loading COG...',
+    'map.loadingZarr': 'Loading Zarr data...',
+    'map.features': 'features',
+    'map.limit': '(limit)',
+    'map.of': 'of',
+    'map.attributes': 'Attributes',
+    'map.flyToFirst': 'Fly to first feature',
+    'map.info': 'Info',
+    'map.archiveInfo': 'Archive Info',
+    'map.flatgeobufInfo': 'FlatGeobuf Info',
+    'map.cogInfo': 'COG Info',
+    'map.cogCorsError': 'Cannot load COG: the server does not allow cross-origin requests (CORS). The file must be hosted with CORS headers enabled.',
+    'map.cogUnsupportedFormat': 'This COG uses {{type}} format which is not supported for map rendering. Only RGB COGs can be displayed.',
+    'map.noGeoColumn': 'No geometry column detected in schema',
+    'map.noData': 'No data available for map view',
+    'map.webglLost': 'WebGL context lost',
+    'map.retry': 'Retry',
+    'map.noFeatures': 'No features found in FlatGeobuf file',
+    'map.layers': 'layer',
+    'map.layersPlural': 'layers',
+    'map.tiles': 'tiles',
+    'map.variable': 'Variable:',
+    // Map info panel labels
+    'mapInfo.name': 'Name',
+    'mapInfo.description': 'Description',
+    'mapInfo.specVersion': 'Spec Version',
+    'mapInfo.tileFormat': 'Tile Format',
+    'mapInfo.zoomRange': 'Zoom Range',
+    'mapInfo.tileCompression': 'Tile Compression',
+    'mapInfo.internalCompression': 'Internal Compression',
+    'mapInfo.clustered': 'Clustered',
+    'mapInfo.yes': 'Yes',
+    'mapInfo.no': 'No',
+    'mapInfo.addressedTiles': 'Addressed Tiles',
+    'mapInfo.tileEntries': 'Tile Entries',
+    'mapInfo.uniqueContents': 'Unique Contents',
+    'mapInfo.bounds': 'Bounds',
+    'mapInfo.center': 'Center',
+    'mapInfo.layers': 'Layers',
+    'mapInfo.attribution': 'Attribution',
+    'mapInfo.dataVersion': 'Data Version',
+    'mapInfo.title': 'Title',
+    'mapInfo.geometryType': 'Geometry Type',
+    'mapInfo.totalFeatures': 'Total Features',
+    'mapInfo.spatialIndex': 'Spatial Index',
+    'mapInfo.yesRTree': 'Yes (packed R-tree)',
+    'mapInfo.crs': 'CRS',
+    'mapInfo.columns': 'Columns',
+    'mapInfo.size': 'Size',
+    'mapInfo.bands': 'Bands',
+    // PMTiles Viewer
+    'pmtiles.mapView': 'Map',
+    'pmtiles.archiveView': 'Archive',
+    'pmtiles.inspectorView': 'Inspector',
+    'pmtiles.layers': 'Layers',
+    'pmtiles.allLayers': 'All layers',
+    'pmtiles.showTileBounds': 'Tile grid',
+    'pmtiles.inspectFeatures': 'Inspect',
+    'pmtiles.fitBounds': 'Fit to bounds',
+    // PMTiles Archive
+    'pmtiles.archiveStats': 'Archive Statistics',
+    'pmtiles.directoryBrowser': 'Directory Browser',
+    'pmtiles.zoomLevels': 'Zoom Levels',
+    'pmtiles.tilesAtZoom': 'Tiles at z{zoom}',
+    'pmtiles.entryDetails': 'Entry Details',
+    'pmtiles.openInInspector': 'Open in Inspector',
+    'pmtiles.noEntries': 'No entries at this zoom',
+    'pmtiles.jsonMetadata': 'JSON Metadata',
+    'pmtiles.headerLayout': 'Header Layout',
+    'pmtiles.rootDirectory': 'Root Directory',
+    'pmtiles.leafDirectories': 'Leaf Directories',
+    'pmtiles.tileData': 'Tile Data',
+    'pmtiles.metadata': 'Metadata',
+    'pmtiles.offset': 'Offset',
+    'pmtiles.length': 'Length',
+    'pmtiles.dedupRatio': 'Dedup Ratio',
+    'pmtiles.totalSize': 'Total Size',
+    // PMTiles Tile Inspector
+    'pmtiles.fetchTile': 'Fetch',
+    'pmtiles.tileNotFound': 'Tile not found',
+    'pmtiles.tileSize': 'Size',
+    'pmtiles.featureProperties': 'Feature Properties',
+    'pmtiles.selectFeature': 'Click a feature to inspect',
+    'pmtiles.rasterPreview': 'Raster preview',
+    'pmtiles.noTileLoaded': 'Enter Z/X/Y and fetch a tile',
+    'pmtiles.parent': 'Parent',
+    'pmtiles.featureCount': 'features',
+    'pmtiles.layerName': 'Layer',
+    'pmtiles.featureType': 'Type',
+    'pmtiles.featureId': 'ID',
+    // Page
+    'page.selectFile': 'Pick something',
+    'page.selectFileDescription': 'Browse the file tree and click a file to peek inside.',
+    'page.noFileOpen': 'Nothing here yet',
+    'page.noFileDescription': 'Add a bucket from the sidebar to start exploring.',
+    'page.supportsFormats': 'Parquet · Cloud Optimized GeoTIFF · FlatGeobuf · PMTiles · CSV · PDF · 3D and more',
+    'page.addConnection': 'Add connection',
+    'page.tryExample': 'Try an example',
+    // Mobile
+    'mobile.openSidebar': 'Open file browser',
+    'mobile.fileExplorer': 'File Explorer',
+    // Notebook Viewer
+    'notebook.badge': 'Jupyter Notebook',
+    'notebook.cells': 'cells',
+    'notebook.loading': 'Loading notebook...',
+    'notebook.hideCode': 'Hide Code',
+    'notebook.showCode': 'Show Code',
+    // Locale
+    'locale.toggle': 'Language'
+};

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

@@ -0,0 +1,9 @@
+export type Locale = 'en' | 'ar';
+export declare function getLocale(): Locale;
+export declare function setLocale(l: Locale): void;
+export declare function getDir(): 'ltr' | 'rtl';
+/**
+ * Translate a key, interpolating `{param}` placeholders.
+ * Falls back to English, then to the raw key.
+ */
+export declare function t(key: string, params?: Record<string, string | number>): string;

package/dist/i18n/index.svelte.js

@@ -0,0 +1,27 @@
+import { ar } from './ar.js';
+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;
+}
+export function getDir() {
+    return RTL_LOCALES.has(currentLocale) ? 'rtl' : 'ltr';
+}
+/**
+ * Translate a key, interpolating `{param}` placeholders.
+ * Falls back to English, then to the raw key.
+ */
+export function t(key, params) {
+    let text = translations[currentLocale]?.[key] ?? translations.en[key] ?? key;
+    if (params) {
+        for (const [k, v] of Object.entries(params)) {
+            text = text.replaceAll(`{${k}}`, String(v));
+        }
+    }
+    return text;
+}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export type { DuckDbReadFn, FileCategory, FileTypeInfo, ViewerKind } from './file-icons/index.js';
+export { buildDuckDbSource, getDuckDbReadFn, getFileTypeInfo, getMimeType, getViewerKind, isCloudNativeFormat, isQueryable } from './file-icons/index.js';
+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 { UrlAdapter } from './storage/url-adapter.js';
+export type { Connection, ConnectionConfig, FileEntry, Tab, Theme, WriteResult } from './types.js';
+export type { TypeCategory } from './utils/column-types.js';
+export { classifyType, typeBadgeClass, typeColor, typeLabel } from './utils/column-types.js';
+export { formatDate, formatFileSize, getFileExtension } 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 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';
+export { describeParseResult, looksLikeUrl, parseStorageUrl } from './utils/storage-url.js';
+export type { GeoType, ParsedGeometry } from './utils/wkb.js';
+export { findGeoColumn, findGeoColumnFromRows, parseWKB, toBinary } from './utils/wkb.js';

package/dist/index.js

@@ -0,0 +1,13 @@
+// Core types
+// File icons registry
+export { buildDuckDbSource, getDuckDbReadFn, getFileTypeInfo, getMimeType, getViewerKind, isCloudNativeFormat, isQueryable } from './file-icons/index.js';
+export { QueryCancelledError } from './query/engine.js';
+export { UrlAdapter } from './storage/url-adapter.js';
+export { classifyType, typeBadgeClass, typeColor, typeLabel } from './utils/column-types.js';
+export { formatDate, formatFileSize, getFileExtension } from './utils/format.js';
+export { buildGeoArrowTables, normalizeGeomType } from './utils/geoarrow.js';
+export { generateHexDump } from './utils/hex.js';
+export { extractBounds, extractEpsgFromGeoMeta, extractGeometryTypes, readParquetMetadata } from './utils/parquet-metadata.js';
+export { describeParseResult, looksLikeUrl, parseStorageUrl } from './utils/storage-url.js';
+// Utilities
+export { findGeoColumn, findGeoColumnFromRows, parseWKB, toBinary } from './utils/wkb.js';

package/dist/query/CLAUDE.md

@@ -0,0 +1,22 @@
+# query/
+
+DuckDB-WASM query engine. Single worker, cancellable queries.
+
+```mermaid
+graph TD
+    A[index.ts<br/>getQueryEngine] -->|lazy init| B[wasm.ts<br/>WasmQueryEngine]
+    B -->|conn.send| C[DuckDB Worker]
+    B -->|conn.cancelSent| C
+    B -->|db.terminate| C
+    D[engine.ts] -->|types| A
+```
+
+| File | Exports | Used by |
+|------|---------|---------|
+| `engine.ts` | `QueryEngine`, `QueryResult`, `MapQueryResult`, `SchemaField`, `QueryHandle`, `MapQueryHandle`, `QueryCancelledError` | TableViewer, GeoParquetMapViewer, FileInfo, evidence-context, lib/index.ts |
+| `wasm.ts` | `WasmQueryEngine` | index.ts (lazy import) |
+| `index.ts` | `getQueryEngine()`, re-exports all types | TableViewer, DatabaseViewer, SqlEditor, evidence-context |
+
+- `conn.send()` for data queries (non-blocking, cancellable)
+- `conn.query()` only for fast metadata queries
+- `enable_geoparquet_conversion = false` set at DB init

package/dist/query/engine.d.ts

@@ -0,0 +1,56 @@
+export declare class QueryCancelledError extends Error {
+    constructor();
+}
+export interface QueryHandle {
+    result: Promise<QueryResult>;
+    cancel: () => Promise<boolean>;
+}
+export interface MapQueryHandle {
+    result: Promise<MapQueryResult>;
+    cancel: () => Promise<boolean>;
+}
+export interface QueryResult {
+    columns: string[];
+    types: string[];
+    rowCount: number;
+    /** Pre-parsed rows — avoids Arrow version mismatch in WASM engine */
+    rows: Record<string, any>[];
+}
+/** Raw column data for map rendering (bypasses toJSON serialization). */
+export interface MapQueryResult {
+    /** Geometry column as raw WKB binary arrays */
+    wkbArrays: Uint8Array[];
+    /** Geometry type from ST_GeometryType (e.g., 'POLYGON') */
+    geometryType: string;
+    /** Non-geometry attribute columns: name → JS values */
+    attributes: Map<string, {
+        values: any[];
+        type: string;
+    }>;
+    /** Number of rows */
+    rowCount: number;
+}
+export interface SchemaField {
+    name: string;
+    type: string;
+    nullable: boolean;
+}
+export interface 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>;
+    /** Detect CRS from GeoParquet metadata. Returns e.g. 'EPSG:27700' or null if WGS84/unknown. */
+    detectCrs(connId: string, path: string, geomCol: string): Promise<string | null>;
+    /** Combined schema + CRS detection in a single connection (fewer web worker round-trips). */
+    getSchemaAndCrs?(connId: string, path: string, findGeoCol: (schema: SchemaField[]) => string | null): Promise<{
+        schema: SchemaField[];
+        geomCol: string | null;
+        crs: string | null;
+    }>;
+    queryCancellable?(connId: string, sql: string): QueryHandle;
+    queryForMapCancellable?(connId: string, sql: string, geomCol: string, geomColType: string, sourceCrs?: string | null): MapQueryHandle;
+    forceCancel?(): Promise<void>;
+    releaseMemory(): Promise<void>;
+    dispose(): Promise<void>;
+}

package/dist/query/engine.js

@@ -0,0 +1,6 @@
+export class QueryCancelledError extends Error {
+    constructor() {
+        super('Query cancelled');
+        this.name = 'QueryCancelledError';
+    }
+}

package/dist/query/index.d.ts

@@ -0,0 +1,4 @@
+import type { QueryEngine } from './engine';
+export declare function getQueryEngine(): Promise<QueryEngine>;
+export type { MapQueryHandle, MapQueryResult, QueryEngine, QueryHandle, QueryResult, SchemaField } from './engine';
+export { QueryCancelledError } from './engine';

package/dist/query/index.js

@@ -0,0 +1,19 @@
+// Cache the promise (not the resolved value) to prevent race conditions.
+// Multiple concurrent callers before the first resolves would otherwise
+// each create a separate WasmQueryEngine instance.
+let enginePromise = null;
+export async function getQueryEngine() {
+    if (!enginePromise) {
+        enginePromise = (async () => {
+            console.log('[query] Using WASM DuckDB engine (browser)');
+            const { WasmQueryEngine } = await import('./wasm');
+            return new WasmQueryEngine();
+        })();
+        // If init fails, clear the promise so it can be retried
+        enginePromise.catch(() => {
+            enginePromise = null;
+        });
+    }
+    return enginePromise;
+}
+export { QueryCancelledError } from './engine';

package/dist/query/wasm.d.ts

@@ -0,0 +1,20 @@
+import { type MapQueryHandle, type MapQueryResult, type QueryEngine, type QueryHandle, type QueryResult, 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<{
+        schema: SchemaField[];
+        geomCol: string | null;
+        crs: string | null;
+    }>;
+    private configureStorage;
+    detectCrs(connId: string, path: string, 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>;
+    releaseMemory(): Promise<void>;
+    dispose(): Promise<void>;
+}