@walkthru-earth/objex 0.1.0

package/dist/components/viewers/pmtiles/PmtilesTileInspector.svelte

@@ -0,0 +1,373 @@
+<script lang="ts">
+import ChevronUpIcon from '@lucide/svelte/icons/chevron-up';
+import XIcon from '@lucide/svelte/icons/x';
+import type { PMTiles } from 'pmtiles';
+import { t } from '../../../i18n/index.svelte.js';
+import type { PmtilesMetadata } from '../../../utils/pmtiles';
+import {
+	type DecodedTile,
+	decodeMvtTile,
+	layerHue,
+	tileMimeType,
+	tileToImageUrl
+} from '../../../utils/pmtiles-tile.js';
+import SvgTileRenderer from './SvgTileRenderer.svelte';
+
+let {
+	metadata,
+	pmtiles,
+	initialZ,
+	initialX,
+	initialY
+}: {
+	metadata: PmtilesMetadata;
+	pmtiles: PMTiles;
+	initialZ?: number;
+	initialX?: number;
+	initialY?: number;
+} = $props();
+
+let inputZ = $state(0);
+let inputX = $state(0);
+let inputY = $state(0);
+
+// Initialize from props (using derived to track prop changes)
+const _initZ = $derived(initialZ ?? metadata.minZoom);
+const _initX = $derived(initialX ?? 0);
+const _initY = $derived(initialY ?? 0);
+
+// Seed inputs once on mount
+let seeded = false;
+$effect(() => {
+	if (!seeded) {
+		inputZ = _initZ;
+		inputX = _initX;
+		inputY = _initY;
+		seeded = true;
+	}
+});
+
+let tile = $state<DecodedTile | null>(null);
+let rasterUrl = $state<string | null>(null);
+let loading = $state(false);
+let error = $state<string | null>(null);
+let tileSize = $state(0);
+
+let selectedLayerName = $state<string | null>(null);
+let selectedFeatureIdx = $state<number | null>(null);
+let showLayerPanel = $state(true);
+let layerVisibility = $state<Record<string, boolean>>({});
+
+const isVector = $derived(metadata.format === 'mvt');
+
+// Auto-fetch when initial coordinates arrive from archive view
+let lastInitKey = '';
+$effect(() => {
+	const key = `${initialZ}/${initialX}/${initialY}`;
+	if (
+		key !== lastInitKey &&
+		initialZ !== undefined &&
+		initialX !== undefined &&
+		initialY !== undefined
+	) {
+		lastInitKey = key;
+		inputZ = initialZ;
+		inputX = initialX;
+		inputY = initialY;
+		fetchTile();
+	}
+});
+
+async function fetchTile() {
+	loading = true;
+	error = null;
+	tile = null;
+	rasterUrl = null;
+	selectedLayerName = null;
+	selectedFeatureIdx = null;
+
+	try {
+		if (isVector) {
+			const result = await decodeMvtTile(pmtiles, inputZ, inputX, inputY);
+			if (!result) {
+				error = t('pmtiles.tileNotFound');
+			} else {
+				tile = result;
+				tileSize = result.rawSize;
+				// Init visibility
+				const vis: Record<string, boolean> = {};
+				for (const l of result.layers) vis[l.name] = true;
+				layerVisibility = vis;
+			}
+		} else {
+			const mime = tileMimeType(metadata.format);
+			const url = await tileToImageUrl(pmtiles, inputZ, inputX, inputY, mime);
+			if (!url) {
+				error = t('pmtiles.tileNotFound');
+			} else {
+				rasterUrl = url;
+				const resp = await pmtiles.getZxy(inputZ, inputX, inputY);
+				tileSize = resp ? new Uint8Array(resp.data).length : 0;
+			}
+		}
+	} catch (e) {
+		error = e instanceof Error ? e.message : String(e);
+	} finally {
+		loading = false;
+	}
+}
+
+function navigateParent() {
+	if (inputZ <= 0) return;
+	inputZ = inputZ - 1;
+	inputX = Math.floor(inputX / 2);
+	inputY = Math.floor(inputY / 2);
+	fetchTile();
+}
+
+function navigateChild(dx: number, dy: number) {
+	inputZ = inputZ + 1;
+	inputX = inputX * 2 + dx;
+	inputY = inputY * 2 + dy;
+	fetchTile();
+}
+
+function handleKeydown(e: KeyboardEvent) {
+	if (e.key === 'Enter') fetchTile();
+}
+
+function selectFeature(layerName: string, featureIndex: number) {
+	selectedLayerName = layerName;
+	selectedFeatureIdx = featureIndex;
+}
+
+const selectedFeature = $derived.by(() => {
+	if (!tile || selectedLayerName === null || selectedFeatureIdx === null) return null;
+	const layer = tile.layers.find((l) => l.name === selectedLayerName);
+	if (!layer || selectedFeatureIdx >= layer.features.length) return null;
+	return layer.features[selectedFeatureIdx];
+});
+
+const selectedFeatureKey = $derived(
+	selectedLayerName !== null && selectedFeatureIdx !== null
+		? `${selectedLayerName}:${selectedFeatureIdx}`
+		: null
+);
+
+function formatBytes(bytes: number): string {
+	if (bytes === 0) return '0 B';
+	const units = ['B', 'KB', 'MB'];
+	const i = Math.floor(Math.log(bytes) / Math.log(1024));
+	return `${(bytes / 1024 ** i).toFixed(i > 0 ? 1 : 0)} ${units[i]}`;
+}
+
+function formatValue(v: unknown): string {
+	if (v === null || v === undefined) return 'NULL';
+	if (typeof v === 'object') return JSON.stringify(v);
+	return String(v);
+}
+</script>
+
+<div class="flex h-full flex-col overflow-hidden">
+	<!-- Navigation bar -->
+	<div
+		class="flex shrink-0 flex-wrap items-center gap-2 border-b border-zinc-200 px-3 py-2 dark:border-zinc-800"
+	>
+		<!-- Z/X/Y inputs -->
+		<div class="flex items-center gap-1 text-xs">
+			<span class="text-muted-foreground">z</span>
+			<input
+				type="number"
+				bind:value={inputZ}
+				min={0}
+				max={30}
+				class="w-12 rounded border border-zinc-300 bg-transparent px-1.5 py-0.5 text-center font-mono text-xs dark:border-zinc-700"
+				onkeydown={handleKeydown}
+			/>
+			<span class="text-muted-foreground">x</span>
+			<input
+				type="number"
+				bind:value={inputX}
+				min={0}
+				class="w-16 rounded border border-zinc-300 bg-transparent px-1.5 py-0.5 text-center font-mono text-xs dark:border-zinc-700"
+				onkeydown={handleKeydown}
+			/>
+			<span class="text-muted-foreground">y</span>
+			<input
+				type="number"
+				bind:value={inputY}
+				min={0}
+				class="w-16 rounded border border-zinc-300 bg-transparent px-1.5 py-0.5 text-center font-mono text-xs dark:border-zinc-700"
+				onkeydown={handleKeydown}
+			/>
+		</div>
+
+		<button
+			class="rounded bg-primary/90 px-3 py-1 text-xs text-primary-foreground hover:bg-primary"
+			onclick={fetchTile}
+			disabled={loading}
+		>
+			{loading ? '...' : t('pmtiles.fetchTile')}
+		</button>
+
+		<!-- Tile size badge -->
+		{#if tileSize > 0}
+			<span class="text-[10px] tabular-nums text-muted-foreground">
+				{formatBytes(tileSize)}
+			</span>
+		{/if}
+
+		<div class="ms-auto flex items-center gap-1">
+			<!-- Parent -->
+			<button
+				class="rounded bg-card/80 p-1 text-xs text-card-foreground hover:bg-card disabled:opacity-30"
+				onclick={navigateParent}
+				disabled={inputZ <= 0}
+				title={t('pmtiles.parent')}
+			>
+				<ChevronUpIcon class="size-3.5" />
+			</button>
+
+			<!-- Children 2x2 -->
+			<div class="grid grid-cols-2 gap-px">
+				{#each [[0, 0], [1, 0], [0, 1], [1, 1]] as [dx, dy]}
+					<button
+						class="size-4 rounded-sm bg-card/80 text-[8px] leading-none text-card-foreground hover:bg-card"
+						onclick={() => navigateChild(dx, dy)}
+						title="z{inputZ + 1}/{inputX * 2 + dx}/{inputY * 2 + dy}"
+					>
+						{dx}{dy}
+					</button>
+				{/each}
+			</div>
+		</div>
+	</div>
+
+	<!-- Main content -->
+	<div class="flex min-h-0 flex-1 overflow-hidden">
+		{#if loading}
+			<div class="flex flex-1 items-center justify-center text-xs text-muted-foreground">
+				Loading tile...
+			</div>
+		{:else if error}
+			<div class="flex flex-1 items-center justify-center text-xs text-red-400">
+				{error}
+			</div>
+		{:else if tile}
+			<!-- SVG render area -->
+			<div class="relative min-w-0 flex-1 overflow-hidden p-2">
+				<SvgTileRenderer
+					{tile}
+					visibleLayers={layerVisibility}
+					{selectedFeatureKey}
+					onFeatureClick={selectFeature}
+				/>
+
+				<!-- Layer panel overlay -->
+				{#if showLayerPanel}
+					<div
+						class="absolute left-4 top-4 z-10 max-h-[50%] w-44 overflow-auto rounded bg-card/95 p-2 text-xs shadow-lg backdrop-blur-sm"
+					>
+						<div class="mb-1 flex items-center justify-between">
+							<span class="font-medium text-card-foreground">{t('pmtiles.layers')}</span>
+							<button
+								class="rounded p-0.5 text-zinc-400 hover:text-zinc-200"
+								onclick={() => (showLayerPanel = false)}
+							>
+								<XIcon class="size-3" />
+							</button>
+						</div>
+						{#each tile.layers as layer, i}
+							<label
+								class="flex cursor-pointer items-center gap-1.5 rounded px-1 py-0.5 hover:bg-zinc-800/50"
+							>
+								<input
+									type="checkbox"
+									checked={layerVisibility[layer.name] !== false}
+									onchange={() => (layerVisibility[layer.name] = !layerVisibility[layer.name])}
+									class="size-3 accent-primary"
+								/>
+								<span
+									class="inline-block size-2 shrink-0 rounded-sm"
+									style="background: hsl({layerHue(i)}, 70%, 55%)"
+								></span>
+								<span class="truncate text-card-foreground">{layer.name}</span>
+								<span class="ms-auto text-[10px] text-muted-foreground">
+									{layer.features.length}
+								</span>
+							</label>
+						{/each}
+					</div>
+				{/if}
+			</div>
+
+			<!-- Feature properties panel -->
+			<div
+				class="flex w-56 shrink-0 flex-col border-s border-zinc-200 lg:w-64 dark:border-zinc-800"
+			>
+				<div
+					class="shrink-0 border-b border-zinc-200 px-3 py-1.5 text-[11px] font-medium uppercase tracking-wider text-muted-foreground dark:border-zinc-800"
+				>
+					{t('pmtiles.featureProperties')}
+				</div>
+				{#if selectedFeature && selectedLayerName !== null}
+					<div class="flex-1 overflow-auto">
+						<div class="border-b border-zinc-200 px-3 py-2 dark:border-zinc-800">
+							<div class="flex items-center gap-1.5 text-xs">
+								<span
+									class="inline-block size-2 rounded-sm"
+									style="background: hsl({layerHue(tile.layers.findIndex((l) => l.name === selectedLayerName))}, 70%, 55%)"
+								></span>
+								<span class="font-medium">{selectedLayerName}</span>
+							</div>
+							<div class="mt-0.5 text-[10px] text-muted-foreground">
+								{selectedFeature.type}
+								{#if selectedFeature.id !== undefined}
+									· ID: {selectedFeature.id}
+								{/if}
+								· #{selectedFeatureIdx}
+							</div>
+						</div>
+						<div class="divide-y divide-zinc-100 dark:divide-zinc-800">
+							{#each Object.entries(selectedFeature.properties) as [key, value]}
+								<div class="px-3 py-1.5">
+									<div class="text-[10px] font-medium text-zinc-500 dark:text-zinc-400">
+										{key}
+									</div>
+									<div
+										class="break-all text-xs text-zinc-700 dark:text-zinc-300"
+										title={formatValue(value)}
+									>
+										{formatValue(value)}
+									</div>
+								</div>
+							{/each}
+						</div>
+					</div>
+				{:else}
+					<div
+						class="flex flex-1 items-center justify-center px-4 text-center text-xs text-muted-foreground"
+					>
+						{t('pmtiles.selectFeature')}
+					</div>
+				{/if}
+			</div>
+		{:else if rasterUrl}
+			<!-- Raster tile preview -->
+			<div class="flex flex-1 items-center justify-center bg-zinc-950 p-4">
+				<img
+					src={rasterUrl}
+					alt="Tile {inputZ}/{inputX}/{inputY}"
+					class="max-h-full max-w-full rounded border border-zinc-800"
+					style="image-rendering: pixelated;"
+				/>
+			</div>
+		{:else}
+			<div
+				class="flex flex-1 items-center justify-center text-xs text-muted-foreground"
+			>
+				{t('pmtiles.noTileLoaded')}
+			</div>
+		{/if}
+	</div>
+</div>

package/dist/components/viewers/pmtiles/PmtilesTileInspector.svelte.d.ts

@@ -0,0 +1,12 @@
+import type { PMTiles } from 'pmtiles';
+import type { PmtilesMetadata } from '../../../utils/pmtiles';
+type $$ComponentProps = {
+    metadata: PmtilesMetadata;
+    pmtiles: PMTiles;
+    initialZ?: number;
+    initialX?: number;
+    initialY?: number;
+};
+declare const PmtilesTileInspector: import("svelte").Component<$$ComponentProps, {}, "">;
+type PmtilesTileInspector = ReturnType<typeof PmtilesTileInspector>;
+export default PmtilesTileInspector;

package/dist/components/viewers/pmtiles/SvgTileRenderer.svelte

@@ -0,0 +1,112 @@
+<script lang="ts">
+import type { DecodedLayer, DecodedTile } from '../../../utils/pmtiles-tile.js';
+import { layerHue } from '../../../utils/pmtiles-tile.js';
+
+let {
+	tile,
+	visibleLayers = {},
+	selectedFeatureKey = null,
+	onFeatureClick
+}: {
+	tile: DecodedTile;
+	visibleLayers?: Record<string, boolean>;
+	selectedFeatureKey?: string | null;
+	onFeatureClick?: (layer: string, featureIndex: number) => void;
+} = $props();
+
+const SVG_SIZE = 512;
+
+function featureKey(layerName: string, idx: number): string {
+	return `${layerName}:${idx}`;
+}
+
+function scale(layer: DecodedLayer): number {
+	return SVG_SIZE / layer.extent;
+}
+
+function pointsToPath(rings: number[][][], s: number, close: boolean): string {
+	return rings
+		.map((ring) => {
+			const pts = ring.map((p) => `${(p[0] * s).toFixed(1)},${(p[1] * s).toFixed(1)}`);
+			return `M${pts.join('L')}${close ? 'Z' : ''}`;
+		})
+		.join('');
+}
+
+function isVisible(layerName: string): boolean {
+	return visibleLayers[layerName] !== false;
+}
+
+/** Build a flat list of all layer names with their index for color assignment. */
+const layerIndex = $derived(new Map(tile.layers.map((l, i) => [l.name, i])));
+</script>
+
+<svg
+	viewBox="0 0 {SVG_SIZE} {SVG_SIZE}"
+	class="h-full w-full rounded bg-zinc-950"
+	xmlns="http://www.w3.org/2000/svg"
+>
+	<!-- Grid lines -->
+	<g stroke="rgba(63,63,70,0.3)" stroke-width="0.5" fill="none">
+		{#each [0, 128, 256, 384, 512] as v}
+			<line x1={v} y1="0" x2={v} y2={SVG_SIZE} />
+			<line x1="0" y1={v} x2={SVG_SIZE} y2={v} />
+		{/each}
+	</g>
+
+	{#each tile.layers as layer}
+		{#if isVisible(layer.name)}
+			{@const s = scale(layer)}
+			{@const hue = layerHue(layerIndex.get(layer.name) ?? 0)}
+			<g>
+				{#each layer.features as feature, fi}
+					{@const key = featureKey(layer.name, fi)}
+					{@const selected = key === selectedFeatureKey}
+					{#if feature.type === 'Polygon'}
+						<path
+							d={pointsToPath(feature.geometry, s, true)}
+							fill="hsla({hue}, 70%, 55%, {selected ? 0.5 : 0.25})"
+							stroke="hsl({hue}, 70%, {selected ? '80%' : '45%'})"
+							stroke-width={selected ? 2 : 0.8}
+							class="cursor-pointer"
+							role="button"
+							tabindex="-1"
+							onclick={() => onFeatureClick?.(layer.name, fi)}
+							onkeydown={() => {}}
+						/>
+					{:else if feature.type === 'LineString'}
+						<path
+							d={pointsToPath(feature.geometry, s, false)}
+							fill="none"
+							stroke="hsl({hue}, 70%, {selected ? '80%' : '50%'})"
+							stroke-width={selected ? 2.5 : 1.2}
+							class="cursor-pointer"
+							role="button"
+							tabindex="-1"
+							onclick={() => onFeatureClick?.(layer.name, fi)}
+							onkeydown={() => {}}
+						/>
+					{:else if feature.type === 'Point'}
+						{#each feature.geometry as ring}
+							{#each ring as pt}
+								<circle
+									cx={(pt[0] * s).toFixed(1)}
+									cy={(pt[1] * s).toFixed(1)}
+									r={selected ? 5 : 3}
+									fill="hsl({hue}, 70%, 55%)"
+									stroke={selected ? '#ffc800' : 'white'}
+									stroke-width={selected ? 2 : 0.8}
+									class="cursor-pointer"
+									role="button"
+									tabindex="-1"
+									onclick={() => onFeatureClick?.(layer.name, fi)}
+									onkeydown={() => {}}
+								/>
+							{/each}
+						{/each}
+					{/if}
+				{/each}
+			</g>
+		{/if}
+	{/each}
+</svg>

package/dist/components/viewers/pmtiles/SvgTileRenderer.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { DecodedTile } from '../../../utils/pmtiles-tile.js';
+type $$ComponentProps = {
+    tile: DecodedTile;
+    visibleLayers?: Record<string, boolean>;
+    selectedFeatureKey?: string | null;
+    onFeatureClick?: (layer: string, featureIndex: number) => void;
+};
+declare const SvgTileRenderer: import("svelte").Component<$$ComponentProps, {}, "">;
+type SvgTileRenderer = ReturnType<typeof SvgTileRenderer>;
+export default SvgTileRenderer;

package/dist/file-icons/CLAUDE.md

@@ -0,0 +1,21 @@
+# file-icons/
+
+Extension → file type registry. Maps 200+ extensions to viewer, icon, category, DuckDB read function.
+
+```mermaid
+graph LR
+    EXT[".parquet"] --> FT[getFileTypeInfo]
+    FT --> VK[getViewerKind → 'table']
+    FT --> DR[getDuckDbReadFn → 'read_parquet']
+    FT --> CN[isCloudNativeFormat → true]
+    FT --> QR[isQueryable → true]
+    FT --> IC[FileTypeIcon.svelte]
+```
+
+| File | Exports | Used by |
+|------|---------|---------|
+| `index.ts` | `getFileTypeInfo()`, `getDuckDbReadFn()`, `buildDuckDbSource()`, `isCloudNativeFormat()`, `getViewerKind()`, `isQueryable()`, `getMimeType()` | StatusBar, FileRow, ViewerRouter, TableViewer, query/wasm, +page.svelte, lib/index.ts |
+| `FileTypeIcon.svelte` | Icon component (Lucide icons by category) | FileRow, TabBar |
+
+Types: `FileCategory`, `ViewerKind`, `DuckDbReadFn`, `FileTypeInfo` (interface).
+Published to npm. No Svelte dependency in `index.ts`.

package/dist/file-icons/FileTypeIcon.svelte

@@ -0,0 +1,74 @@
+<script lang="ts">
+import ArchiveIcon from '@lucide/svelte/icons/archive';
+import BookTextIcon from '@lucide/svelte/icons/book-text';
+import BoxIcon from '@lucide/svelte/icons/box';
+import BracesIcon from '@lucide/svelte/icons/braces';
+import Columns3Icon from '@lucide/svelte/icons/columns-3';
+import DatabaseIcon from '@lucide/svelte/icons/database';
+import DatabaseZapIcon from '@lucide/svelte/icons/database-zap';
+import FileIcon from '@lucide/svelte/icons/file';
+import FileCodeIcon from '@lucide/svelte/icons/file-code';
+import FileTextIcon from '@lucide/svelte/icons/file-text';
+import FilmIcon from '@lucide/svelte/icons/film';
+import FolderIcon from '@lucide/svelte/icons/folder';
+import FolderOpenIcon from '@lucide/svelte/icons/folder-open';
+import GlobeIcon from '@lucide/svelte/icons/globe';
+import ImageIcon from '@lucide/svelte/icons/image';
+import LayersIcon from '@lucide/svelte/icons/layers';
+import MapIcon from '@lucide/svelte/icons/map';
+import MusicIcon from '@lucide/svelte/icons/music';
+import PaintbrushIcon from '@lucide/svelte/icons/paintbrush';
+import PaletteIcon from '@lucide/svelte/icons/palette';
+import SettingsIcon from '@lucide/svelte/icons/settings';
+import TableIcon from '@lucide/svelte/icons/table';
+import TerminalIcon from '@lucide/svelte/icons/terminal';
+import ZapIcon from '@lucide/svelte/icons/zap';
+import { getFileTypeInfo } from './index.js';
+
+let {
+	extension = '',
+	isDir = false,
+	isOpen = false,
+	class: className = 'size-4'
+}: {
+	extension?: string;
+	isDir?: boolean;
+	isOpen?: boolean;
+	class?: string;
+} = $props();
+
+const info = $derived(getFileTypeInfo(extension, isDir));
+
+const ICON_MAP: Record<string, any> = {
+	Columns3: Columns3Icon,
+	Table: TableIcon,
+	Braces: BracesIcon,
+	Globe: GlobeIcon,
+	Zap: ZapIcon,
+	FileCode: FileCodeIcon,
+	FileText: FileTextIcon,
+	Image: ImageIcon,
+	Palette: PaletteIcon,
+	Film: FilmIcon,
+	Music: MusicIcon,
+	Archive: ArchiveIcon,
+	Map: MapIcon,
+	Layers: LayersIcon,
+	Database: DatabaseIcon,
+	DatabaseZap: DatabaseZapIcon,
+	Box: BoxIcon,
+	Terminal: TerminalIcon,
+	BookText: BookTextIcon,
+	Settings: SettingsIcon,
+	Paintbrush: PaintbrushIcon,
+	Folder: FolderIcon,
+	FolderOpen: FolderOpenIcon,
+	File: FileIcon
+};
+
+const Icon = $derived(
+	isDir ? (isOpen ? FolderOpenIcon : FolderIcon) : ICON_MAP[info.icon] || FileIcon
+);
+</script>
+
+<Icon class="{info.color} {className}" />

package/dist/file-icons/FileTypeIcon.svelte.d.ts

@@ -0,0 +1,9 @@
+type $$ComponentProps = {
+    extension?: string;
+    isDir?: boolean;
+    isOpen?: boolean;
+    class?: string;
+};
+declare const FileTypeIcon: import("svelte").Component<$$ComponentProps, {}, "">;
+type FileTypeIcon = ReturnType<typeof FileTypeIcon>;
+export default FileTypeIcon;

package/dist/file-icons/index.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Centralized file type detection module.
+ *
+ * Single source of truth for extension → icon, color, label, category,
+ * viewer, DuckDB read function, MIME type, and queryability.
+ *
+ * Used by: FileRow, FileTreeSidebar, ViewerRouter, TableViewer, WasmQueryEngine, etc.
+ */
+export type FileCategory = 'data' | 'geo' | 'code' | 'document' | 'config' | 'image' | 'video' | 'audio' | 'archive' | 'database' | '3d' | 'other';
+export type ViewerKind = 'table' | 'image' | 'video' | 'audio' | 'markdown' | 'code' | 'cog' | 'pmtiles' | 'flatgeobuf' | 'pdf' | '3d' | 'archive' | 'database' | 'zarr' | 'copc' | 'notebook' | 'raw';
+export type DuckDbReadFn = 'read_parquet' | 'read_csv' | 'read_json' | 'ST_Read';
+export interface FileTypeInfo {
+    /** Lucide icon name */
+    icon: string;
+    /** Tailwind color classes (light + dark) */
+    color: string;
+    /** Human-readable type label, e.g. "Apache Parquet" */
+    label: string;
+    /** High-level category */
+    category: FileCategory;
+    /** Which viewer component to use */
+    viewer: ViewerKind;
+    /** Whether this file can be queried with DuckDB */
+    queryable: boolean;
+    /** DuckDB read function (null if not queryable) */
+    duckdbReadFn: DuckDbReadFn | null;
+    /** MIME type */
+    mimeType: string;
+}
+declare const DEFAULT_INFO: FileTypeInfo;
+declare const FOLDER_INFO: FileTypeInfo;
+/**
+ * Returns full file type information for a given extension.
+ * Extension may be with or without leading dot: ".parquet" or "parquet".
+ */
+export declare function getFileTypeInfo(extension: string, isDir?: boolean): FileTypeInfo;
+/** Returns the DuckDB read function name for a file path. Falls back to read_parquet. */
+export declare function getDuckDbReadFn(pathOrExt: string): string;
+/**
+ * Returns a DuckDB FROM-clause expression for a file.
+ *
+ * For GeoJSON files the raw `read_json_auto` returns a single row with the
+ * FeatureCollection structure (`type`, `features`, `bbox`). This helper
+ * unnests the features array so each feature becomes its own row with
+ * property columns + a geometry column.
+ */
+export declare function buildDuckDbSource(pathOrExt: string, url: string): string;
+export declare function isCloudNativeFormat(pathOrExt: string): boolean;
+/** Returns the viewer kind for a given extension. */
+export declare function getViewerKind(extension: string): ViewerKind;
+/** Returns whether a file can be queried with DuckDB. */
+export declare function isQueryable(extension: string): boolean;
+/** Returns the MIME type for a file extension. */
+export declare function getMimeType(extension: string): string;
+/** Re-export folder info for components that need it directly. */
+export { FOLDER_INFO, DEFAULT_INFO };