@walkthru-earth/objex 0.1.0 → 1.0.0

package/dist/utils/host-detection.js

@@ -7,6 +7,7 @@
  *
  * Also extracts `rootPrefix` when the app is hosted inside a subfolder.
  */
+import { buildProviderBaseUrl } from '../storage/providers.js';
 import { parseStorageUrl } from './storage-url.js';
 /**
  * Extract root prefix from pathname.
@@ -28,20 +29,8 @@ function extractRootPrefix(pathname) {
 /**
  * Build a normalized API endpoint URL for a detected provider.
  */
-function buildBucketUrl(provider, endpoint, bucket) {
-    if (endpoint) {
-        return `${endpoint.replace(/\/$/, '')}/${bucket}`;
-    }
-    switch (provider) {
-        case 'gcs':
-            return `https://storage.googleapis.com/${bucket}`;
-        case 'azure':
-            return `${endpoint}/${bucket}`;
-        case 'storj':
-            return `https://gateway.storjshare.io/${bucket}`;
-        default:
-            return `https://s3.us-east-1.amazonaws.com/${bucket}`;
-    }
+function buildBucketUrl(provider, endpoint, bucket, region) {
+    return buildProviderBaseUrl((provider === 'unknown' ? 's3' : provider), endpoint, bucket, region || '');
 }
 /**
  * Detect hosting bucket from current URL.
@@ -178,7 +167,7 @@ export function detectHostBucket() {
     const doSpaces = host.match(/^(.+)\.([a-z0-9-]+)\.digitaloceanspaces\.com$/);
     if (doSpaces) {
         return {
-            provider: 's3',
+            provider: 'digitalocean',
             bucket: doSpaces[1],
             region: doSpaces[2],
             endpoint: `https://${doSpaces[2]}.digitaloceanspaces.com`,
@@ -190,7 +179,7 @@ export function detectHostBucket() {
     const doCdn = host.match(/^(.+)\.([a-z0-9-]+)\.cdn\.digitaloceanspaces\.com$/);
     if (doCdn) {
         return {
-            provider: 's3',
+            provider: 'digitalocean',
             bucket: doCdn[1],
             region: doCdn[2],
             endpoint: `https://${doCdn[2]}.digitaloceanspaces.com`,
@@ -204,7 +193,7 @@ export function detectHostBucket() {
         const parts = pathname.replace(/^\//, '').split('/').filter(Boolean);
         if (parts.length > 0) {
             return {
-                provider: 's3',
+                provider: 'wasabi',
                 bucket: parts[0],
                 region: wasabi[1],
                 endpoint: `https://${host}`,
@@ -217,7 +206,7 @@ export function detectHostBucket() {
     const b2s3 = host.match(/^(.+)\.s3\.([a-z0-9-]+)\.backblazeb2\.com$/);
     if (b2s3) {
         return {
-            provider: 's3',
+            provider: 'b2',
             bucket: b2s3[1],
             region: b2s3[2],
             endpoint: `https://s3.${b2s3[2]}.backblazeb2.com`,
@@ -267,6 +256,77 @@ export function detectHostBucket() {
             };
         }
     }
+    // Contabo: <region>.contabostorage.com/<bucket>
+    const contabo = host.match(/^([a-z0-9]+)\.contabostorage\.com$/);
+    if (contabo) {
+        const parts = pathname.replace(/^\//, '').split('/').filter(Boolean);
+        if (parts.length > 0) {
+            return {
+                provider: 'contabo',
+                bucket: parts[0],
+                region: contabo[1],
+                endpoint: `${url.protocol}//${url.host}`,
+                rootPrefix: parts.length > 1 ? extractRootPrefix(`/${parts.slice(1).join('/')}`) : '',
+                bucketUrl: `${url.protocol}//${url.host}/${parts[0]}`
+            };
+        }
+    }
+    // Hetzner: <region>.your-objectstorage.com/<bucket>
+    const hetzner = host.match(/^([a-z0-9]+)\.your-objectstorage\.com$/);
+    if (hetzner) {
+        const parts = pathname.replace(/^\//, '').split('/').filter(Boolean);
+        if (parts.length > 0) {
+            return {
+                provider: 'hetzner',
+                bucket: parts[0],
+                region: hetzner[1],
+                endpoint: `${url.protocol}//${url.host}`,
+                rootPrefix: parts.length > 1 ? extractRootPrefix(`/${parts.slice(1).join('/')}`) : '',
+                bucketUrl: `${url.protocol}//${url.host}/${parts[0]}`
+            };
+        }
+    }
+    // Linode / Akamai: <bucket>.<region>.linodeobjects.com or <region>.linodeobjects.com/<bucket>
+    const linodeVhost = host.match(/^(.+)\.([a-z0-9-]+)\.linodeobjects\.com$/);
+    if (linodeVhost) {
+        return {
+            provider: 'linode',
+            bucket: linodeVhost[1],
+            region: linodeVhost[2],
+            endpoint: `https://${linodeVhost[2]}.linodeobjects.com`,
+            rootPrefix: extractRootPrefix(pathname),
+            bucketUrl: `https://${linodeVhost[2]}.linodeobjects.com/${linodeVhost[1]}`
+        };
+    }
+    const linodePath = host.match(/^([a-z0-9-]+)\.linodeobjects\.com$/);
+    if (linodePath) {
+        const parts = pathname.replace(/^\//, '').split('/').filter(Boolean);
+        if (parts.length > 0) {
+            return {
+                provider: 'linode',
+                bucket: parts[0],
+                region: linodePath[1],
+                endpoint: `https://${url.host}`,
+                rootPrefix: parts.length > 1 ? extractRootPrefix(`/${parts.slice(1).join('/')}`) : '',
+                bucketUrl: `https://${url.host}/${parts[0]}`
+            };
+        }
+    }
+    // OVHcloud: s3.<region>.io.cloud.ovh.net/<bucket>
+    const ovh = host.match(/^s3\.([a-z0-9-]+)\.io\.cloud\.ovh\.(?:net|us)$/);
+    if (ovh) {
+        const parts = pathname.replace(/^\//, '').split('/').filter(Boolean);
+        if (parts.length > 0) {
+            return {
+                provider: 'ovhcloud',
+                bucket: parts[0],
+                region: ovh[1],
+                endpoint: `https://${url.host}`,
+                rootPrefix: parts.length > 1 ? extractRootPrefix(`/${parts.slice(1).join('/')}`) : '',
+                bucketUrl: `https://${url.host}/${parts[0]}`
+            };
+        }
+    }
     // MinIO / localhost / private IPs
     const isLocal = host === 'localhost' ||
         host === '127.0.0.1' ||

package/dist/utils/notebook.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Lightweight browser-native Jupyter notebook renderer.
+ * Replaces `notebookjs` which depends on jsdom/Buffer (Node.js only).
+ * Handles nbformat 2, 3, 4, and 5.
+ */
+export interface NotebookConfig {
+    markdown: (md: string) => string;
+    ansi: (text: string) => string;
+    highlighter: (code: string, lang: string) => string;
+}
+interface RawNotebook {
+    nbformat: number;
+    nbformat_minor?: number;
+    metadata?: Record<string, any>;
+    cells?: RawCell[];
+    worksheets?: {
+        cells: RawCell[];
+    }[];
+}
+interface RawCell {
+    cell_type: string;
+    source?: string | string[];
+    input?: string | string[];
+    outputs?: RawOutput[];
+    prompt_number?: number;
+    execution_count?: number | null;
+    level?: number;
+    language?: string;
+}
+interface RawOutput {
+    output_type: string;
+    data?: Record<string, string | string[]>;
+    text?: string | string[];
+    stream?: string;
+    name?: string;
+    png?: string;
+    jpeg?: string;
+    svg?: string;
+    html?: string;
+    latex?: string;
+    traceback?: string[];
+    ename?: string;
+    evalue?: string;
+    [key: string]: any;
+}
+export interface NotebookMeta {
+    kernelName: string;
+    language: string;
+    cellCount: number;
+}
+/**
+ * Parse and render a Jupyter notebook JSON to a DOM element.
+ * Returns the rendered element and metadata.
+ */
+export declare function renderNotebook(raw: RawNotebook, config: NotebookConfig): {
+    element: HTMLElement;
+    meta: NotebookMeta;
+};
+export {};

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,7 +4,11 @@ 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. */
+/**
+ * Map provider to its native URI scheme prefix.
+ * Derived from the registry's `schemes` array (first entry is the primary scheme).
+ * Falls back to 's3' for providers without a scheme (S3-compatible).
+ */
 export declare function getNativeScheme(provider: string): string;
 /**
  * Build a provider-native protocol URL (s3://bucket/path, sj://bucket/path, etc.).
@@ -25,3 +29,13 @@ export declare function buildDuckDbUrl(tab: Tab): string;
  * False for authenticated S3 (needs signed URLs or blob download via adapter).
  */
 export declare function canStreamDirectly(tab: Tab): boolean;
+/**
+ * Convert a cloud storage protocol URL (s3://, gs://) to an HTTPS URL
+ * for browser access. Returns the original URL if already HTTP(S) or unknown.
+ *
+ * Supported:
+ * - `s3://bucket/key` → `https://s3.{region}.amazonaws.com/{bucket}/{key}`
+ *   (region auto-detected from bucket name when possible, e.g. "us-west-2.opendata.source.coop")
+ * - `gs://bucket/key` → `https://storage.googleapis.com/{bucket}/{key}`
+ */
+export declare function resolveCloudUrl(url: string): string;