@walkthru-earth/objex 0.1.0

package/dist/utils/url-state.js

@@ -0,0 +1,113 @@
+/**
+ * URL state management for shareable links.
+ *
+ * URL format: ?url=<storage-url>[#table|map|query|inspect]
+ *
+ * - ?url=  : full storage URL (endpoint + bucket + object path)
+ *   e.g. https://s3.us-east-1.amazonaws.com/my-bucket/path/file.parquet
+ * - #hash  : viewer mode (table, map, query, inspect)
+ *
+ * Uses SvelteKit's replaceState to avoid conflicts with the router.
+ */
+import { replaceState } from '$app/navigation';
+import { parseStorageUrl } from './storage-url.js';
+/**
+ * Build the base HTTPS URL for a connection (endpoint + bucket).
+ */
+function buildBaseUrl(conn) {
+    if (conn.endpoint) {
+        return `${conn.endpoint.replace(/\/$/, '')}/${conn.bucket}`;
+    }
+    if (conn.provider === 'gcs') {
+        return `https://storage.googleapis.com/${conn.bucket}`;
+    }
+    return `https://s3.${conn.region || 'us-east-1'}.amazonaws.com/${conn.bucket}`;
+}
+/**
+ * Build a full storage URL from a Connection + optional object prefix.
+ */
+export function buildUrlParam(conn, prefix) {
+    const base = buildBaseUrl(conn);
+    if (!prefix)
+        return base;
+    return `${base}/${prefix.replace(/^\//, '')}`;
+}
+/**
+ * Set the ?url= param to a raw URL string (for direct URL tabs).
+ */
+export function setRawUrlParam(rawUrl) {
+    try {
+        const url = new URL(window.location.href);
+        url.searchParams.set('url', rawUrl);
+        replaceState(url.pathname + url.search + url.hash, {});
+    }
+    catch {
+        /* ignore */
+    }
+}
+/**
+ * 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 */
+    }
+}
+/**
+ * Update the #hash in the URL to reflect the current view mode.
+ */
+export function updateUrlView(view) {
+    try {
+        const url = new URL(window.location.href);
+        url.hash = view || '';
+        replaceState(url.pathname + url.search + url.hash, {});
+    }
+    catch {
+        /* ignore */
+    }
+}
+/**
+ * Read the current #hash view mode from the URL.
+ */
+export function getUrlView() {
+    try {
+        return window.location.hash.replace('#', '');
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Read the prefix (file/folder path) from the ?url= param.
+ */
+export function getUrlPrefix() {
+    try {
+        const url = new URL(window.location.href);
+        const urlParam = url.searchParams.get('url');
+        if (!urlParam)
+            return '';
+        return parseStorageUrl(urlParam).prefix;
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Clear all URL state params.
+ */
+export function clearUrlState() {
+    try {
+        const url = new URL(window.location.href);
+        url.searchParams.delete('url');
+        url.hash = '';
+        replaceState(url.pathname + url.search, {});
+    }
+    catch {
+        /* ignore */
+    }
+}

package/dist/utils/url.d.ts

@@ -0,0 +1,27 @@
+import type { Tab } from '../types.js';
+/**
+ * Build an HTTPS URL for a tab's file.
+ * Works for any viewer that needs an HTTP-accessible URL (COG, PMTiles, Zarr, etc.)
+ */
+export declare function buildHttpsUrl(tab: Tab): string;
+/** Map provider to its native URI scheme prefix. */
+export declare function getNativeScheme(provider: string): 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
+ */
+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).
+ */
+export declare function canStreamDirectly(tab: Tab): boolean;

package/dist/utils/url.js

@@ -0,0 +1,115 @@
+import { connections } from '../stores/connections.svelte.js';
+import { credentialStore } from '../stores/credentials.svelte.js';
+/**
+ * Build an HTTPS URL for a tab's file.
+ * Works for any viewer that needs an HTTP-accessible URL (COG, PMTiles, Zarr, etc.)
+ */
+export function buildHttpsUrl(tab) {
+    const conn = tab.connectionId ? connections.getById(tab.connectionId) : null;
+    if (!conn)
+        return tab.path;
+    const cleanPath = tab.path.replace(/^\//, '');
+    // Azure: <endpoint>/<container>/<blob>, append SAS if available
+    if (conn.provider === 'azure') {
+        const base = conn.endpoint
+            ? `${conn.endpoint.replace(/\/$/, '')}/${conn.bucket}/${cleanPath}`
+            : `https://${conn.bucket}.blob.core.windows.net/${cleanPath}`;
+        return appendAzureSas(base, conn.id);
+    }
+    if (conn.endpoint) {
+        return `${conn.endpoint.replace(/\/$/, '')}/${conn.bucket}/${cleanPath}`;
+    }
+    return `https://s3.${conn.region || 'us-east-1'}.amazonaws.com/${conn.bucket}/${cleanPath}`;
+}
+/** Map provider to its native URI scheme prefix. */
+export function getNativeScheme(provider) {
+    switch (provider) {
+        case 'gcs':
+            return 'gs';
+        case 'azure':
+            return 'az';
+        case 'r2':
+            return 'r2';
+        case 'storj':
+            return 'sj';
+        case 'minio':
+            return 's3';
+        default:
+            return 's3';
+    }
+}
+/**
+ * Build a provider-native protocol URL (s3://bucket/path, sj://bucket/path, etc.).
+ */
+export function buildStorageUrl(tab) {
+    const conn = tab.connectionId ? connections.getById(tab.connectionId) : null;
+    if (!conn)
+        return tab.path;
+    const scheme = getNativeScheme(conn.provider);
+    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
+ */
+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') {
+        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}`;
+}
+function safeDecodeURIComponent(s) {
+    try {
+        return decodeURIComponent(s);
+    }
+    catch {
+        return s;
+    }
+}
+/**
+ * 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).
+ */
+export function canStreamDirectly(tab) {
+    if (tab.source === 'url')
+        return true;
+    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;
+}
+/**
+ * Append Azure SAS token to a URL if available.
+ */
+function appendAzureSas(url, connectionId) {
+    const creds = credentialStore.get(connectionId);
+    if (!creds || creds.type !== 'sas-token')
+        return url;
+    const token = creds.sasToken;
+    const cleanToken = token.startsWith('?') ? token.slice(1) : token;
+    const sep = url.includes('?') ? '&' : '?';
+    return `${url}${sep}${cleanToken}`;
+}

package/dist/utils/wkb.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Lightweight WKB (Well-Known Binary) parser for extracting coordinates.
+ * Supports Point, LineString, Polygon, and Multi* variants.
+ * Handles standard WKB, ISO WKB (with Z/M), and EWKB (PostGIS SRID).
+ */
+export type GeoType = 'Point' | 'LineString' | 'Polygon' | 'MultiPoint' | 'MultiLineString' | 'MultiPolygon' | 'Unknown';
+export interface ParsedGeometry {
+    type: GeoType;
+    coordinates: number[] | number[][] | number[][][] | number[][][][];
+}
+/**
+ * Normalize binary data from various formats to Uint8Array.
+ * Handles Uint8Array, ArrayBuffer, number arrays, hex strings,
+ * and DuckDB toJSON() blob objects ({0: byte, 1: byte, ...}).
+ */
+export declare function toBinary(value: unknown): Uint8Array | null;
+/**
+ * Parse a WKB binary blob into coordinates and geometry type.
+ */
+export declare function parseWKB(data: Uint8Array): ParsedGeometry | null;
+/**
+ * Find the geometry column name from a schema.
+ *
+ * Detection priority:
+ * 1. Column type contains a geometry keyword (GEOMETRY, POINT, WKB, etc.)
+ * 2. Exact well-known column name with BLOB/BINARY type
+ * 3. Exact well-known column name regardless of type
+ * 4. Column name contains a geo-related substring with BLOB/BINARY type
+ * 5. Column name contains a geo-related substring regardless of type
+ */
+export declare function findGeoColumn(schema: {
+    name: string;
+    type: string;
+}[]): string | null;
+/**
+ * Fallback: probe actual row data to find a column containing WKB geometry.
+ * Use this when schema-only detection via `findGeoColumn()` returns null.
+ * Samples the first row and checks each BLOB/binary column for WKB magic bytes.
+ */
+export declare function findGeoColumnFromRows(rows: Record<string, unknown>[], schema: {
+    name: string;
+    type: string;
+}[]): string | null;

package/dist/utils/wkb.js

@@ -0,0 +1,345 @@
+/**
+ * Lightweight WKB (Well-Known Binary) parser for extracting coordinates.
+ * Supports Point, LineString, Polygon, and Multi* variants.
+ * Handles standard WKB, ISO WKB (with Z/M), and EWKB (PostGIS SRID).
+ */
+// WKB type codes
+const WKB_POINT = 1;
+const WKB_LINESTRING = 2;
+const WKB_POLYGON = 3;
+const WKB_MULTIPOINT = 4;
+const WKB_MULTILINESTRING = 5;
+const WKB_MULTIPOLYGON = 6;
+// EWKB flags
+const EWKB_Z_FLAG = 0x80000000;
+const EWKB_M_FLAG = 0x40000000;
+const EWKB_SRID_FLAG = 0x20000000;
+/**
+ * Normalize binary data from various formats to Uint8Array.
+ * Handles Uint8Array, ArrayBuffer, number arrays, hex strings,
+ * and DuckDB toJSON() blob objects ({0: byte, 1: byte, ...}).
+ */
+export function toBinary(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (value instanceof Uint8Array)
+        return value;
+    if (value instanceof ArrayBuffer)
+        return new Uint8Array(value);
+    if (Array.isArray(value) && value.length > 0 && typeof value[0] === 'number') {
+        return new Uint8Array(value);
+    }
+    if (typeof value === 'string' && /^[0-9a-fA-F]+$/.test(value) && value.length % 2 === 0) {
+        const bytes = new Uint8Array(value.length / 2);
+        for (let i = 0; i < value.length; i += 2) {
+            bytes[i / 2] = parseInt(value.substring(i, i + 2), 16);
+        }
+        return bytes;
+    }
+    // DuckDB toJSON() serializes BLOB/GEOMETRY as {"0": byte, "1": byte, ...}
+    if (typeof value === 'object' && !Array.isArray(value)) {
+        const obj = value;
+        const keys = Object.keys(obj);
+        if (keys.length > 4 && typeof obj['0'] === 'number') {
+            const arr = new Uint8Array(keys.length);
+            for (let i = 0; i < keys.length; i++)
+                arr[i] = obj[i];
+            return arr;
+        }
+    }
+    return null;
+}
+/**
+ * Parse a WKB binary blob into coordinates and geometry type.
+ */
+export function parseWKB(data) {
+    if (data.length < 5)
+        return null;
+    try {
+        return readGeometry(new DataView(data.buffer, data.byteOffset, data.byteLength), 0).geometry;
+    }
+    catch {
+        return null;
+    }
+}
+function readGeometry(view, offset) {
+    const le = view.getUint8(offset) === 1;
+    offset += 1;
+    let typeInt = view.getUint32(offset, le);
+    offset += 4;
+    // Detect coordinate dimensions from EWKB flags or ISO type ranges
+    const hasZ = (typeInt & EWKB_Z_FLAG) !== 0 ||
+        (typeInt % 10000 >= 1000 && typeInt % 10000 < 2000) ||
+        (typeInt % 10000 >= 3000 && typeInt % 10000 < 4000);
+    const hasM = (typeInt & EWKB_M_FLAG) !== 0 ||
+        (typeInt % 10000 >= 2000 && typeInt % 10000 < 3000) ||
+        (typeInt % 10000 >= 3000 && typeInt % 10000 < 4000);
+    // Skip SRID if present (EWKB)
+    if (typeInt & EWKB_SRID_FLAG)
+        offset += 4;
+    // Strip all flags to get base geometry type
+    typeInt = (typeInt & 0x0000ffff) % 1000;
+    const extraDims = (hasZ ? 1 : 0) + (hasM ? 1 : 0);
+    const rd = (o) => view.getFloat64(o, le);
+    const ru = (o) => view.getUint32(o, le);
+    function readPoint(off) {
+        const x = rd(off);
+        const y = rd(off + 8);
+        return { coords: [x, y], offset: off + 16 + extraDims * 8 };
+    }
+    function readLineString(off) {
+        const n = ru(off);
+        off += 4;
+        const coords = [];
+        for (let i = 0; i < n; i++) {
+            const pt = readPoint(off);
+            coords.push(pt.coords);
+            off = pt.offset;
+        }
+        return { coords, offset: off };
+    }
+    function readPolygon(off) {
+        const n = ru(off);
+        off += 4;
+        const coords = [];
+        for (let i = 0; i < n; i++) {
+            const ring = readLineString(off);
+            coords.push(ring.coords);
+            off = ring.offset;
+        }
+        return { coords, offset: off };
+    }
+    switch (typeInt) {
+        case WKB_POINT: {
+            const pt = readPoint(offset);
+            return { geometry: { type: 'Point', coordinates: pt.coords }, offset: pt.offset };
+        }
+        case WKB_LINESTRING: {
+            const ls = readLineString(offset);
+            return { geometry: { type: 'LineString', coordinates: ls.coords }, offset: ls.offset };
+        }
+        case WKB_POLYGON: {
+            const pg = readPolygon(offset);
+            return { geometry: { type: 'Polygon', coordinates: pg.coords }, offset: pg.offset };
+        }
+        case WKB_MULTIPOINT: {
+            const n = ru(offset);
+            offset += 4;
+            const coords = [];
+            for (let i = 0; i < n; i++) {
+                const r = readGeometry(view, offset);
+                coords.push(r.geometry.coordinates);
+                offset = r.offset;
+            }
+            return { geometry: { type: 'MultiPoint', coordinates: coords }, offset };
+        }
+        case WKB_MULTILINESTRING: {
+            const n = ru(offset);
+            offset += 4;
+            const coords = [];
+            for (let i = 0; i < n; i++) {
+                const r = readGeometry(view, offset);
+                coords.push(r.geometry.coordinates);
+                offset = r.offset;
+            }
+            return { geometry: { type: 'MultiLineString', coordinates: coords }, offset };
+        }
+        case WKB_MULTIPOLYGON: {
+            const n = ru(offset);
+            offset += 4;
+            const coords = [];
+            for (let i = 0; i < n; i++) {
+                const r = readGeometry(view, offset);
+                coords.push(r.geometry.coordinates);
+                offset = r.offset;
+            }
+            return { geometry: { type: 'MultiPolygon', coordinates: coords }, offset };
+        }
+        default:
+            return { geometry: { type: 'Unknown', coordinates: [] }, offset };
+    }
+}
+// ---------------------------------------------------------------------------
+// Geometry column detection
+// ---------------------------------------------------------------------------
+/** Exact well-known geometry column names (lowercase for comparison). */
+const GEO_NAMES = [
+    'geometry',
+    'geom',
+    'wkb_geometry',
+    'the_geom',
+    'shape',
+    'geo',
+    'wkt_geometry',
+    'the_geog',
+    'geog',
+    'way',
+    'ora_geometry'
+];
+/** Type keywords that indicate a geometry column. */
+const GEO_TYPE_KEYWORDS = [
+    'geometry',
+    'geography',
+    'wkb',
+    'point',
+    'linestring',
+    'polygon',
+    'multipoint',
+    'multilinestring',
+    'multipolygon',
+    'geometrycollection',
+    'sdo_geometry'
+];
+/** Substrings in column names that hint at geometry content. */
+const GEO_NAME_HINTS = ['geom', 'geometry', 'geo_', '_geo', 'wkb', 'wkt', 'shape', 'spatial'];
+/** Valid GeoJSON geometry type names. */
+const GEOJSON_TYPES = [
+    'Point',
+    'LineString',
+    'Polygon',
+    'MultiPoint',
+    'MultiLineString',
+    'MultiPolygon'
+];
+/** Check if a value is a GeoJSON geometry object ({type, coordinates}). */
+function isGeoJSONGeometry(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const obj = value;
+    return (typeof obj.type === 'string' && GEOJSON_TYPES.includes(obj.type) && obj.coordinates != null);
+}
+/**
+ * Find the geometry column name from a schema.
+ *
+ * Detection priority:
+ * 1. Column type contains a geometry keyword (GEOMETRY, POINT, WKB, etc.)
+ * 2. Exact well-known column name with BLOB/BINARY type
+ * 3. Exact well-known column name regardless of type
+ * 4. Column name contains a geo-related substring with BLOB/BINARY type
+ * 5. Column name contains a geo-related substring regardless of type
+ */
+export function findGeoColumn(schema) {
+    // Priority 1: column type contains a geometry keyword
+    // Skip STRUCT/MAP/LIST types — their field names can false-positive
+    // (e.g. STRUCT(... Geometry VARCHAR ...) matches 'geometry')
+    for (const f of schema) {
+        const t = f.type.toLowerCase();
+        if (t.startsWith('struct') || t.startsWith('map') || t.startsWith('list'))
+            continue;
+        if (GEO_TYPE_KEYWORDS.some((kw) => t.includes(kw)))
+            return f.name;
+    }
+    // Priority 2: exact well-known name with binary type
+    for (const f of schema) {
+        const n = f.name.toLowerCase();
+        const t = f.type.toLowerCase();
+        const isBinary = t.includes('blob') || t.includes('binary') || t.includes('bytea');
+        if (GEO_NAMES.includes(n) && isBinary)
+            return f.name;
+    }
+    // Priority 3: exact well-known name, any type
+    for (const f of schema) {
+        if (GEO_NAMES.includes(f.name.toLowerCase()))
+            return f.name;
+    }
+    // Priority 4: name contains geo hint with binary type
+    for (const f of schema) {
+        const n = f.name.toLowerCase();
+        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)))
+            return f.name;
+    }
+    // Priority 5: name contains geo hint, any type
+    for (const f of schema) {
+        const n = f.name.toLowerCase();
+        if (GEO_NAME_HINTS.some((hint) => n.includes(hint)))
+            return f.name;
+    }
+    return null;
+}
+/**
+ * Check if a value looks like valid WKB by inspecting its first bytes.
+ * WKB starts with a byte-order marker (0x00 big-endian, 0x01 little-endian)
+ * followed by a uint32 geometry type code.
+ */
+function looksLikeWKB(value) {
+    const bytes = toBinary(value);
+    if (!bytes || bytes.length < 5)
+        return false;
+    const bom = bytes[0];
+    if (bom !== 0x00 && bom !== 0x01)
+        return false;
+    const le = bom === 0x01;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let typeInt = view.getUint32(1, le);
+    // Strip EWKB flags
+    typeInt = (typeInt & 0x0000ffff) % 1000;
+    // Valid base geometry types are 1–7
+    return typeInt >= 1 && typeInt <= 7;
+}
+/**
+ * Fallback: probe actual row data to find a column containing WKB geometry.
+ * Use this when schema-only detection via `findGeoColumn()` returns null.
+ * Samples the first row and checks each BLOB/binary column for WKB magic bytes.
+ */
+export function findGeoColumnFromRows(rows, schema) {
+    if (rows.length === 0)
+        return null;
+    const sample = rows[0];
+    // First pass: check binary-typed columns
+    for (const f of schema) {
+        const t = f.type.toLowerCase();
+        const isBinary = t.includes('blob') || t.includes('binary') || t.includes('bytea');
+        if (isBinary && looksLikeWKB(sample[f.name]))
+            return f.name;
+    }
+    // Second pass: check any column that holds binary-like data or WKT strings
+    for (const [key, value] of Object.entries(sample)) {
+        if (value instanceof Uint8Array || value instanceof ArrayBuffer) {
+            if (looksLikeWKB(value))
+                return key;
+        }
+        if (typeof value === 'string') {
+            // Hex-encoded WKB
+            if (/^[0-9a-fA-F]+$/.test(value) && value.length >= 10 && looksLikeWKB(value)) {
+                return key;
+            }
+            // WKT string (from DuckDB spatial GEOMETRY type)
+            if (isWKT(value))
+                return key;
+        }
+        // GeoJSON geometry object (from DuckDB read_json_auto struct serialization)
+        if (isGeoJSONGeometry(value))
+            return key;
+        // GeoJSON JSON string (from DuckDB to_json()::VARCHAR)
+        if (typeof value === 'string' && value.startsWith('{')) {
+            try {
+                if (isGeoJSONGeometry(JSON.parse(value)))
+                    return key;
+            }
+            catch {
+                // not JSON
+            }
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// WKT detection (used by findGeoColumnFromRows for column sniffing)
+// ---------------------------------------------------------------------------
+const WKT_TYPES = [
+    'POINT',
+    'LINESTRING',
+    'POLYGON',
+    'MULTIPOINT',
+    'MULTILINESTRING',
+    'MULTIPOLYGON'
+];
+/** Check if a string looks like WKT. */
+function isWKT(value) {
+    if (typeof value !== 'string')
+        return false;
+    const s = value.trimStart().toUpperCase();
+    return WKT_TYPES.some((t) => s.startsWith(t) || s.startsWith(`MULTI${t}`));
+}

package/dist/utils/zarr.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Zarr metadata parsing utilities.
+ *
+ * Handles consolidated metadata for both Zarr v2 (.zmetadata) and v3 (zarr.json),
+ * plus a zarrita fallback for non-consolidated stores.
+ */
+export interface VarMeta {
+    name: string;
+    shape: number[];
+    dtype: string;
+    dims: string[];
+    chunks: number[];
+    attributes: Record<string, any>;
+}
+export interface ZarrMetadata {
+    storeAttrs: Record<string, any>;
+    variables: VarMeta[];
+    coords: VarMeta[];
+    spatialRefAttrs: Record<string, any> | null;
+    zarrVersion: number | null;
+}
+/** Guess dimension names from shape length when metadata is absent. */
+export declare function inferDims(name: string, shape: number[]): string[];
+/** Format shape array for display: `[3 × 256 × 512]` or `scalar`. */
+export declare function formatShape(shape: number[]): string;
+/** Parse Zarr v3 consolidated metadata (zarr.json). */
+export declare function parseV3Consolidated(data: any): Omit<ZarrMetadata, 'zarrVersion'>;
+/** Parse Zarr v2 consolidated metadata (.zmetadata). */
+export declare function parseV2Consolidated(data: any): Omit<ZarrMetadata, 'zarrVersion'>;
+/**
+ * Fetch consolidated metadata from a Zarr store URL.
+ * Tries v3 (zarr.json) first, then v2 (.zmetadata).
+ */
+export declare function fetchConsolidated(storeUrl: string): Promise<ZarrMetadata | null>;
+/**
+ * Fallback: probe a Zarr store using zarrita when consolidated metadata is unavailable.
+ * @param storeName - Display name for the root array (e.g. file name without .zarr)
+ */
+export declare function probeWithZarrita(storeUrl: string, storeName: string): Promise<ZarrMetadata | null>;