@walkthru-earth/objex 0.1.0 → 1.1.0

package/dist/utils/notebook.js

@@ -0,0 +1,211 @@
+/**
+ * Lightweight browser-native Jupyter notebook renderer.
+ * Replaces `notebookjs` which depends on jsdom/Buffer (Node.js only).
+ * Handles nbformat 2, 3, 4, and 5.
+ */
+const PREFIX = 'nb-';
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function el(tag, classNames = []) {
+    const e = document.createElement(tag);
+    if (classNames.length)
+        e.className = classNames.map((c) => PREFIX + c).join(' ');
+    return e;
+}
+function escapeHTML(raw) {
+    return raw.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function joinText(text) {
+    if (Array.isArray(text))
+        return text.join('');
+    return text ?? '';
+}
+// ── Display renderers ────────────────────────────────────────────────────────
+const IMAGE_FORMATS = ['image/png', 'image/jpeg', 'image/gif', 'image/webp'];
+function renderImage(format, data) {
+    const img = el('img', ['image-output']);
+    img.src = `data:${format};base64,${joinText(data).replace(/\n/g, '')}`;
+    return img;
+}
+function renderDisplayData(output, config) {
+    // Resolve data from v4 `data` field or v3 flat fields
+    const getData = (mime) => output.data?.[mime] ?? output[mime];
+    // Priority order (richest first)
+    for (const fmt of IMAGE_FORMATS) {
+        const d = getData(fmt);
+        if (d)
+            return renderImage(fmt, d);
+    }
+    const svg = getData('image/svg+xml') ?? getData('text/svg+xml');
+    if (svg) {
+        const wrapper = el('div', ['svg-output']);
+        wrapper.innerHTML = joinText(svg);
+        return wrapper;
+    }
+    const html = getData('text/html');
+    if (html) {
+        const wrapper = el('div', ['html-output']);
+        wrapper.innerHTML = joinText(html);
+        return wrapper;
+    }
+    const md = getData('text/markdown');
+    if (md) {
+        const wrapper = el('div', ['html-output']);
+        wrapper.innerHTML = config.markdown(joinText(md));
+        return wrapper;
+    }
+    const latex = getData('text/latex');
+    if (latex) {
+        const wrapper = el('div', ['latex-output']);
+        wrapper.textContent = joinText(latex);
+        return wrapper;
+    }
+    const plain = getData('text/plain');
+    if (plain) {
+        const pre = el('pre', ['text-output']);
+        pre.innerHTML = config.ansi(escapeHTML(joinText(plain)));
+        return pre;
+    }
+    return el('div', ['empty-output']);
+}
+function renderStream(output, config) {
+    const streamName = output.stream ?? output.name ?? 'stdout';
+    const pre = el('pre', [streamName]);
+    pre.innerHTML = config.ansi(escapeHTML(joinText(output.text ?? '')));
+    return pre;
+}
+function renderError(output, config) {
+    const pre = el('pre', ['pyerr']);
+    const raw = (output.traceback ?? []).join('\n');
+    pre.innerHTML = config.ansi(escapeHTML(raw));
+    return pre;
+}
+// ── Output coalescing (merge consecutive same-name streams) ──────────────────
+function coalesceStreams(outputs) {
+    if (!outputs.length)
+        return outputs;
+    const result = [{ ...outputs[0] }];
+    for (let i = 1; i < outputs.length; i++) {
+        const o = outputs[i];
+        const last = result[result.length - 1];
+        if (o.output_type === 'stream' &&
+            last.output_type === 'stream' &&
+            (o.stream ?? o.name) === (last.stream ?? last.name)) {
+            // Merge text
+            const lastText = Array.isArray(last.text) ? last.text : [last.text ?? ''];
+            const oText = Array.isArray(o.text) ? o.text : [o.text ?? ''];
+            last.text = lastText.concat(oText);
+        }
+        else {
+            result.push({ ...o });
+        }
+    }
+    return result;
+}
+// ── Cell renderers ───────────────────────────────────────────────────────────
+function renderCodeCell(cell, lang, config) {
+    const cellEl = el('div', ['cell', 'code-cell']);
+    // Input
+    const source = joinText(cell.source ?? cell.input ?? '');
+    if (source) {
+        const holder = el('div', ['input']);
+        const num = cell.prompt_number ?? cell.execution_count;
+        if (typeof num === 'number' && num > -1) {
+            holder.setAttribute('data-prompt-number', String(num));
+        }
+        const pre = el('pre');
+        const code = document.createElement('code');
+        code.setAttribute('data-language', lang);
+        code.className = `lang-${lang}`;
+        code.innerHTML = config.highlighter(escapeHTML(source), lang);
+        pre.appendChild(code);
+        holder.appendChild(pre);
+        cellEl.appendChild(holder);
+    }
+    // Outputs
+    const rawOutputs = coalesceStreams(cell.outputs ?? []);
+    for (const output of rawOutputs) {
+        const outer = el('div', ['output']);
+        let inner;
+        switch (output.output_type) {
+            case 'display_data':
+            case 'execute_result':
+            case 'pyout':
+                inner = renderDisplayData(output, config);
+                break;
+            case 'stream':
+                inner = renderStream(output, config);
+                break;
+            case 'error':
+            case 'pyerr':
+                inner = renderError(output, config);
+                break;
+            default:
+                inner = el('div', ['empty-output']);
+        }
+        outer.appendChild(inner);
+        cellEl.appendChild(outer);
+    }
+    return cellEl;
+}
+function renderMarkdownCell(cell, config) {
+    const cellEl = el('div', ['cell', 'markdown-cell']);
+    const source = joinText(cell.source ?? cell.input ?? '');
+    cellEl.innerHTML = config.markdown(source);
+    return cellEl;
+}
+function renderHeadingCell(cell) {
+    const level = Math.min(Math.max(cell.level ?? 1, 1), 6);
+    const heading = el(`h${level}`, ['cell', 'heading-cell']);
+    heading.innerHTML = escapeHTML(joinText(cell.source ?? cell.input ?? ''));
+    return heading;
+}
+function renderRawCell(cell) {
+    const cellEl = el('div', ['cell', 'raw-cell']);
+    cellEl.innerHTML = escapeHTML(joinText(cell.source ?? cell.input ?? ''));
+    return cellEl;
+}
+/**
+ * Parse and render a Jupyter notebook JSON to a DOM element.
+ * Returns the rendered element and metadata.
+ */
+export function renderNotebook(raw, config) {
+    const meta = raw.metadata ?? {};
+    const lang = meta.kernelspec?.language ?? meta.language_info?.name ?? meta.language ?? 'python';
+    const kernelName = meta.kernelspec?.display_name ?? meta.language_info?.name ?? '';
+    // Normalize cells: v4+ has top-level `cells`, v2/v3 uses `worksheets`
+    let allCells = [];
+    if (Array.isArray(raw.cells)) {
+        allCells = raw.cells;
+    }
+    else if (Array.isArray(raw.worksheets)) {
+        for (const ws of raw.worksheets) {
+            if (Array.isArray(ws.cells))
+                allCells.push(...ws.cells);
+        }
+    }
+    const notebook = el('div', ['notebook']);
+    for (const cell of allCells) {
+        let rendered;
+        switch (cell.cell_type) {
+            case 'code':
+                rendered = renderCodeCell(cell, cell.language ?? lang, config);
+                break;
+            case 'markdown':
+                rendered = renderMarkdownCell(cell, config);
+                break;
+            case 'heading':
+                rendered = renderHeadingCell(cell);
+                break;
+            case 'raw':
+                rendered = renderRawCell(cell);
+                break;
+            default:
+                rendered = renderRawCell(cell);
+        }
+        notebook.appendChild(rendered);
+    }
+    return {
+        element: notebook,
+        meta: { kernelName, language: lang, cellCount: allCells.length }
+    };
+}

package/dist/utils/parquet-metadata.js

@@ -6,7 +6,7 @@
  *
  * This provides instant metadata display before DuckDB-WASM finishes loading.
  */
-const WGS84_CODES = new Set([4326, 4979]);
+import { WGS84_CODES } from '../constants.js';
 /** Map hyparquet schema element types to DuckDB-like type strings. */
 function mapParquetType(col) {
     const lt = col.logical_type;

package/dist/utils/pmtiles-tile.js

@@ -5,6 +5,7 @@
  * vector tiles into a structure suitable for SVG rendering and
  * feature inspection.
  */
+import { LAYER_HUE_MULTIPLIER } from '../constants.js';
 const GEOM_TYPES = ['Unknown', 'Point', 'LineString', 'Polygon'];
 /**
  * Fetch and decode an MVT tile from a PMTiles archive.
@@ -60,5 +61,5 @@ export function tileMimeType(format) {
 }
 /** Compute the hue for layer index i (same palette as buildPmtilesLayers). */
 export function layerHue(i) {
-    return (i * 137) % 360;
+    return (i * LAYER_HUE_MULTIPLIER) % 360;
 }

package/dist/utils/pmtiles.js

@@ -1,4 +1,5 @@
 import { PMTiles, Protocol } from 'pmtiles';
+import { LAYER_HUE_MULTIPLIER } from '../constants.js';
 let protocol = null;
 export function getPmtilesProtocol() {
     if (!protocol) {
@@ -96,7 +97,7 @@ export function buildPmtilesLayers(sourceId, metadata) {
     const layers = [];
     for (let i = 0; i < metadata.layers.length; i++) {
         const layerId = metadata.layers[i];
-        const hue = (i * 137) % 360;
+        const hue = (i * LAYER_HUE_MULTIPLIER) % 360;
         layers.push({
             id: `${layerId}-fill`,
             type: 'fill',

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

@@ -35,7 +35,7 @@
  *
  * Also handles plain bucket names (no protocol).
  */
-export type StorageProvider = 's3' | 'gcs' | 'r2' | 'minio' | 'azure' | 'storj' | 'unknown';
+export type StorageProvider = string;
 export interface ParsedStorageUrl {
     bucket: string;
     region: string;

package/dist/utils/storage-url.js

@@ -35,25 +35,25 @@
  *
  * Also handles plain bucket names (no protocol).
  */
-/** All recognized URI scheme prefixes (lowercase) */
-const SCHEME_MAP = {
-    's3://': { provider: 's3', strip: 5 },
-    's3a://': { provider: 's3', strip: 6 },
-    's3n://': { provider: 's3', strip: 6 },
-    'aws://': { provider: 's3', strip: 6 },
-    'r2://': { provider: 'r2', strip: 5 },
-    'gs://': { provider: 'gcs', strip: 5 },
-    'gcs://': { provider: 'gcs', strip: 6 },
-    'azure://': { provider: 'azure', strip: 8 },
-    'az://': { provider: 'azure', strip: 5 },
-    'abfs://': { provider: 'azure', strip: 7 },
-    'abfss://': { provider: 'azure', strip: 8 },
-    'wasbs://': { provider: 'azure', strip: 8 },
-    'adl://': { provider: 'azure', strip: 6 },
-    'storj://': { provider: 'storj', strip: 8 },
-    'sj://': { provider: 'storj', strip: 5 },
-    'swift://': { provider: 'unknown', strip: 8 }
-};
+import { PROVIDERS } from '../storage/providers.js';
+/**
+ * Build SCHEME_MAP from the provider registry's `schemes` arrays.
+ * Each scheme like "s3" generates an entry `"s3://": { provider: "s3", strip: 5 }`.
+ */
+function buildSchemeMap() {
+    const map = {};
+    for (const [id, def] of Object.entries(PROVIDERS)) {
+        for (const scheme of def.schemes) {
+            const key = `${scheme}://`;
+            map[key] = { provider: id, strip: key.length };
+        }
+    }
+    // Non-registry schemes (no corresponding provider)
+    map['swift://'] = { provider: 'unknown', strip: 8 };
+    return map;
+}
+/** All recognized URI scheme prefixes (lowercase), derived from provider registry */
+const SCHEME_MAP = buildSchemeMap();
 function defaultResult(defaults) {
     return {
         bucket: '',
@@ -174,7 +174,7 @@ export function parseStorageUrl(input, defaults = {}) {
                     bucket: doVhost[1],
                     region: doVhost[2],
                     endpoint: `${url.protocol}//${doVhost[2]}.digitaloceanspaces.com`,
-                    provider: 's3',
+                    provider: 'digitalocean',
                     prefix: pathParts.join('/')
                 };
             }
@@ -185,7 +185,7 @@ export function parseStorageUrl(input, defaults = {}) {
                     bucket: pathParts[0],
                     region: doPath[1],
                     endpoint: `${url.protocol}//${url.host}`,
-                    provider: 's3',
+                    provider: 'digitalocean',
                     prefix: pathParts.slice(1).join('/')
                 };
             }
@@ -197,7 +197,7 @@ export function parseStorageUrl(input, defaults = {}) {
                     bucket: pathParts[0],
                     region: wasabiMatch[1],
                     endpoint: `${url.protocol}//${url.host}`,
-                    provider: 's3',
+                    provider: 'wasabi',
                     prefix: pathParts.slice(1).join('/')
                 };
             }
@@ -209,7 +209,7 @@ export function parseStorageUrl(input, defaults = {}) {
                     bucket: b2S3[1],
                     region: b2S3[2],
                     endpoint: `${url.protocol}//s3.${b2S3[2]}.backblazeb2.com`,
-                    provider: 's3',
+                    provider: 'b2',
                     prefix: pathParts.join('/')
                 };
             }
@@ -220,7 +220,7 @@ export function parseStorageUrl(input, defaults = {}) {
                     bucket: pathParts[1],
                     region: defaults.region || 'us-west-000',
                     endpoint: `${url.protocol}//${url.host}`,
-                    provider: 's3',
+                    provider: 'b2',
                     prefix: pathParts.slice(2).join('/')
                 };
             }
@@ -259,6 +259,64 @@ export function parseStorageUrl(input, defaults = {}) {
                     prefix: pathParts.slice(1).join('/')
                 };
             }
+            // --- Contabo ---
+            // <region>.contabostorage.com/<bucket>
+            const contaboMatch = host.match(/^([a-z0-9]+)\.contabostorage\.com$/);
+            if (contaboMatch && pathParts.length > 0) {
+                return {
+                    bucket: pathParts[0],
+                    region: contaboMatch[1],
+                    endpoint: `${url.protocol}//${url.host}`,
+                    provider: 'contabo',
+                    prefix: pathParts.slice(1).join('/')
+                };
+            }
+            // --- Hetzner ---
+            // <region>.your-objectstorage.com/<bucket>
+            const hetznerMatch = host.match(/^([a-z0-9]+)\.your-objectstorage\.com$/);
+            if (hetznerMatch && pathParts.length > 0) {
+                return {
+                    bucket: pathParts[0],
+                    region: hetznerMatch[1],
+                    endpoint: `${url.protocol}//${url.host}`,
+                    provider: 'hetzner',
+                    prefix: pathParts.slice(1).join('/')
+                };
+            }
+            // --- Linode / Akamai ---
+            // <bucket>.<region>.linodeobjects.com or <region>.linodeobjects.com/<bucket>
+            const linodeVhost = host.match(/^(.+)\.([a-z0-9-]+)\.linodeobjects\.com$/);
+            if (linodeVhost) {
+                return {
+                    bucket: linodeVhost[1],
+                    region: linodeVhost[2],
+                    endpoint: `${url.protocol}//${linodeVhost[2]}.linodeobjects.com`,
+                    provider: 'linode',
+                    prefix: pathParts.join('/')
+                };
+            }
+            const linodePath = host.match(/^([a-z0-9-]+)\.linodeobjects\.com$/);
+            if (linodePath && pathParts.length > 0) {
+                return {
+                    bucket: pathParts[0],
+                    region: linodePath[1],
+                    endpoint: `${url.protocol}//${url.host}`,
+                    provider: 'linode',
+                    prefix: pathParts.slice(1).join('/')
+                };
+            }
+            // --- OVHcloud ---
+            // s3.<region>.io.cloud.ovh.net/<bucket>
+            const ovhMatch = host.match(/^s3\.([a-z0-9-]+)\.io\.cloud\.ovh\.(?:net|us)$/);
+            if (ovhMatch && pathParts.length > 0) {
+                return {
+                    bucket: pathParts[0],
+                    region: ovhMatch[1],
+                    endpoint: `${url.protocol}//${url.host}`,
+                    provider: 'ovhcloud',
+                    prefix: pathParts.slice(1).join('/')
+                };
+            }
             // --- MinIO ---
             // Common patterns: minio.<domain>, localhost with port
             const isMinioLike = host.includes('minio') ||

package/dist/utils/url-state.js

@@ -10,18 +10,13 @@
  * Uses SvelteKit's replaceState to avoid conflicts with the router.
  */
 import { replaceState } from '$app/navigation';
+import { buildProviderBaseUrl } from '../storage/providers.js';
 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}`;
+    return buildProviderBaseUrl(conn.provider, conn.endpoint, conn.bucket, conn.region);
 }
 /**
  * Build a full storage URL from a Connection + optional object prefix.

package/dist/utils/url.d.ts

@@ -4,8 +4,6 @@ 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;
-/** 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.).
  */

package/dist/utils/url.js

@@ -1,5 +1,7 @@
+import { buildProviderBaseUrl } 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';
 /**
  * Build an HTTPS URL for a tab's file.
  * Works for any viewer that needs an HTTP-accessible URL (COG, PMTiles, Zarr, etc.)
@@ -16,27 +18,7 @@ export function buildHttpsUrl(tab) {
             : `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';
-    }
+    return `${buildProviderBaseUrl(conn.provider, conn.endpoint, conn.bucket, conn.region)}/${cleanPath}`;
 }
 /**
  * Build a provider-native protocol URL (s3://bucket/path, sj://bucket/path, etc.).
@@ -76,14 +58,6 @@ export function buildDuckDbUrl(tab) {
     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).

package/dist/utils/zarr.d.ts

@@ -1,39 +1,79 @@
 /**
  * Zarr metadata parsing utilities.
  *
- * Handles consolidated metadata for both Zarr v2 (.zmetadata) and v3 (zarr.json),
- * plus a zarrita fallback for non-consolidated stores.
+ * Builds a hierarchical tree of groups and arrays from consolidated metadata
+ * (Zarr v2 .zmetadata, v3 zarr.json), with zarrita fallback for non-consolidated stores.
  */
-export interface VarMeta {
+/** Ensure numcodecs codecs are registered. Await before creating ZarrLayer. */
+export declare function ensureCodecsRegistered(): Promise<void>;
+/** Zarr store marker files — presence of any indicates a Zarr store. */
+export declare const ZARR_MARKER_FILES: Set<string>;
+/**
+ * Detect whether a set of file names contains Zarr marker files.
+ * Returns the detected version (2 or 3) or null if not detected.
+ */
+export declare function detectZarrMarkers(fileNames: Iterable<string>): {
+    detected: boolean;
+    version: 2 | 3 | null;
+};
+/**
+ * If a URL points to a Zarr marker file, strip the marker suffix and return the store URL.
+ * Returns null if the URL doesn't end with a known marker suffix.
+ */
+export declare function extractZarrStoreUrl(url: string): string | null;
+export interface ZarrNode {
+    path: string;
     name: string;
-    shape: number[];
-    dtype: string;
-    dims: string[];
-    chunks: number[];
+    kind: 'group' | 'array';
+    children: ZarrNode[];
+    shape?: number[];
+    dtype?: string;
+    dims?: string[];
+    chunks?: number[];
+    fillValue?: any;
+    codecs?: any[];
+    compressor?: any;
+    filters?: any[];
+    chunkKeyEncoding?: string;
     attributes: Record<string, any>;
 }
-export interface ZarrMetadata {
+export interface ZarrHierarchy {
+    root: ZarrNode;
+    zarrVersion: 2 | 3 | null;
+    totalNodes: number;
     storeAttrs: Record<string, any>;
-    variables: VarMeta[];
-    coords: VarMeta[];
     spatialRefAttrs: Record<string, any> | null;
-    zarrVersion: number | null;
 }
+/** Dimension-like variable names treated as coordinates. */
+export declare const DIM_LIKE_NAMES: Set<string>;
 /** 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'>;
+/** Byte size of a dtype string. Handles v2 (`<f4`, `|u1`) and v3 (`float32`, `uint8`). */
+export declare function dtypeByteSize(dtype: string): number;
+/** Format chunk count: `"36 [6 × 6]"` */
+export declare function computeChunkCount(shape: number[] | undefined, chunks: number[] | undefined): string | null;
+/** Format chunk size in bytes: `"817.6 KB"` */
+export declare function computeChunkSize(chunks: number[] | undefined, dtype: string | undefined): string | null;
+/** Format uncompressed size: `"28.7 MB"` */
+export declare function computeUncompressed(shape: number[] | undefined, dtype: string | undefined): string | null;
+/** Format codec pipeline for display. */
+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). */
+export declare function buildV2Tree(data: any): ZarrHierarchy;
 /**
- * Fetch consolidated metadata from a Zarr store URL.
- * Tries v3 (zarr.json) first, then v2 (.zmetadata).
+ * Fetch hierarchy from a Zarr store URL.
+ * Tries v3 (zarr.json) first, then v2 (.zmetadata), then zarrita fallback.
  */
-export declare function fetchConsolidated(storeUrl: string): Promise<ZarrMetadata | null>;
+export declare function fetchHierarchy(storeUrl: string, storeName: string, signal?: AbortSignal): Promise<ZarrHierarchy | 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>;
+export declare function probeHierarchy(storeUrl: string, storeName: string): Promise<ZarrHierarchy | null>;