@walkthru-earth/objex 1.1.0 → 1.2.1

package/dist/utils/deck.d.ts

@@ -33,24 +33,6 @@ export declare function loadDeckModules(): Promise<{
     MapboxOverlay: typeof import("@deck.gl/mapbox").MapboxOverlay;
     GeoJsonLayer: typeof import("@deck.gl/layers").GeoJsonLayer;
 }>;
-export interface DeckOverlayOptions {
-    layerId: string;
-    data: GeoJSON.FeatureCollection;
-    /** Called with properties and the full GeoJSON Feature (for selection highlight). */
-    onClick?: (properties: Record<string, any>, feature: GeoJSON.Feature) => void;
-    /** Layer-level onHover — use hoverCursor(map) to toggle pointer on MapLibre canvas. */
-    onHover?: (info: {
-        picked?: boolean;
-    }) => void;
-}
-/**
- * Create a MapboxOverlay with a single GeoJsonLayer.
- * Colors are assigned per-feature based on geometry type.
- */
-export declare function createDeckOverlay(modules: {
-    MapboxOverlay: any;
-    GeoJsonLayer: any;
-}, options: DeckOverlayOptions): any;
 /** Lazy-load GeoArrow deck.gl layers + MapboxOverlay + GeoJsonLayer (for selection). */
 export declare function loadGeoArrowModules(): Promise<{
     GeoArrowArcLayer: typeof import("@geoarrow/deck.gl-layers").GeoArrowArcLayer;

package/dist/utils/deck.js

@@ -46,42 +46,6 @@ export async function loadDeckModules() {
     ]);
     return { MapboxOverlay, GeoJsonLayer };
 }
-/**
- * Create a MapboxOverlay with a single GeoJsonLayer.
- * Colors are assigned per-feature based on geometry type.
- */
-export function createDeckOverlay(modules, options) {
-    const { MapboxOverlay, GeoJsonLayer } = modules;
-    const { layerId, data, onClick, onHover } = options;
-    return new MapboxOverlay({
-        interleaved: false,
-        layers: [
-            new GeoJsonLayer({
-                id: layerId,
-                data,
-                pickable: true,
-                stroked: true,
-                filled: true,
-                pointType: 'circle',
-                getFillColor: geojsonFillColor,
-                getLineColor: geojsonLineColor,
-                getPointRadius: 6,
-                getLineWidth: 2.5,
-                lineWidthMinPixels: 1.5,
-                pointRadiusMinPixels: 4,
-                pointRadiusMaxPixels: 12,
-                autoHighlight: true,
-                highlightColor: [255, 255, 255, 100],
-                onHover,
-                onClick: (info) => {
-                    if (info.object?.properties && onClick) {
-                        onClick({ ...info.object.properties }, info.object);
-                    }
-                }
-            })
-        ]
-    });
-}
 // ─── GeoArrow overlay (GeoParquetMapViewer) ──────────────────────────
 /** Lazy-load GeoArrow deck.gl layers + MapboxOverlay + GeoJsonLayer (for selection). */
 export async function loadGeoArrowModules() {

package/dist/utils/geometry-type.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Helpers for parsing DuckDB v1.5 parameterized GEOMETRY type strings.
+ *
+ * DuckDB v1.5 made GEOMETRY a core type with an optional CRS parameter:
+ *   GEOMETRY                  — no CRS attached
+ *   GEOMETRY('EPSG:4326')     — EPSG form
+ *   GEOMETRY('OGC:CRS84')     — OGC form (canonical for GeoParquet 1.1+)
+ *   GEOMETRY('EPSG:27700')    — projected CRS
+ *
+ * Type strings may come from `DESCRIBE`, from the Arrow schema, or from a
+ * legacy code path that still reports `BLOB`. Use these helpers everywhere
+ * instead of ad-hoc regex so behaviour stays consistent.
+ */
+export interface GeometryTypeInfo {
+    /** True if the type is some form of GEOMETRY (with or without CRS). */
+    isGeometry: boolean;
+    /** True if the type carries a CRS parameter, e.g. GEOMETRY('EPSG:4326'). */
+    hasCrs: boolean;
+    /** The CRS string if present, otherwise null. Raw value, including WGS84. */
+    rawCrs: string | null;
+    /**
+     * The CRS string if present and NOT a WGS84 variant (EPSG:4326, EPSG:4979,
+     * OGC:CRS84). Returns null for WGS84 so callers can skip ST_Transform.
+     */
+    nonWgs84Crs: string | null;
+}
+/**
+ * Parse a DuckDB type string and report whether it is a GEOMETRY type, and
+ * whether a CRS parameter is attached.
+ */
+export declare function parseGeometryTypeCrs(typeStr: string | null | undefined): GeometryTypeInfo;
+/** True for EPSG:4326, EPSG:4979, OGC:CRS84 and equivalent strings. */
+export declare function isWgs84Crs(crs: string | null | undefined): boolean;
+/**
+ * Build a `ST_Transform(...)` SQL expression choosing the 2-arg form when the
+ * input already carries its CRS in the GEOMETRY type (DuckDB v1.5), and the
+ * 3-arg form otherwise.
+ *
+ * `geometry_always_xy` is set globally at DB init, so no per-call `always_xy`
+ * argument is needed.
+ */
+export declare function buildTransformExpr(innerExpr: string, sourceType: string, sourceCrs: string, targetCrs: string): string;
+/**
+ * Wrap a bare WKB expression with `ST_SetCRS(ST_GeomFromWKB(...))` so that the
+ * resulting GEOMETRY value carries a CRS through the rest of the pipeline.
+ * Used in the legacy GeoParquet fallback where we read the geometry column as
+ * BLOB but still know the source CRS from hyparquet metadata or the GeoParquet
+ * footer.
+ *
+ * If `sourceCrs` is null/empty, returns a plain `ST_GeomFromWKB(...)`.
+ */
+export declare function wrapWkbWithCrs(wkbExpr: string, sourceCrs: string | null | undefined): string;

package/dist/utils/geometry-type.js

@@ -0,0 +1,76 @@
+/**
+ * Helpers for parsing DuckDB v1.5 parameterized GEOMETRY type strings.
+ *
+ * DuckDB v1.5 made GEOMETRY a core type with an optional CRS parameter:
+ *   GEOMETRY                  — no CRS attached
+ *   GEOMETRY('EPSG:4326')     — EPSG form
+ *   GEOMETRY('OGC:CRS84')     — OGC form (canonical for GeoParquet 1.1+)
+ *   GEOMETRY('EPSG:27700')    — projected CRS
+ *
+ * Type strings may come from `DESCRIBE`, from the Arrow schema, or from a
+ * legacy code path that still reports `BLOB`. Use these helpers everywhere
+ * instead of ad-hoc regex so behaviour stays consistent.
+ */
+import { WGS84_CODES } from '../constants.js';
+const GEOMETRY_PREFIX = /^GEOMETRY(\s*\(\s*'?([^')]+)'?\s*\))?/i;
+/**
+ * Parse a DuckDB type string and report whether it is a GEOMETRY type, and
+ * whether a CRS parameter is attached.
+ */
+export function parseGeometryTypeCrs(typeStr) {
+    if (!typeStr)
+        return { isGeometry: false, hasCrs: false, rawCrs: null, nonWgs84Crs: null };
+    const match = typeStr.match(GEOMETRY_PREFIX);
+    if (!match)
+        return { isGeometry: false, hasCrs: false, rawCrs: null, nonWgs84Crs: null };
+    const rawCrs = match[2]?.trim() ?? null;
+    if (!rawCrs)
+        return { isGeometry: true, hasCrs: false, rawCrs: null, nonWgs84Crs: null };
+    return {
+        isGeometry: true,
+        hasCrs: true,
+        rawCrs,
+        nonWgs84Crs: isWgs84Crs(rawCrs) ? null : rawCrs
+    };
+}
+/** True for EPSG:4326, EPSG:4979, OGC:CRS84 and equivalent strings. */
+export function isWgs84Crs(crs) {
+    if (!crs)
+        return true;
+    const trimmed = crs.trim();
+    if (trimmed === 'OGC:CRS84' || trimmed === 'OGC:CRS83')
+        return true;
+    const epsgMatch = trimmed.match(/^EPSG:(\d+)$/i);
+    if (epsgMatch && WGS84_CODES.has(Number(epsgMatch[1])))
+        return true;
+    return false;
+}
+/**
+ * Build a `ST_Transform(...)` SQL expression choosing the 2-arg form when the
+ * input already carries its CRS in the GEOMETRY type (DuckDB v1.5), and the
+ * 3-arg form otherwise.
+ *
+ * `geometry_always_xy` is set globally at DB init, so no per-call `always_xy`
+ * argument is needed.
+ */
+export function buildTransformExpr(innerExpr, sourceType, sourceCrs, targetCrs) {
+    const info = parseGeometryTypeCrs(sourceType);
+    if (info.hasCrs) {
+        return `ST_Transform(${innerExpr}, '${targetCrs}')`;
+    }
+    return `ST_Transform(${innerExpr}, '${sourceCrs}', '${targetCrs}')`;
+}
+/**
+ * Wrap a bare WKB expression with `ST_SetCRS(ST_GeomFromWKB(...))` so that the
+ * resulting GEOMETRY value carries a CRS through the rest of the pipeline.
+ * Used in the legacy GeoParquet fallback where we read the geometry column as
+ * BLOB but still know the source CRS from hyparquet metadata or the GeoParquet
+ * footer.
+ *
+ * If `sourceCrs` is null/empty, returns a plain `ST_GeomFromWKB(...)`.
+ */
+export function wrapWkbWithCrs(wkbExpr, sourceCrs) {
+    if (!sourceCrs)
+        return `ST_GeomFromWKB(${wkbExpr})`;
+    return `ST_SetCRS(ST_GeomFromWKB(${wkbExpr}), '${sourceCrs}')`;
+}

package/dist/utils/markdown-sql.d.ts

@@ -17,7 +17,7 @@ export interface ParsedMarkdownDocument {
  * SELECT * FROM table
  * ```
  */
-export declare function parseMarkdownDocument(markdown: string): ParsedMarkdownDocument;
+export declare function parseMarkdownDocument(markdown: string): Promise<ParsedMarkdownDocument>;
 /**
  * Interpolate template variables in markdown text.
  * Supports {queryName.rows[0].columnName} syntax.

package/dist/utils/markdown-sql.js

@@ -1,4 +1,3 @@
-import YAML from 'yaml';
 /**
  * Parse a markdown document with YAML frontmatter and SQL code blocks.
  *
@@ -7,17 +6,17 @@ import YAML from 'yaml';
  * SELECT * FROM table
  * ```
  */
-export function parseMarkdownDocument(markdown) {
+export async function parseMarkdownDocument(markdown) {
     let frontmatter = {};
     let content = markdown;
-    // Extract YAML frontmatter
     const fmMatch = markdown.match(/^---\n([\s\S]*?)\n---\n/);
     if (fmMatch) {
         try {
+            const { default: YAML } = await import('yaml');
             frontmatter = YAML.parse(fmMatch[1]) || {};
         }
         catch {
-            // Invalid YAML — ignore
+            // Invalid YAML or yaml peer dep not installed, ignore frontmatter
         }
         content = markdown.slice(fmMatch[0].length);
     }

package/dist/utils/pmtiles-tile.d.ts

@@ -30,8 +30,6 @@ export interface DecodedFeature {
  * Returns null if the tile does not exist or for raster archives.
  */
 export declare function decodeMvtTile(pmtiles: PMTiles, z: number, x: number, y: number): Promise<DecodedTile | null>;
-/** Convert tile bytes to a Blob URL for raster tile preview. */
-export declare function tileToImageUrl(pmtiles: PMTiles, z: number, x: number, y: number, mimeType: string): Promise<string | null>;
 /** MIME type for a PMTiles tile format string. */
 export declare function tileMimeType(format: string): string;
 /** Compute the hue for layer index i (same palette as buildPmtilesLayers). */

package/dist/utils/pmtiles-tile.js

@@ -41,14 +41,6 @@ export async function decodeMvtTile(pmtiles, z, x, y) {
     }
     return { z, x, y, layers, rawSize };
 }
-/** Convert tile bytes to a Blob URL for raster tile preview. */
-export async function tileToImageUrl(pmtiles, z, x, y, mimeType) {
-    const resp = await pmtiles.getZxy(z, x, y);
-    if (!resp)
-        return null;
-    const blob = new Blob([resp.data], { type: mimeType });
-    return URL.createObjectURL(blob);
-}
 /** MIME type for a PMTiles tile format string. */
 export function tileMimeType(format) {
     const map = {

package/dist/utils/url-state.d.ts

@@ -34,6 +34,12 @@ export declare function getUrlView(): string;
  * Read the prefix (file/folder path) from the ?url= param.
  */
 export declare function getUrlPrefix(): string;
+/**
+ * True when a `?url=` param is present. Single source of truth, used by
+ * the tab-sync effect and Sidebar auto-detection to decide whether an
+ * auto-migration is in progress (see `+page.svelte` tab-sync effect).
+ */
+export declare function hasUrlParam(): boolean;
 /**
  * Clear all URL state params.
  */

package/dist/utils/url-state.js

@@ -28,43 +28,43 @@ export function buildUrlParam(conn, prefix) {
     return `${base}/${prefix.replace(/^\//, '')}`;
 }
 /**
- * Set the ?url= param to a raw URL string (for direct URL tabs).
+ * Apply a URL mutation, skipping `replaceState` if nothing changed.
+ * Every public mutator below funnels through this to avoid `replaceState`
+ * thrash when the tab-sync effect re-fires on unrelated reactive changes.
  */
-export function setRawUrlParam(rawUrl) {
+function writeLocation(mutate) {
     try {
         const url = new URL(window.location.href);
-        url.searchParams.set('url', rawUrl);
-        replaceState(url.pathname + url.search + url.hash, {});
+        const before = url.pathname + url.search + url.hash;
+        mutate(url);
+        const after = url.pathname + url.search + url.hash;
+        if (before === after)
+            return;
+        replaceState(after, {});
     }
     catch {
         /* ignore */
     }
 }
+/**
+ * Set the ?url= param to a raw URL string (for direct URL tabs).
+ */
+export function setRawUrlParam(rawUrl) {
+    writeLocation((url) => url.searchParams.set('url', rawUrl));
+}
 /**
  * Sync the ?url= param in the browser URL.
  */
 export function syncUrlParam(conn, prefix) {
-    try {
-        const url = new URL(window.location.href);
-        url.searchParams.set('url', buildUrlParam(conn, prefix));
-        replaceState(url.pathname + url.search + url.hash, {});
-    }
-    catch {
-        /* ignore */
-    }
+    writeLocation((url) => url.searchParams.set('url', buildUrlParam(conn, prefix)));
 }
 /**
  * Update the #hash in the URL to reflect the current view mode.
  */
 export function updateUrlView(view) {
-    try {
-        const url = new URL(window.location.href);
+    writeLocation((url) => {
         url.hash = view || '';
-        replaceState(url.pathname + url.search + url.hash, {});
-    }
-    catch {
-        /* ignore */
-    }
+    });
 }
 /**
  * Read the current #hash view mode from the URL.
@@ -93,16 +93,24 @@ export function getUrlPrefix() {
     }
 }
 /**
- * Clear all URL state params.
+ * True when a `?url=` param is present. Single source of truth, used by
+ * the tab-sync effect and Sidebar auto-detection to decide whether an
+ * auto-migration is in progress (see `+page.svelte` tab-sync effect).
  */
-export function clearUrlState() {
+export function hasUrlParam() {
     try {
-        const url = new URL(window.location.href);
-        url.searchParams.delete('url');
-        url.hash = '';
-        replaceState(url.pathname + url.search, {});
+        return new URL(window.location.href).searchParams.has('url');
     }
     catch {
-        /* ignore */
+        return false;
     }
 }
+/**
+ * Clear all URL state params.
+ */
+export function clearUrlState() {
+    writeLocation((url) => {
+        url.searchParams.delete('url');
+        url.hash = '';
+    });
+}

package/dist/utils/url.d.ts

@@ -4,22 +4,39 @@ import type { Tab } from '../types.js';
  * Works for any viewer that needs an HTTP-accessible URL (COG, PMTiles, Zarr, etc.)
  */
 export declare function buildHttpsUrl(tab: Tab): string;
+/**
+ * Async counterpart of `buildHttpsUrl`. For `signed-s3` connections, returns a
+ * presigned HTTPS URL (SigV4 query-string auth). For public or SAS connections
+ * it returns the same URL as the sync version.
+ */
+export declare function buildHttpsUrlAsync(tab: Tab, expiresIn?: number): Promise<string>;
 /**
  * Build a provider-native protocol URL (s3://bucket/path, sj://bucket/path, etc.).
  */
 export declare function buildStorageUrl(tab: Tab): string;
 /**
- * Build the URL that DuckDB should use for queries.
- * - Azure: always HTTPS URL with SAS token appended
- * - Anonymous with custom endpoint (Storj, R2, etc.): HTTPS URL — no S3 config needed,
- *   avoids endpoint/auth complexity, works directly via httpfs
- * - AWS S3 (no endpoint): s3:// — DuckDB routes via configured region
- * - Authenticated with endpoint: s3:// — needs S3 endpoint config for SigV4 signing
+ * Build the URL DuckDB should query. Derived from the connection's access mode:
+ *
+ * | Access mode     | DuckDB URL                        | Why                                       |
+ * |-----------------|-----------------------------------|-------------------------------------------|
+ * | `sas-https`     | HTTPS with SAS token              | No DuckDB Azure support; SAS in URL works |
+ * | `public-https`  | HTTPS (no auth)                   | httpfs fetches directly, no signing needed|
+ * | `signed-s3`     | `s3://bucket/key`                 | DuckDB signs with configured S3 settings  |
+ *
+ * Path is percent-decoded so DuckDB's httpfs doesn't double-encode
+ * (e.g. Arabic filenames `%D9%85` → `%25D9%2585`).
  */
 export declare function buildDuckDbUrl(tab: Tab): string;
 /**
- * Check if a tab's file can be loaded directly via HTTPS URL (streaming).
- * True for URL-sourced tabs, anonymous buckets, and Azure (SAS token in URL).
- * False for authenticated S3 (needs signed URLs or blob download via adapter).
+ * Async counterpart of `buildDuckDbUrl`. Returns a presigned HTTPS URL for
+ * `signed-s3` connections so DuckDB httpfs can fetch with `Range` only, no
+ * `Authorization` preflight (which breaks on GCS's S3-compat endpoint when
+ * the bucket CORS `responseHeader` list desyncs from the browser's request).
+ */
+export declare function buildDuckDbUrlAsync(tab: Tab, expiresIn?: number): Promise<string>;
+/**
+ * True when any HTTP client (fetch/img/video/deck.gl/COG/Zarr/PMTiles) can
+ * load the tab's file directly via its HTTPS URL. False when SigV4 signing
+ * is required and the viewer must go through the storage adapter instead.
  */
 export declare function canStreamDirectly(tab: Tab): boolean;

package/dist/utils/url.js

@@ -1,4 +1,5 @@
-import { buildProviderBaseUrl } from '../storage/providers.js';
+import { presignHttpsUrl } from '../storage/presign.js';
+import { buildProviderBaseUrl, isPubliclyStreamable } from '../storage/providers.js';
 import { connections } from '../stores/connections.svelte.js';
 import { credentialStore } from '../stores/credentials.svelte.js';
 import { getNativeScheme, safeDecodeURIComponent } from './cloud-url.js';
@@ -20,6 +21,15 @@ export function buildHttpsUrl(tab) {
     }
     return `${buildProviderBaseUrl(conn.provider, conn.endpoint, conn.bucket, conn.region)}/${cleanPath}`;
 }
+/**
+ * Async counterpart of `buildHttpsUrl`. For `signed-s3` connections, returns a
+ * presigned HTTPS URL (SigV4 query-string auth). For public or SAS connections
+ * it returns the same URL as the sync version.
+ */
+export async function buildHttpsUrlAsync(tab, expiresIn) {
+    const presigned = await tryPresignTab(tab, expiresIn);
+    return presigned ?? buildHttpsUrl(tab);
+}
 /**
  * Build a provider-native protocol URL (s3://bucket/path, sj://bucket/path, etc.).
  */
@@ -31,37 +41,58 @@ export function buildStorageUrl(tab) {
     return `${scheme}://${conn.bucket}/${tab.path.replace(/^\//, '')}`;
 }
 /**
- * Build the URL that DuckDB should use for queries.
- * - Azure: always HTTPS URL with SAS token appended
- * - Anonymous with custom endpoint (Storj, R2, etc.): HTTPS URL — no S3 config needed,
- *   avoids endpoint/auth complexity, works directly via httpfs
- * - AWS S3 (no endpoint): s3:// — DuckDB routes via configured region
- * - Authenticated with endpoint: s3:// — needs S3 endpoint config for SigV4 signing
+ * Build the URL DuckDB should query. Derived from the connection's access mode:
+ *
+ * | Access mode     | DuckDB URL                        | Why                                       |
+ * |-----------------|-----------------------------------|-------------------------------------------|
+ * | `sas-https`     | HTTPS with SAS token              | No DuckDB Azure support; SAS in URL works |
+ * | `public-https`  | HTTPS (no auth)                   | httpfs fetches directly, no signing needed|
+ * | `signed-s3`     | `s3://bucket/key`                 | DuckDB signs with configured S3 settings  |
+ *
+ * Path is percent-decoded so DuckDB's httpfs doesn't double-encode
+ * (e.g. Arabic filenames `%D9%85` → `%25D9%2585`).
  */
 export function buildDuckDbUrl(tab) {
     const conn = tab.connectionId ? connections.getById(tab.connectionId) : null;
     if (!conn)
         return tab.path;
-    // Azure always uses HTTPS (DuckDB doesn't have native Azure Blob support)
-    if (conn.provider === 'azure') {
+    if (isPubliclyStreamable(conn))
         return buildHttpsUrl(tab);
-    }
-    // Anonymous connections with custom endpoints (Storj, R2, Wasabi, etc.)
-    // use HTTPS directly — simpler and avoids S3 endpoint configuration.
-    if (conn.anonymous && conn.endpoint) {
-        return buildHttpsUrl(tab);
-    }
-    // S3-compatible with credentials: use s3:// protocol so DuckDB uses its
-    // configured S3 settings (region, endpoint, url_style) for SigV4 signing.
     // Decode percent-encoded paths (e.g. Arabic filenames) so DuckDB's httpfs
     // doesn't double-encode them (%D9%85 → %25D9%2585).
     const rawPath = safeDecodeURIComponent(tab.path.replace(/^\//, ''));
     return `s3://${conn.bucket}/${rawPath}`;
 }
 /**
- * Check if a tab's file can be loaded directly via HTTPS URL (streaming).
- * True for URL-sourced tabs, anonymous buckets, and Azure (SAS token in URL).
- * False for authenticated S3 (needs signed URLs or blob download via adapter).
+ * Async counterpart of `buildDuckDbUrl`. Returns a presigned HTTPS URL for
+ * `signed-s3` connections so DuckDB httpfs can fetch with `Range` only, no
+ * `Authorization` preflight (which breaks on GCS's S3-compat endpoint when
+ * the bucket CORS `responseHeader` list desyncs from the browser's request).
+ */
+export async function buildDuckDbUrlAsync(tab, expiresIn) {
+    const presigned = await tryPresignTab(tab, expiresIn);
+    return presigned ?? buildDuckDbUrl(tab);
+}
+/** Presign the tab's HTTPS URL for `signed-s3` connections; null otherwise. */
+async function tryPresignTab(tab, expiresIn) {
+    const conn = tab.connectionId ? connections.getById(tab.connectionId) : null;
+    if (!conn || isPubliclyStreamable(conn))
+        return null;
+    try {
+        return await presignHttpsUrl(conn, tab.path, expiresIn);
+    }
+    catch (err) {
+        // Silent fallback would route the caller back to `s3://...` + SigV4
+        // header signing — exactly the CORS preflight path presigning was added
+        // to avoid. Surface the failure so it is debuggable.
+        console.warn('[presign] falling back to signed-s3 path:', err);
+        return null;
+    }
+}
+/**
+ * True when any HTTP client (fetch/img/video/deck.gl/COG/Zarr/PMTiles) can
+ * load the tab's file directly via its HTTPS URL. False when SigV4 signing
+ * is required and the viewer must go through the storage adapter instead.
  */
 export function canStreamDirectly(tab) {
     if (tab.source === 'url')
@@ -69,11 +100,7 @@ export function canStreamDirectly(tab) {
     const conn = tab.connectionId ? connections.getById(tab.connectionId) : null;
     if (!conn)
         return true;
-    if (conn.anonymous)
-        return true;
-    if (conn.provider === 'azure')
-        return true;
-    return false;
+    return isPubliclyStreamable(conn);
 }
 /**
  * Append Azure SAS token to a URL if available.

package/dist/utils/wkb.js

@@ -190,8 +190,22 @@ const GEO_TYPE_KEYWORDS = [
     'geometrycollection',
     'sdo_geometry'
 ];
-/** Substrings in column names that hint at geometry content. */
-const GEO_NAME_HINTS = ['geom', 'geometry', 'geo_', '_geo', 'wkb', 'wkt', 'shape', 'spatial'];
+/**
+ * Tokens in column names that hint at geometry content. Matched against
+ * snake_case / kebab-case / camelCase tokens only — never as loose substrings
+ * (e.g. `_geographic_` must not match `geo` via the `_geo` substring, because
+ * count columns like `n_geographic_entities` are INT, not geometry).
+ */
+const GEO_NAME_HINTS = ['geom', 'geometry', 'wkb', 'wkt', 'shape', 'spatial', 'geo'];
+/** Split a column name into lowercase tokens for hint matching. */
+function tokenizeColumnName(name) {
+    return name
+        .replace(/([a-z])([A-Z])/g, '$1_$2')
+        .replace(/([a-z])([0-9])/g, '$1_$2')
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean);
+}
 /** Valid GeoJSON geometry type names. */
 const GEOJSON_TYPES = [
     'Point',
@@ -242,18 +256,18 @@ export function findGeoColumn(schema) {
         if (GEO_NAMES.includes(f.name.toLowerCase()))
             return f.name;
     }
-    // Priority 4: name contains geo hint with binary type
+    // Priority 4: name token matches geo hint with binary type
     for (const f of schema) {
-        const n = f.name.toLowerCase();
+        const tokens = tokenizeColumnName(f.name);
         const t = f.type.toLowerCase();
         const isBinary = t.includes('blob') || t.includes('binary') || t.includes('bytea');
-        if (isBinary && GEO_NAME_HINTS.some((hint) => n.includes(hint)))
+        if (isBinary && tokens.some((tok) => GEO_NAME_HINTS.includes(tok)))
             return f.name;
     }
-    // Priority 5: name contains geo hint, any type
+    // Priority 5: name token matches geo hint, any type
     for (const f of schema) {
-        const n = f.name.toLowerCase();
-        if (GEO_NAME_HINTS.some((hint) => n.includes(hint)))
+        const tokens = tokenizeColumnName(f.name);
+        if (tokens.some((tok) => GEO_NAME_HINTS.includes(tok)))
             return f.name;
     }
     return null;

package/dist/utils/zarr-tab.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Zarr tab-opening helper.
+ * Centralizes Zarr store tab creation to avoid duplicating the same logic
+ * across FileBrowser, FileRow, FileTreeSidebar, and +page.svelte.
+ *
+ * Kept separate from zarr.ts to avoid adding a store dependency to a pure utility.
+ */
+interface ZarrTabContext {
+    /** 'remote' for object-storage connections, 'url' for direct URL tabs. */
+    source: 'remote' | 'url';
+    /** Connection ID — required for remote sources. */
+    connectionId?: string;
+    /** Fallback name when the path has no meaningful last segment (e.g. bucket root). */
+    bucketFallback?: string;
+}
+/**
+ * Open a directory path as a Zarr store tab.
+ * Normalizes the path, derives a display name, and deduplicates via a
+ * deterministic tab ID so calling this twice with the same path is a no-op.
+ */
+export declare function openZarrTab(dirPath: string, ctx: ZarrTabContext): void;
+export {};

package/dist/utils/zarr-tab.js

@@ -0,0 +1,30 @@
+/**
+ * Zarr tab-opening helper.
+ * Centralizes Zarr store tab creation to avoid duplicating the same logic
+ * across FileBrowser, FileRow, FileTreeSidebar, and +page.svelte.
+ *
+ * Kept separate from zarr.ts to avoid adding a store dependency to a pure utility.
+ */
+import { tabs } from '../stores/tabs.svelte.js';
+/**
+ * Open a directory path as a Zarr store tab.
+ * Normalizes the path, derives a display name, and deduplicates via a
+ * deterministic tab ID so calling this twice with the same path is a no-op.
+ */
+export function openZarrTab(dirPath, ctx) {
+    const path = ctx.source === 'remote'
+        ? dirPath.endsWith('/')
+            ? dirPath
+            : `${dirPath}/`
+        : dirPath.replace(/\/+$/, '');
+    const name = path.replace(/\/+$/, '').split('/').pop()?.split('?')[0] || ctx.bucketFallback || 'zarr';
+    const id = ctx.connectionId ? `${ctx.connectionId}:${path}` : `url:${path}`;
+    tabs.open({
+        id,
+        name,
+        path,
+        source: ctx.source,
+        ...(ctx.connectionId ? { connectionId: ctx.connectionId } : {}),
+        extension: 'zarr'
+    });
+}

package/dist/utils/zarr.d.ts

@@ -62,8 +62,6 @@ export declare function computeUncompressed(shape: number[] | undefined, dtype:
 export declare function formatCodecs(node: ZarrNode): string | null;
 /** Format chunk_key_encoding for display: `"default (sep: "/")"` */
 export declare function formatChunkKeys(node: ZarrNode): string | null;
-/** Find a node by slash-delimited path. */
-export declare function findNodeByPath(root: ZarrNode, path: string): ZarrNode | null;
 /** Build tree from Zarr v3 consolidated metadata (zarr.json). */
 export declare function buildV3Tree(data: any): ZarrHierarchy;
 /** Build tree from Zarr v2 consolidated metadata (.zmetadata). */