triiiceratops 0.16.9 → 0.16.10

package/dist/components/OSDViewer.svelte

@@ -7,6 +7,7 @@
         MOBILE_DRAWER_FALLBACK,
         shouldUseMobileDrawerFallback,
     } from './osdDefaults';
+    import { resolveTileSources } from './osdTileSources';
     import { parseAnnotations } from '../utils/annotationAdapter';
     import { manifestsState } from '../state/manifests.svelte';
     import type { ViewerState } from '../state/viewer.svelte';
@@ -21,9 +22,6 @@
     let viewer: any | undefined = $state.raw();
     let OSD: any | undefined = $state();
 
-    const IIIF_LEVEL0_V2_HTTPS = 'https://iiif.io/api/image/2/level0.json';
-    const IIIF_LEVEL0_V2_HTTP = 'http://iiif.io/api/image/2/level0.json';
-
     // Track OSD state changes for reactivity
     let osdVersion = $state(0);
     // Track last opened tile source to prevent unnecessary resets
@@ -178,7 +176,6 @@
             if (!mounted) return;
 
             OSD = osdModule.default || osdModule;
-            patchIiifLevel0ProfileCompatibility(OSD);
             const userAgent = navigator.userAgent || '';
             const consumerOverrides = viewerState.config?.openSeadragonConfig ?? {};
 
@@ -220,8 +217,8 @@
                 const overrides = viewerState.config?.openSeadragonConfig ?? {};
                 if (overrides.minZoomLevel !== undefined) return;
 
-                // Prevent zooming into the "no tiles rendered" range seen on
-                // some level-0 services when zoomed far past home view.
+                // Keep a conservative floor below home zoom to avoid over-zoomed
+                // empty/unstable ranges while preserving normal navigation.
                 const homeZoom = viewer.viewport.getHomeZoom();
                 const floorFactor =
                     viewerState.viewingMode === 'continuous' ? 0.8 : 0.95;
@@ -278,132 +275,6 @@
         }
     });
 
-    function normalizeIiifLevel0Profile<T>(source: T): T {
-        if (!source || typeof source !== 'object') return source;
-
-        const obj = source as any;
-        const profile = obj.profile;
-        const getProfileHead = (p: any): string | null => {
-            if (typeof p === 'string') return p;
-            if (Array.isArray(p) && typeof p[0] === 'string') return p[0];
-            return null;
-        };
-        const profileHead = getProfileHead(profile);
-        const isLevel0 =
-            profileHead === 'level0' ||
-            profileHead === IIIF_LEVEL0_V2_HTTPS ||
-            profileHead === IIIF_LEVEL0_V2_HTTP ||
-            (typeof profileHead === 'string' &&
-                (profileHead.endsWith('/level0.json') ||
-                    profileHead.endsWith('#level0')));
-
-        // Keep this minimal and conservative: OSD 5 misses the https v2 profile
-        // variant in some paths, so normalize only that string form.
-        if (typeof profile === 'string' && profile === IIIF_LEVEL0_V2_HTTPS) {
-            obj.profile = IIIF_LEVEL0_V2_HTTP;
-        } else if (Array.isArray(profile) && profile.length > 0) {
-            const first = profile[0];
-            if (typeof first === 'string' && first === IIIF_LEVEL0_V2_HTTPS) {
-                obj.profile = [IIIF_LEVEL0_V2_HTTP, ...profile.slice(1)];
-            }
-        }
-
-        // Some level-0 services advertise `tiles`, but 1x1 tile levels produce
-        // `/full/w,h/...` requests that 404. Keep only scale factors that still
-        // require at least 2 tiles in one dimension.
-        if (
-            isLevel0 &&
-            Array.isArray(obj.tiles) &&
-            obj.tiles.length > 0 &&
-            typeof obj.width === 'number' &&
-            typeof obj.height === 'number'
-        ) {
-            obj.tiles = obj.tiles.map((tile: any) => {
-                if (!Array.isArray(tile?.scaleFactors)) return tile;
-                const tileW =
-                    typeof tile.width === 'number' ? tile.width : 0;
-                const tileH =
-                    typeof tile.height === 'number' ? tile.height : tileW;
-                if (!tileW || !tileH) return tile;
-
-                const filtered = tile.scaleFactors.filter((sf: any) => {
-                    if (typeof sf !== 'number' || sf <= 0) return false;
-                    const levelW = Math.ceil(obj.width / sf);
-                    const levelH = Math.ceil(obj.height / sf);
-                    const tilesX = Math.ceil(levelW / tileW);
-                    const tilesY = Math.ceil(levelH / tileH);
-                    return tilesX > 1 || tilesY > 1;
-                });
-
-                // If everything is filtered out, keep original to avoid breaking source.
-                if (!filtered.length) return tile;
-                return { ...tile, scaleFactors: filtered };
-            });
-        }
-
-        return source;
-    }
-
-    function patchIiifLevel0ProfileCompatibility(osd: any) {
-        if (
-            !osd?.IIIFTileSource?.prototype ||
-            osd.__triiiceratopsIiifLevel0Patched
-        )
-            return;
-
-        const proto = osd.IIIFTileSource.prototype;
-        const originalConfigure = proto.configure;
-        if (typeof originalConfigure !== 'function') return;
-
-        proto.configure = function (data: any, url: string, postData: any) {
-            const configured = originalConfigure.call(this, data, url, postData);
-            return normalizeIiifLevel0Profile(configured);
-        };
-
-        osd.__triiiceratopsIiifLevel0Patched = true;
-    }
-
-    // Pre-fetch info.json URLs to detect 401 auth errors before passing to OSD
-    async function resolveTileSources(
-        sources: any[],
-    ): Promise<
-        | { ok: true; resolved: any[] }
-        | { ok: false; error: { type: 'auth' } }
-    > {
-        const resolved = await Promise.all(
-            sources.map(async (source) => {
-                // Only probe string sources (info.json URLs); preserve string tile
-                // sources so OSD follows its normal source-loading path.
-                if (typeof source !== 'string')
-                    return normalizeIiifLevel0Profile(source);
-                try {
-                    const response = await fetch(source);
-                    if (response.status === 401) {
-                        return { __authError: true };
-                    }
-                    if (response.ok) {
-                        try {
-                            normalizeIiifLevel0Profile(await response.json());
-                        } catch {
-                            // Not JSON or malformed response; let OSD handle source URL.
-                        }
-                    }
-                    return source;
-                } catch {
-                    // Network errors: pass through and let OSD handle it
-                    return source;
-                }
-            }),
-        );
-
-        // Check if any source had an auth error
-        if (resolved.some((r) => r && r.__authError)) {
-            return { ok: false, error: { type: 'auth' } };
-        }
-
-        return { ok: true, resolved };
-    }
-
     // Load tile source when it changes
     $effect(() => {
         if (!viewer) return;
@@ -467,7 +338,14 @@
                 viewer.minZoomImageRatio = DEFAULT_MIN_ZOOM_IMAGE_RATIO;
             }
 
-            resolveTileSources(sources).then((result) => {
+            resolveTileSources({
+                sources,
+                osd: OSD,
+                viewport: {
+                    width: container?.clientWidth ?? 0,
+                    height: container?.clientHeight ?? 0,
+                },
+            }).then((result) => {
                 // Staleness guard: if tile sources changed while we were fetching, discard
                 if (capturedKey !== lastTileSourceStr) return;
 
@@ -542,9 +420,8 @@
                             (batchIdx + 1) * BATCH_SIZE,
                         );
                         if (batch.length === 0) {
-                            // Keep a modest margin below home zoom, but avoid the
-                            // extreme zoom-out range where some level-0 services
-                            // trigger invalid tile URLs.
+                            // Keep a modest margin below home zoom in continuous
+                            // mode to reduce empty over-zoom edge cases.
                             if (overrides.minZoomLevel === undefined) {
                                 viewer.viewport.minZoomLevel =
                                     viewer.viewport.getHomeZoom() * 0.8;
@@ -585,62 +462,59 @@
             viewer.minZoomImageRatio = DEFAULT_MIN_ZOOM_IMAGE_RATIO;
         }
 
-        const immediateSources = sources.map((source) =>
-            typeof source === 'string'
-                ? source
-                : normalizeIiifLevel0Profile(source),
-        );
-
-        // Open immediately for perceived responsiveness.
-        if (mode === 'paged' && immediateSources.length === 2) {
-            const gap = 0.025;
-            const offset = 1 + gap;
-
-            // Two pages.
-            // If LTR: [0] at 0, [1] at 1.025
-            // If RTL: [0] at 1.025, [1] at 0
-            const firstX = isPagedRTL ? offset : 0;
-            const secondX = isPagedRTL ? 0 : offset;
-
-            const spread = [
-                {
-                    tileSource: immediateSources[0],
-                    x: firstX,
-                    y: 0,
-                    width: 1.0,
-                },
-                {
-                    tileSource: immediateSources[1],
-                    x: secondX,
-                    y: 0,
-                    width: 1.0,
-                },
-            ];
-            viewer.open(spread);
-        } else {
-            // Individuals or single paged or fallback
-            viewer.open(
-                immediateSources.length === 1
-                    ? immediateSources[0]
-                    : immediateSources,
-            );
-        }
-
-        // Pre-fetch info.json URLs in the background to detect auth errors
-        // without delaying image display.
-        resolveTileSources(sources).then((result) => {
+        resolveTileSources({
+            sources,
+            osd: OSD,
+            viewport: {
+                width: container?.clientWidth ?? 0,
+                height: container?.clientHeight ?? 0,
+            },
+        }).then((result) => {
             // Staleness guard: if tile sources changed while we were fetching, discard
             if (capturedKey !== lastTileSourceStr) return;
 
             if (!result.ok) {
                 viewerState.tileSourceError = result.error;
-                // Clear stale tiles from the previous canvas
                 viewer.close();
                 return;
             }
 
-            // Clear any previous error
             viewerState.tileSourceError = null;
+            const resolvedSources = result.resolved;
+
+            if (mode === 'paged' && resolvedSources.length === 2) {
+                const gap = 0.025;
+                const offset = 1 + gap;
+
+                // Two pages.
+                // If LTR: [0] at 0, [1] at 1.025
+                // If RTL: [0] at 1.025, [1] at 0
+                const firstX = isPagedRTL ? offset : 0;
+                const secondX = isPagedRTL ? 0 : offset;
+
+                const spread = [
+                    {
+                        tileSource: resolvedSources[0],
+                        x: firstX,
+                        y: 0,
+                        width: 1.0,
+                    },
+                    {
+                        tileSource: resolvedSources[1],
+                        x: secondX,
+                        y: 0,
+                        width: 1.0,
+                    },
+                ];
+                viewer.open(spread);
+            } else {
+                // Individuals or single paged or fallback
+                viewer.open(
+                    resolvedSources.length === 1
+                        ? resolvedSources[0]
+                        : resolvedSources,
+                );
+            }
         });
     });
 

package/dist/components/osdTileSources.d.ts

@@ -0,0 +1,19 @@
+export type TileSourceResolutionResult = {
+    ok: true;
+    resolved: any[];
+} | {
+    ok: false;
+    error: {
+        type: 'auth';
+    };
+};
+type ResolveTileSourcesParams = {
+    sources: any[];
+    osd?: any;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+};
+export declare function resolveTileSources(params: ResolveTileSourcesParams): Promise<TileSourceResolutionResult>;
+export {};

package/dist/components/osdTileSources.js

@@ -0,0 +1,206 @@
+function isAuthErrorMarker(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        '__authError' in value &&
+        value.__authError === true);
+}
+function getProfileHead(profile) {
+    if (typeof profile === 'string')
+        return profile;
+    if (Array.isArray(profile) && typeof profile[0] === 'string') {
+        return profile[0];
+    }
+    return null;
+}
+function isIiifLevel0Profile(profile) {
+    const profileHead = getProfileHead(profile);
+    if (!profileHead)
+        return false;
+    return (profileHead === 'level0' ||
+        profileHead.endsWith('/level0.json') ||
+        profileHead.endsWith('#level0'));
+}
+function createIiifTileSource(osd, data, url, viewport) {
+    if (!osd?.IIIFTileSource?.prototype)
+        return data;
+    try {
+        const configured = osd.IIIFTileSource.prototype.configure.call({}, data, url, null);
+        const tileSource = new osd.IIIFTileSource(configured);
+        applyLevel0LowZoomFullImageStrategy(tileSource, viewport);
+        return tileSource;
+    }
+    catch {
+        return data;
+    }
+}
+function applyLevel0LowZoomFullImageStrategy(tileSource, viewport) {
+    if (!isIiifLevel0Profile(tileSource?.profile))
+        return;
+    if (typeof tileSource?.getTileUrl !== 'function')
+        return;
+    if (tileSource.__triiiceratopsLevel0LowZoomPrepared)
+        return;
+    const originalGetTileUrl = tileSource.getTileUrl.bind(tileSource);
+    const originalGetNumTiles = typeof tileSource.getNumTiles === 'function'
+        ? tileSource.getNumTiles.bind(tileSource)
+        : null;
+    const fitMaxLevel = getFitMaxLevel(tileSource, viewport);
+    const advertisedScaleFactors = getAdvertisedScaleFactors(tileSource);
+    const tiledOnlyMinLevel = getTiledOnlyMinLevel(tileSource, advertisedScaleFactors, originalGetNumTiles);
+    if (originalGetNumTiles) {
+        tileSource.getNumTiles = function (level) {
+            if (shouldHideLevel(level, tiledOnlyMinLevel, advertisedScaleFactors, this)) {
+                return { x: 0, y: 0 };
+            }
+            if (isFullImageLevel(this, level, fitMaxLevel, advertisedScaleFactors, originalGetNumTiles, tiledOnlyMinLevel)) {
+                return { x: 1, y: 1 };
+            }
+            return originalGetNumTiles(level);
+        };
+    }
+    if (typeof tileSource?.minLevel === 'number' && tiledOnlyMinLevel >= 0) {
+        tileSource.minLevel = Math.max(tileSource.minLevel, tiledOnlyMinLevel);
+    }
+    tileSource.getTileUrl = function (level, x, y) {
+        if (shouldHideLevel(level, tiledOnlyMinLevel, advertisedScaleFactors, this)) {
+            const safeLevel = tiledOnlyMinLevel >= 0 ? tiledOnlyMinLevel : level;
+            return originalGetTileUrl(safeLevel, x, y);
+        }
+        if (isFullImageLevel(this, level, fitMaxLevel, advertisedScaleFactors, originalGetNumTiles, tiledOnlyMinLevel)) {
+            return getFullImageUrlForLevel(this, level);
+        }
+        return originalGetTileUrl(level, x, y);
+    };
+    tileSource.__triiiceratopsLevel0LowZoomPrepared = true;
+}
+function isFullImageLevel(tileSource, level, fitMaxLevel, advertisedScaleFactors, getNumTilesBase, tiledOnlyMinLevel) {
+    if (tiledOnlyMinLevel >= 0)
+        return false;
+    if (fitMaxLevel >= 0 && level <= fitMaxLevel)
+        return true;
+    if (!isAdvertisedTileLevel(tileSource, level, advertisedScaleFactors)) {
+        return true;
+    }
+    if (!getNumTilesBase)
+        return false;
+    const numTiles = getNumTilesBase(level);
+    return numTiles?.x === 1 && numTiles?.y === 1;
+}
+function getTiledOnlyMinLevel(tileSource, advertisedScaleFactors, getNumTilesBase) {
+    if (!getNumTilesBase)
+        return -1;
+    if (typeof tileSource?.minLevel !== 'number' ||
+        typeof tileSource?.maxLevel !== 'number')
+        return -1;
+    if (advertisedScaleFactors.size === 0)
+        return -1;
+    for (let level = tileSource.minLevel; level <= tileSource.maxLevel; level++) {
+        if (!isAdvertisedTileLevel(tileSource, level, advertisedScaleFactors)) {
+            continue;
+        }
+        const tiles = getNumTilesBase(level);
+        if (tiles?.x > 1 || tiles?.y > 1) {
+            return level;
+        }
+    }
+    return -1;
+}
+function shouldHideLevel(level, tiledOnlyMinLevel, advertisedScaleFactors, tileSource) {
+    if (tiledOnlyMinLevel < 0)
+        return false;
+    if (level < tiledOnlyMinLevel)
+        return true;
+    return !isAdvertisedTileLevel(tileSource, level, advertisedScaleFactors);
+}
+function getAdvertisedScaleFactors(tileSource) {
+    const result = new Set();
+    const factors = tileSource?.scale_factors;
+    if (Array.isArray(factors)) {
+        for (const value of factors) {
+            if (typeof value === 'number' && value > 0)
+                result.add(value);
+        }
+    }
+    return result;
+}
+function isAdvertisedTileLevel(tileSource, level, advertisedScaleFactors) {
+    if (advertisedScaleFactors.size === 0)
+        return true;
+    if (typeof tileSource?.maxLevel !== 'number' ||
+        typeof level !== 'number') {
+        return true;
+    }
+    const scaleFactor = Math.pow(2, tileSource.maxLevel - level);
+    return advertisedScaleFactors.has(scaleFactor);
+}
+function getFitMaxLevel(tileSource, viewport) {
+    if (!viewport || viewport.width <= 0 || viewport.height <= 0)
+        return -1;
+    if (typeof tileSource?.minLevel !== 'number' ||
+        typeof tileSource?.maxLevel !== 'number' ||
+        typeof tileSource?.getLevelScale !== 'function' ||
+        typeof tileSource?.width !== 'number' ||
+        typeof tileSource?.height !== 'number')
+        return -1;
+    let fitMaxLevel = -1;
+    for (let level = tileSource.minLevel; level <= tileSource.maxLevel; level++) {
+        const scale = tileSource.getLevelScale(level);
+        const levelWidth = Math.ceil(tileSource.width * scale);
+        const levelHeight = Math.ceil(tileSource.height * scale);
+        if (levelWidth <= viewport.width && levelHeight <= viewport.height) {
+            fitMaxLevel = level;
+        }
+    }
+    return fitMaxLevel;
+}
+function getFullImageUrlForLevel(tileSource, level) {
+    const scale = tileSource.getLevelScale(level);
+    const levelWidth = Math.ceil(tileSource.width * scale);
+    const levelHeight = Math.ceil(tileSource.height * scale);
+    const isVersion3 = tileSource.version === 3;
+    const isLevel0 = isIiifLevel0Profile(tileSource?.profile);
+    const size = isVersion3
+        ? levelWidth === tileSource.width && levelHeight === tileSource.height
+            ? 'max'
+            : isLevel0
+                ? `${levelWidth},`
+                : `${levelWidth},${levelHeight}`
+        : levelWidth === tileSource.width
+            ? 'full'
+            : `${levelWidth},`;
+    const quality = isVersion3 ? 'default' : 'native';
+    return `${tileSource._id}/full/${size}/0/${quality}.${tileSource.tileFormat}`;
+}
+// Fetch string info.json URLs once to detect auth errors and build prepared
+// sources for OSD. Non-string tile sources are passed through unchanged.
+export async function resolveTileSources(params) {
+    const { sources, osd, viewport } = params;
+    const resolved = await Promise.all(sources.map(async (source) => {
+        if (typeof source !== 'string')
+            return source;
+        try {
+            const response = await fetch(source);
+            if (response.status === 401) {
+                return { __authError: true };
+            }
+            if (!response.ok)
+                return source;
+            let data = null;
+            try {
+                data = await response.json();
+            }
+            catch {
+                return source;
+            }
+            return createIiifTileSource(osd, data, source, viewport);
+        }
+        catch {
+            // Network errors: pass through and let OSD handle it.
+            return source;
+        }
+    }));
+    if (resolved.some(isAuthErrorMarker)) {
+        return { ok: false, error: { type: 'auth' } };
+    }
+    return { ok: true, resolved };
+}

package/dist/components/osdTileSources.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/osdTileSources.test.js

@@ -0,0 +1,161 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { resolveTileSources } from './osdTileSources';
+class FakeIIIFTileSource {
+    width;
+    height;
+    _id;
+    version;
+    tileFormat;
+    profile;
+    scale_factors;
+    minLevel = 0;
+    maxLevel = 2;
+    __triiiceratopsLevel0LowZoomPrepared;
+    constructor(options) {
+        this.width = options.width;
+        this.height = options.height;
+        this._id = options._id || options.id || options['@id'];
+        this.version = options.version ?? 3;
+        this.tileFormat = options.tileFormat ?? 'jpg';
+        this.profile = options.profile;
+        this.scale_factors = options.scale_factors ?? [1, 2, 4];
+    }
+    configure(data, url) {
+        return {
+            ...data,
+            _id: data._id || data.id || data['@id'] || url.replace('/info.json', ''),
+            width: data.width ?? 4000,
+            height: data.height ?? 3000,
+            version: data.version ?? 3,
+            tileFormat: data.tileFormat ?? 'jpg',
+        };
+    }
+    getTileUrl(level, x, y) {
+        return `tile/${level}/${x}/${y}`;
+    }
+    getLevelScale(level) {
+        return [0.25, 0.5, 1][level] ?? 1;
+    }
+    getNumTiles(level) {
+        if (level <= 1)
+            return { x: 1, y: 1 };
+        return { x: 2, y: 2 };
+    }
+}
+describe('resolveTileSources', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('passes through non-string sources unchanged', async () => {
+        const objectSource = {
+            '@context': 'http://iiif.io/api/image/2/context.json',
+            profile: 'https://iiif.io/api/image/2/level0.json',
+        };
+        const result = await resolveTileSources({ sources: [objectSource] });
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.resolved[0]).toBe(objectSource);
+            expect(result.resolved[0].profile).toBe('https://iiif.io/api/image/2/level0.json');
+        }
+    });
+    it('fetches info.json once and returns parsed source for non-401 responses', async () => {
+        const fetchSpy = vi
+            .spyOn(globalThis, 'fetch')
+            .mockResolvedValue({
+            status: 200,
+            ok: true,
+            json: async () => ({ width: 1000, height: 800 }),
+        });
+        const source = 'https://example.org/iiif/image/info.json';
+        const result = await resolveTileSources({ sources: [source] });
+        expect(fetchSpy).toHaveBeenCalledWith(source);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.resolved[0]).toEqual({ width: 1000, height: 800 });
+        }
+    });
+    it('returns auth error when any string source responds with 401', async () => {
+        vi.spyOn(globalThis, 'fetch').mockImplementation(async (input) => {
+            const url = String(input);
+            const isProtected = url.includes('protected');
+            return {
+                status: isProtected ? 401 : 200,
+                ok: !isProtected,
+                json: async () => ({ width: 1000, height: 800 }),
+            };
+        });
+        const result = await resolveTileSources({
+            sources: [
+                'https://example.org/public/info.json',
+                'https://example.org/protected/info.json',
+            ],
+        });
+        expect(result).toEqual({ ok: false, error: { type: 'auth' } });
+    });
+    it('hides low single-tile levels and preserves tiled zoom-in for level-0', async () => {
+        vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+            status: 200,
+            ok: true,
+            json: async () => ({
+                '@context': 'http://iiif.io/api/image/3/context.json',
+                id: 'https://example.org/iiif/image',
+                width: 4000,
+                height: 3000,
+                version: 3,
+                profile: 'https://iiif.io/api/image/3/level0.json',
+                scale_factors: [1, 2, 4],
+            }),
+        });
+        const osd = { IIIFTileSource: FakeIIIFTileSource };
+        const result = await resolveTileSources({
+            sources: ['https://example.org/iiif/image/info.json'],
+            osd,
+            viewport: { width: 1200, height: 900 },
+        });
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            const source = result.resolved[0];
+            expect(source.minLevel).toBe(2);
+            expect(source.getNumTiles(0)).toEqual({ x: 0, y: 0 });
+            expect(source.getNumTiles(1)).toEqual({ x: 0, y: 0 });
+            expect(source.getNumTiles(2)).toEqual({ x: 2, y: 2 });
+            expect(source.getTileUrl(2, 1, 0)).toBe('tile/2/1/0');
+        }
+    });
+    it('forces full-image requests for unadvertised scale-factor levels', async () => {
+        vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+            status: 200,
+            ok: true,
+            json: async () => ({
+                '@context': 'http://iiif.io/api/image/3/context.json',
+                id: 'https://example.org/iiif/image',
+                width: 4000,
+                height: 3000,
+                version: 3,
+                profile: 'https://iiif.io/api/image/3/level0.json',
+                // level scale factors for maxLevel=2 are [4,2,1]; omit 2.
+                scale_factors: [1, 4],
+            }),
+        });
+        const osd = { IIIFTileSource: FakeIIIFTileSource };
+        const result = await resolveTileSources({
+            sources: ['https://example.org/iiif/image/info.json'],
+            osd,
+            viewport: { width: 500, height: 500 },
+        });
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            const source = result.resolved[0];
+            expect(source.getNumTiles(1)).toEqual({ x: 0, y: 0 });
+            expect(source.getTileUrl(1, 0, 0)).toBe('tile/2/0/0');
+            // Highest level is still advertised and remains tiled.
+            expect(source.getTileUrl(2, 1, 0)).toBe('tile/2/1/0');
+        }
+    });
+    it('passes through string sources on fetch/network failure', async () => {
+        vi.spyOn(globalThis, 'fetch').mockRejectedValue(new Error('network'));
+        const source = 'https://example.org/iiif/image/info.json';
+        const result = await resolveTileSources({ sources: [source] });
+        expect(result).toEqual({ ok: true, resolved: [source] });
+    });
+});