incyclist-services 1.8.0 → 1.8.2

package/lib/cjs/routes/library/service.js

@@ -44,6 +44,7 @@ const types_1 = require("../../base/types");
 const parsers_1 = require("../base/parsers");
 const service_2 = require("../list/service");
 const utils_1 = require("../../utils");
+const errors_1 = require("./errors");
 const db_1 = require("../list/loaders/db");
 const route_1 = require("../base/model/route");
 const sleep_1 = require("../../utils/sleep");
@@ -51,7 +52,11 @@ const i18n_1 = require("../../i18n");
 const utils_2 = require("../base/parsers/utils");
 const externalFiles_1 = require("../../fileaccess/externalFiles");
 const store_1 = require("../previews/store");
+const store_2 = require("../shapes/store");
 const WAITING_FOR_ICLOUD_THRESHOLD_MS = 2_000;
+const VIDEO_EXTENSIONS = ['mp4', 'avi', 'mov', 'm4v', 'mkv', 'webm', 'mpg', 'mpeg', 'wmv'];
+const PATH_SEPARATOR = /[/\\]/;
+const UNREADABLE_FOLDER_ERRORS = /\b(EACCES|EPERM|EIO|EBUSY|EAGAIN|ETIMEDOUT|ESTALE|EMFILE|ENFILE|EHOSTDOWN|EHOSTUNREACH|ENETDOWN|ENETUNREACH|ECONNRESET|ECONNABORTED)\b/;
 let RouteLibraryScannerService = (() => {
     let _classDecorators = [decorators_1.Singleton];
     let _classDescriptor;
@@ -63,6 +68,7 @@ let RouteLibraryScannerService = (() => {
     let _getBindings_decorators;
     let _getRoutesDBLoader_decorators;
     let _getPreviewStore_decorators;
+    let _getRouteShapeStore_decorators;
     let _getParsers_decorators;
     let _getUnitConverter_decorators;
     var RouteLibraryScannerService = class extends _classSuper {
@@ -73,12 +79,14 @@ let RouteLibraryScannerService = (() => {
             _getBindings_decorators = [decorators_1.Injectable];
             _getRoutesDBLoader_decorators = [decorators_1.Injectable];
             _getPreviewStore_decorators = [decorators_1.Injectable];
+            _getRouteShapeStore_decorators = [decorators_1.Injectable];
             _getParsers_decorators = [decorators_1.Injectable];
             _getUnitConverter_decorators = [decorators_1.Injectable];
             __esDecorate(this, null, _getRouteList_decorators, { kind: "method", name: "getRouteList", static: false, private: false, access: { has: obj => "getRouteList" in obj, get: obj => obj.getRouteList }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getBindings_decorators, { kind: "method", name: "getBindings", static: false, private: false, access: { has: obj => "getBindings" in obj, get: obj => obj.getBindings }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getRoutesDBLoader_decorators, { kind: "method", name: "getRoutesDBLoader", static: false, private: false, access: { has: obj => "getRoutesDBLoader" in obj, get: obj => obj.getRoutesDBLoader }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getPreviewStore_decorators, { kind: "method", name: "getPreviewStore", static: false, private: false, access: { has: obj => "getPreviewStore" in obj, get: obj => obj.getPreviewStore }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getRouteShapeStore_decorators, { kind: "method", name: "getRouteShapeStore", static: false, private: false, access: { has: obj => "getRouteShapeStore" in obj, get: obj => obj.getRouteShapeStore }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getParsers_decorators, { kind: "method", name: "getParsers", static: false, private: false, access: { has: obj => "getParsers" in obj, get: obj => obj.getParsers }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getUnitConverter_decorators, { kind: "method", name: "getUnitConverter", static: false, private: false, access: { has: obj => "getUnitConverter" in obj, get: obj => obj.getUnitConverter }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
@@ -118,35 +126,89 @@ let RouteLibraryScannerService = (() => {
         importSingle(fileInfo) {
             const observer = new types_1.Observer();
             this.isCancelled = false;
-            this.importRoute(fileInfo, observer).catch(err => {
+            if (!this.importProps)
+                this.prepare();
+            const session = this.importProps;
+            delete session.error;
+            delete session.failure;
+            delete session.resultSuccess;
+            this.importRoute(fileInfo, observer, session).catch(err => {
                 this.logError(err, 'importSingle', { file: fileInfo?.filename });
                 observer.emit('error', err.message);
             });
             observer.on('success', (route) => {
-                if (!this.importProps)
+                if (this.importProps !== session)
+                    return;
+                session.phase = 'result';
+                session.resultSuccess = { routeName: route.title };
+            });
+            observer.on('error', (error, failure) => {
+                if (this.importProps !== session)
                     return;
-                this.importProps.phase = 'result';
-                this.importProps.resultSuccess = { routeName: route.title };
+                session.phase = 'result';
+                session.error = error;
+                session.failure = failure;
+            });
+            return observer;
+        }
+        importFiles(files) {
+            const observer = new types_1.Observer();
+            this.isCancelled = false;
+            if (!this.importProps)
+                this.prepare();
+            this.importProps.phase = 'ingesting';
+            const list = this.getRouteList();
+            list.pauseListUpdates();
+            this._importFiles(files ?? [], observer)
+                .catch(err => {
+                this.logError(err, 'importFiles');
+                observer.emit('error', err.message);
+            })
+                .finally(() => {
+                list.resumeListUpdates();
+                list.emitLists('updated', { source: 'system' });
             });
-            observer.on('error', (error) => {
+            observer.on('ingest-progress', (progress) => {
+                if (this.importProps)
+                    this.importProps.ingestProgress = progress;
+            });
+            observer.on('ingest-complete', (status) => {
                 if (!this.importProps)
                     return;
-                this.importProps.phase = 'result';
-                this.importProps.error = error;
+                const { imported, skipped, errors, failedRoutes } = status;
+                this.importProps.phase = 'complete';
+                this.importProps.completionSummary = { imported, skipped, errors, failedRoutes };
             });
             return observer;
         }
+        async importRouteFile(fileInfo, props) {
+            const name = fileInfo?.url ?? fileInfo?.filename ?? fileInfo?.name;
+            this.logEvent({ message: 'import single route file', file: name, type: fileInfo?.ext });
+            try {
+                const route = await this.parseRouteFile(fileInfo, props?.isCancelled);
+                this.logEvent({ message: 'import single route file success', file: name });
+                const list = props?.list ?? this.getRouteList();
+                const existing = list.findCard(route) ?? null;
+                await this.ingestOne(route, existing, list, this.getRoutesDBLoader());
+                return route;
+            }
+            catch (err) {
+                const error = (0, errors_1.toRouteImportError)(err);
+                this.logEvent({ message: 'import single route file failed', file: name, reason: error.message, code: error.code, stack: err?.stack });
+                throw error;
+            }
+        }
         scan(folderInfo) {
             if (!this.importProps)
                 this.prepare();
-            this.logEvent({ message: 'import route library', folder: folderInfo.displayName, uri: folderInfo.uri });
+            this.logEvent({ message: 'import route library', folder: folderInfo.displayName });
             this.isCancelled = false;
             this.scanResult = [];
             this.importProps.phase = 'scanning';
-            this.importProps.scanProgress = { scannedFolders: 0 };
+            this.importProps.scanProgress = { scannedFolders: 0, failedFolders: 0 };
             const observer = new types_1.Observer();
             this._scan(folderInfo, observer).catch(err => {
-                this.logError(err, 'scan', { uri: folderInfo.uri });
+                this.logError(err, 'scan', { folder: folderInfo.displayName });
                 observer.emit('error', err.message);
             });
             observer
@@ -154,8 +216,8 @@ let RouteLibraryScannerService = (() => {
                 this.importProps.scanProgress = progress;
             })
                 .on('scan-complete', () => {
-                const cntScanned = this.importProps.scanProgress.scannedFolders;
-                this.logEvent({ message: 'import route library: scan success', folder: folderInfo.displayName, cntScanned });
+                const { scannedFolders: cntScanned, failedFolders: cntFailed } = this.importProps.scanProgress;
+                this.logEvent({ message: 'import route library: scan success', folder: folderInfo.displayName, cntScanned, cntFailed });
                 this.importProps.phase = 'parsing';
             });
             return observer;
@@ -228,189 +290,307 @@ let RouteLibraryScannerService = (() => {
             this.done();
             this.prepare();
         }
-        async importRoute(fileInfo, observer) {
+        async importRoute(fileInfo, observer, session) {
             await (0, sleep_1.sleep)(0);
-            observer.emit('parsing');
-            if (!this.importProps)
+            const isStale = () => this.importProps !== session;
+            if (isStale())
                 return;
-            this.importProps.phase = 'parsing';
-            if (fileInfo?.ext === 'gpx') {
-                return this.importSingleGpxRoute(fileInfo, observer);
+            session.phase = 'parsing';
+            observer.emit('parsing');
+            const isCancelled = () => this.isCancelled || isStale();
+            try {
+                const route = await this.importRouteFile(fileInfo, { isCancelled });
+                if (!isCancelled())
+                    observer.emit('success', route);
             }
-            else {
-                return this.importSingleVideoRoute(fileInfo, observer);
+            catch (err) {
+                const error = (0, errors_1.toRouteImportError)(err);
+                if (!isCancelled())
+                    observer.emit('error', error.message, error.toFailure());
             }
         }
-        async importSingleGpxRoute(fileInfo, observer) {
-            const name = fileInfo.url ?? fileInfo.filename ?? fileInfo.name;
-            this.logEvent({ message: 'import single route file', file: name, type: fileInfo.ext });
-            const service = this.getRouteList();
-            const db = this.getRoutesDBLoader();
-            try {
-                const { data, details } = await parsers_1.RouteParser.parse(fileInfo);
-                const route = new route_1.Route(data, details);
-                this.logEvent({ message: 'import single route file success', file: name });
-                const existing = service.findCard(route);
-                if (existing) {
-                    this.logEvent({ message: 'route updated (import)', route: route.title });
+        async _importFiles(files, observer) {
+            await (0, utils_1.waitNextTick)();
+            const targets = files.filter(f => !!f);
+            const total = targets.length;
+            const failedRoutes = [];
+            const importedRoutes = [];
+            const isCancelled = () => this.isCancelled;
+            for (let i = 0; i < total; i++) {
+                if (isCancelled())
+                    continue;
+                const file = targets[i];
+                const name = file.name ?? file.base ?? file.filename ?? file.url;
+                observer.emit('ingest-progress', { current: i + 1, total, currentName: name });
+                try {
+                    importedRoutes.push(await this.importRouteFile(file, { isCancelled }));
                 }
-                route.description.tsImported = Date.now();
-                await db.save(route, true);
-                service.addRoute(route, existing ? 'import' : 'user');
-                const cardInfo = service.findCard(route);
-                cardInfo?.card?.verify();
-                if (existing) {
-                    existing.card.emitUpdate();
+                catch (err) {
+                    const error = (0, errors_1.toRouteImportError)(err);
+                    failedRoutes.push({ name, reason: error.message, code: error.code, missingExt: error.missingExt });
+                    observer.emit('ingest-error', { name, reason: error.message });
                 }
-                observer.emit('success', route);
-            }
-            catch (err) {
-                this.logEvent({ message: 'import single route file failed', file: name, reason: err.message, stack: err.stack });
-                observer.emit('error', err.message);
             }
+            observer.emit('ingest-complete', { imported: importedRoutes.length, skipped: 0, errors: failedRoutes.length, failedRoutes, importedRoutes });
         }
-        async importSingleVideoRoute(fileInfo, observer) {
-            const name = fileInfo.url ?? fileInfo.filename ?? fileInfo.name;
-            this.logEvent({ message: 'import single route file', file: name, type: fileInfo.ext });
+        async parseRouteFile(fileInfo, isCancelled) {
+            const ext = (fileInfo?.ext ?? '').replace(/^\./, '').toLowerCase();
+            if (ext === 'gpx' || !fileInfo?.dir) {
+                const { data, details } = await parsers_1.RouteParser.parse(fileInfo);
+                return new route_1.Route(data, details);
+            }
             const parsers = this.getParsers();
-            const { dir, delimiter } = fileInfo;
-            let { ext } = fileInfo;
-            if (ext.startsWith('.'))
-                ext = ext.slice(1);
-            const folderUri = dir.endsWith(delimiter ?? '/') ? dir.slice(0, -delimiter.length) : dir;
+            if (!parsers.isPrimaryExtension(ext))
+                throw new errors_1.RouteImportError('not a route control file', 'UNSUPPORTED');
+            const target = await this.locateRouteFile(fileInfo, ext, parsers);
+            return this.parseLocatedRoute(target, isCancelled);
+        }
+        async locateRouteFile(fileInfo, ext, parsers) {
+            const { dir } = fileInfo;
+            const delimiter = fileInfo.delimiter ?? '/';
+            const folderUri = dir.endsWith(delimiter) ? dir.slice(0, -delimiter.length) : dir;
+            let listing = null;
             try {
-                if (!parsers.isPrimaryExtension(ext)) {
-                    this.logEvent({ message: 'import single route file failed', file: name, reason: 'not a route control file' });
-                    observer.emit('error', 'not a route control file', ext);
-                    return;
-                }
-                const scanObserver = new types_1.Observer();
-                await this.scanFolder(folderUri, folderUri, scanObserver, parsers, { scannedFolders: 0 }, { value: 0 }, false);
-                const files = this.scanResult;
-                this.scanResult = [];
-                scanObserver.stop();
-                if (!files.length) {
-                    this.logEvent({ message: 'import single route file failed', file: name, reason: 'no file found' });
-                    observer.emit('error', 'no file found');
-                }
-                if (files[0].scanError) {
-                    this.logEvent({ message: 'import single route file failed', file: name, reason: files[0].scanError });
-                    observer.emit('error', files[0].scanError);
-                    return;
+                listing = await this.listEntries(folderUri);
+            }
+            catch (err) {
+                this.logError(err, 'locateRouteFile');
+            }
+            const files = (listing ?? [])
+                .filter(e => !e.isDirectory)
+                .map(e => e.unknownType ? { name: e.name, uri: e.uri, isDirectory: false } : e);
+            const base = fileInfo.base ?? fileInfo.name;
+            const controlFile = base ? (files.find(f => f.name === base) ?? files.find(f => f.uri?.includes(base))) : undefined;
+            if (!controlFile)
+                throw new errors_1.RouteImportError('no file found', 'READ_FAILED');
+            const baseName = this.getBaseName(controlFile.name);
+            const missingExt = this.findMissingCompanion(parsers, ext, baseName, files);
+            if (missingExt)
+                throw new errors_1.RouteImportError(`Missing companion file (.${missingExt})`, 'MISSING_COMPANION', { missingExt });
+            return {
+                folderUri,
+                folderName: folderUri,
+                files,
+                controlFileUri: controlFile.uri,
+                format: this.getExtension(controlFile.name)
+            };
+        }
+        async parseLocatedRoute(target, isCancelled) {
+            const file = this.buildFileInfo(target.controlFileUri, target.format);
+            const scope = (0, externalFiles_1.useExternalFileService)().beginScope({ isCancelled });
+            try {
+                let result;
+                try {
+                    result = await parsers_1.RouteParser.parse(file);
                 }
-                else {
-                    const file = files.find(file => file.controlFileUri.includes(fileInfo.base));
-                    const parseObserver = this.parse([file]);
-                    parseObserver.on('parse-result', (result) => {
-                        parseObserver.stop();
-                        if (result.parseError) {
-                            this.logEvent({ message: 'import single route file failed', file: name, reason: result.parseError });
-                            observer.emit('error', result.parseError);
-                            return;
-                        }
-                        const ingest = this.ingest([result]);
-                        let ingestError;
-                        ingest.once('ingest-error', (_, reason) => {
-                            ingest.stop();
-                            this.logEvent({ message: 'import single route file failed', file: name, reason });
-                            observer.emit('error', reason);
-                            ingestError = reason;
-                        });
-                        ingest.once('ingest-complete', (summary) => {
-                            ingest.stop();
-                            if (!ingestError && summary.imported > 0) {
-                                this.logEvent({ message: 'import single route file success', file: name });
-                                observer.emit('success', summary.importedRoutes?.[0]?.title);
-                            }
-                            else if (!ingestError && summary.imported === 0) {
-                                this.logEvent({ message: 'import single route file failed', file: name, reason: 'not imported' });
-                                observer.emit('error', 'not imported');
-                            }
-                        });
-                    });
+                finally {
+                    scope.end();
                 }
+                if (scope.lastFailure)
+                    throw new Error(this.getReadFailureMessage(scope));
+                const route = new route_1.Route(result.data, result.details);
+                if (result.data.hasVideo)
+                    this.validateVideoUrl(route, target.folderUri, target.files);
+                return route;
             }
             catch (err) {
-                this.logEvent({ message: 'import single route file failed', file: name, reason: err.message, stack: err.stack });
-                observer.emit('error', err.message);
+                throw (0, errors_1.toRouteImportError)(err, scope, scope.lastFailure ? this.getReadFailureMessage(scope) : undefined);
             }
         }
         async _scan(folderInfo, observer) {
             await (0, utils_1.waitNextTick)();
-            const parsers = this.getParsers();
-            const progress = { scannedFolders: 0 };
-            const discoveredCount = { value: 0 };
-            await this.scanFolder(folderInfo.uri, folderInfo.displayName, observer, parsers, progress, discoveredCount);
-            await this.upsertImportHistory(folderInfo, discoveredCount.value);
-            this.logEvent({ message: 'video scan result', scannedFolders: this.importProps.scanProgress.scannedFolders, files: this.scanResult.length });
+            const ctx = this.createScanContext(observer, this.getParsers(), true);
+            await this.scanFolder(folderInfo.uri, folderInfo.displayName, ctx);
+            await this.upsertImportHistory(folderInfo, ctx.discoveredCount.value);
+            const { scannedFolders, failedFolders } = ctx.progress;
+            this.logEvent({ message: 'video scan result', scannedFolders, failedFolders, files: this.scanResult.length });
             observer.emit('scan-complete', this.scanResult);
         }
-        async scanFolder(uri, folderName, observer, parsers, progress, discoveredCount, recursive = true) {
-            const fs = this.getBindings().fs;
-            let entries;
-            try {
-                entries = await fs.readdir(uri, { recursive: false, extended: true });
-            }
-            catch (err) {
-                this.logError(err, 'scanFolder', { uri });
+        createScanContext(observer, parsers, recursive) {
+            return {
+                observer,
+                parsers,
+                recursive,
+                progress: { scannedFolders: 0, failedFolders: 0 },
+                discoveredCount: { value: 0 }
+            };
+        }
+        async scanFolder(uri, folderName, ctx) {
+            const listing = await this.readFolder(uri, folderName, ctx);
+            if (!listing)
                 return;
+            let entries = listing;
+            if (ctx.recursive && this.isNamesOnly(listing))
+                entries = await this.listRecursively(uri) ?? listing;
+            await this.scanListing(uri, folderName, entries, ctx);
+        }
+        async scanListing(uri, folderName, entries, ctx) {
+            this.logICloudPlaceholders(uri, entries);
+            ctx.progress.scannedFolders++;
+            this.emitScanProgress(ctx);
+            const { files, dirs } = await this.splitEntries(entries, ctx);
+            await this.announceRoutes(files, uri, folderName, ctx);
+            for (const dir of dirs) {
+                if (this.isCancelled || !ctx.recursive)
+                    continue;
+                if (dir.listing)
+                    await this.scanListing(dir.uri, dir.name, dir.listing, ctx);
+                else
+                    await this.scanFolder(dir.uri, dir.name, ctx);
+            }
+        }
+        async announceRoutes(files, uri, folderName, ctx) {
+            const primaryFiles = files.filter(f => {
+                const ext = this.getExtension(f.name);
+                return ext && ext !== 'gpx' && ctx.parsers.isPrimaryExtension(ext);
+            });
+            for (const file of primaryFiles) {
+                if (!this.isCancelled) {
+                    const routeAnnouncement = await this.buildDiscoveredRoute(file, files, uri, folderName, ctx.parsers);
+                    ctx.discoveredCount.value++;
+                    ctx.observer.emit('scan-result', routeAnnouncement);
+                    this.scanResult.push(routeAnnouncement);
+                }
             }
+        }
+        logICloudPlaceholders(uri, entries) {
             const iCloudPlaceholders = entries.filter(e => /^\.(.+)\.icloud$/.test(e.name));
             if (iCloudPlaceholders.length > 0) {
-                const firstName = iCloudPlaceholders[0].name;
                 this.logEvent({
                     message: 'iCloud placeholder files detected in folder',
                     uri,
                     count: iCloudPlaceholders.length,
-                    firstPlaceholder: firstName
+                    firstPlaceholder: iCloudPlaceholders[0].name
                 });
             }
-            progress.scannedFolders++;
-            observer.emit('scan-progress', { scannedFolders: progress.scannedFolders });
-            const files = entries.filter(e => !e.isDirectory);
-            const dirs = entries.filter(e => e.isDirectory);
-            const primaryFiles = files.filter((f) => {
-                const name = typeof (f) === 'string' ? f : f.name;
-                const ext = this.getExtension(name);
-                return ext && ext !== 'gpx' && parsers.isPrimaryExtension(ext);
-            }).map((f) => {
-                if (typeof f === 'string') {
-                    return {
-                        name: f,
-                        isDirectory: false,
-                        uri: this.getBindings().path.join(uri, f)
-                    };
-                }
-                else
-                    return f;
-            });
-            for (const file of primaryFiles) {
-                if (!this.isCancelled) {
-                    const routeAnnouncement = await this.buildDiscoveredRoute(file, files, uri, folderName, parsers);
-                    discoveredCount.value++;
-                    observer.emit('scan-result', routeAnnouncement);
-                    this.scanResult.push(routeAnnouncement);
-                }
+        }
+        async readFolder(uri, folderName, ctx) {
+            try {
+                const entries = await this.listEntries(uri);
+                if (entries)
+                    return entries;
+                this.countFailedFolder(ctx, new Error('folder listing not available'), folderName);
             }
-            for (const dir of dirs) {
-                if (!this.isCancelled && recursive) {
-                    await this.scanFolder(dir.uri, dir.name, observer, parsers, progress, discoveredCount);
-                }
+            catch (err) {
+                this.countFailedFolder(ctx, err, folderName);
             }
+            return undefined;
+        }
+        countFailedFolder(ctx, err, folderName) {
+            ctx.progress.failedFolders++;
+            this.logError(err, 'scanFolder', { folderName });
+            this.emitScanProgress(ctx);
+        }
+        emitScanProgress(ctx) {
+            const { scannedFolders, failedFolders } = ctx.progress;
+            ctx.observer.emit('scan-progress', { scannedFolders, failedFolders });
+        }
+        async listEntries(uri) {
+            const result = await this.getBindings().fs.readdir?.(uri, { recursive: false, extended: true });
+            if (!Array.isArray(result))
+                return null;
+            if (result.length === 0 || typeof result[0] !== 'string')
+                return result;
+            const path = this.getBindings().path;
+            return result.map(name => ({ name, uri: path.join(uri, name), unknownType: true }));
+        }
+        isNamesOnly(entries) {
+            return entries.some(e => e.unknownType);
+        }
+        async splitEntries(entries, ctx) {
+            if (!this.isNamesOnly(entries)) {
+                return {
+                    files: entries.filter(e => !e.isDirectory),
+                    dirs: entries.filter(e => e.isDirectory)
+                };
+            }
+            return this.resolveNamesOnly(entries, ctx);
+        }
+        async resolveNamesOnly(entries, ctx) {
+            const files = [];
+            const dirs = [];
+            const knownFileExts = this.getKnownFileExtensions(entries, ctx.parsers);
+            for (const entry of entries) {
+                const needsProbe = ctx.recursive && !this.isCancelled && !knownFileExts.has(this.getExtension(entry.name));
+                const listing = needsProbe ? await this.probeEntry(entry, ctx) : undefined;
+                if (listing)
+                    dirs.push({ name: entry.name, uri: entry.uri, isDirectory: true, listing });
+                else if (listing === undefined)
+                    files.push({ name: entry.name, uri: entry.uri, isDirectory: false });
+            }
+            return { files, dirs };
+        }
+        async probeEntry(entry, ctx) {
+            try {
+                return (await this.listEntries(entry.uri)) ?? undefined;
+            }
+            catch (err) {
+                if (!this.isUnreadableFolderError(err))
+                    return undefined;
+                this.countFailedFolder(ctx, err, entry.name);
+                return null;
+            }
+        }
+        isUnreadableFolderError(err) {
+            const { code, message } = (err ?? {});
+            const text = [code, message].filter(v => typeof v === 'string').join(' ');
+            return UNREADABLE_FOLDER_ERRORS.test(text);
+        }
+        getKnownFileExtensions(entries, parsers) {
+            const known = new Set(VIDEO_EXTENSIONS);
+            for (const entry of entries) {
+                const ext = this.getExtension(entry.name);
+                if (!ext || !parsers.isPrimaryExtension(ext))
+                    continue;
+                known.add(ext);
+                for (const companion of this.getCompanionExts(parsers, ext))
+                    known.add(companion.toLowerCase());
+            }
+            return known;
+        }
+        async listRecursively(uri) {
+            let result;
+            try {
+                result = await this.getBindings().fs.readdir?.(uri, { recursive: true });
+            }
+            catch {
+                return undefined;
+            }
+            if (!Array.isArray(result) || !result.every(p => typeof p === 'string'))
+                return undefined;
+            const paths = result;
+            if (!paths.some(p => PATH_SEPARATOR.test(p)))
+                return undefined;
+            return this.buildListingTree(uri, paths);
+        }
+        buildListingTree(rootUri, paths) {
+            const normalised = paths.map(p => p.split(PATH_SEPARATOR).join('/'));
+            const listed = new Set(normalised);
+            const children = new Map();
+            for (const relPath of normalised) {
+                const cut = relPath.lastIndexOf('/');
+                const parent = cut < 0 ? '' : relPath.slice(0, cut);
+                if (parent && !listed.has(parent))
+                    return undefined;
+                const siblings = children.get(parent) ?? [];
+                siblings.push(relPath.slice(cut + 1));
+                children.set(parent, siblings);
+            }
+            const path = this.getBindings().path;
+            const toListing = (relDir, dirUri) => (children.get(relDir) ?? []).map(name => {
+                const relPath = relDir ? `${relDir}/${name}` : name;
+                const entryUri = path.join(dirUri, name);
+                return children.has(relPath)
+                    ? { name, uri: entryUri, isDirectory: true, listing: toListing(relPath, entryUri) }
+                    : { name, uri: entryUri, isDirectory: false };
+            });
+            return toListing('', rootUri);
         }
         async buildDiscoveredRoute(controlFile, folderFiles, folderUri, folderName, parsers) {
             const ext = this.getExtension(controlFile.name);
-            const baseName = controlFile.name.slice(0, controlFile.name.length - ext.length - 1);
-            let skipReason;
-            const companionExts = this.getCompanionExts(parsers, ext);
-            for (const compExt of companionExts) {
-                const hasCompanion = folderFiles.some(f => this.getExtension(f.name).toLowerCase() === compExt.toLowerCase() &&
-                    f.name.toLowerCase().startsWith(baseName.toLowerCase()));
-                if (!hasCompanion) {
-                    skipReason = `Missing companion file (.${compExt})`;
-                    break;
-                }
-            }
+            const baseName = this.getBaseName(controlFile.name);
+            const missingExt = this.findMissingCompanion(parsers, ext, baseName, folderFiles);
+            const skipReason = missingExt ? `Missing companion file (.${missingExt})` : undefined;
             return {
                 folderUri,
                 folderName,
@@ -431,6 +611,7 @@ let RouteLibraryScannerService = (() => {
                     parseState: 'waiting',
                     importable: false,
                     label: file.base,
+                    folder: target.folderName,
                     id: target.controlFileUri,
                     alreadyImported: false,
                     observer: new types_1.Observer()
@@ -489,6 +670,7 @@ let RouteLibraryScannerService = (() => {
                     alreadyImported: false,
                     route,
                     folderUri: target.folderUri,
+                    folderName: target.folderName,
                     controlFileUri: target.controlFileUri,
                     format: target.format
                 };
@@ -503,36 +685,16 @@ let RouteLibraryScannerService = (() => {
                     alreadyImported: false,
                     route: result ? new route_1.Route(result.data, result.details) : undefined,
                     folderUri: target.folderUri,
+                    folderName: target.folderName,
                     controlFileUri: target.controlFileUri,
                     format: target.format,
                     parseError: scope.lastFailure ? this.getReadFailureMessage(scope) : (err?.message ?? String(err)),
-                    parseErrorCode: this.mapErrorToImportCode(err, scope)
+                    parseErrorCode: (0, errors_1.mapErrorToImportCode)(err, scope)
                 };
                 this.logEvent({ message: 'could not parse route file', file: file.base, reason: err.message, stack: err.stack });
                 observer.emit('parse-result', parsed);
             }
         }
-        mapErrorToImportCode(err, scope) {
-            switch (scope?.lastFailure?.reason) {
-                case 'offline':
-                    return 'ICLOUD_OFFLINE';
-                case 'timeout':
-                case 'download-failed':
-                    return 'ICLOUD_DOWNLOAD_FAILED';
-                case 'access-lost':
-                    return 'READ_FAILED';
-            }
-            const message = err?.message ?? String(err);
-            if (/AVI/i.test(message))
-                return 'AVI_NOT_SUPPORTED';
-            if (/no video/i.test(message))
-                return 'NO_VIDEO';
-            if (/^Could not (open|read)/i.test(message))
-                return 'READ_FAILED';
-            if (/pars(e|ing)/i.test(message))
-                return 'PARSE_FAILED';
-            return 'UNSUPPORTED';
-        }
         getReadFailureMessage(scope) {
             const name = this.getFileName(scope.failedFile);
             switch (scope.lastFailure?.reason) {
@@ -560,6 +722,7 @@ let RouteLibraryScannerService = (() => {
         validateVideoUrl(route, folderUri, folderFiles) {
             const { video } = route?.details ?? {};
             const { file, url, format } = video ?? {};
+            this.logEvent({ message: 'validateVideoUrl', file: this.getFileName(file), url: this.getFileName(url), format, folderFileCount: folderFiles.length });
             let videoFormat = format;
             try {
                 if (videoFormat === undefined) {
@@ -642,7 +805,7 @@ let RouteLibraryScannerService = (() => {
                 catch (err) {
                     const reason = err?.message ?? String(err);
                     errors++;
-                    failedRoutes.push({ name: route.title, reason, code: this.mapErrorToImportCode(err) });
+                    failedRoutes.push({ name: route.title, reason, code: (0, errors_1.mapErrorToImportCode)(err) });
                     observer.emit('ingest-error', { name: route.title, reason });
                 }
             }
@@ -660,6 +823,7 @@ let RouteLibraryScannerService = (() => {
             catch (err) {
                 this.logError(err, 'adoptPreview', { title: route?.title });
             }
+            await this.getRouteShapeStore().saveOnImport(route);
             await db.save(route, true);
             service.addRoute(route, existing ? 'import' : 'user');
             try {
@@ -679,6 +843,9 @@ let RouteLibraryScannerService = (() => {
             if (videoRef.startsWith('content://')) {
                 return videoRef;
             }
+            if (!this.isMobile() && /^[a-z][a-z0-9+.-]*:\/\//i.test(videoRef)) {
+                return videoRef;
+            }
             if (videoRef.startsWith('/') || /^[A-Za-z]:[/\\]/.test(videoRef)) {
                 if (this.isMobile())
                     throw new Error('Absolute video path references are not supported');
@@ -691,24 +858,44 @@ let RouteLibraryScannerService = (() => {
         }
         async upsertImportHistory(folderInfo, routeCount) {
             try {
+                const treeUri = this.normaliseTreeUri(folderInfo.uri);
                 const repo = json_1.JsonRepository.create('importedLibraries');
-                const names = await repo.list();
-                const all = await Promise.all((names ?? []).map(n => repo.read(n)));
-                const existing = all
-                    .map(lib => lib)
-                    .find(lib => lib?.treeUri === folderInfo.uri);
+                const names = (await repo.list()) ?? [];
+                const all = await Promise.all(names.map(n => repo.read(n)));
+                const matching = names.filter((_, i) => {
+                    const lib = all[i];
+                    return typeof lib?.treeUri === 'string' && this.normaliseTreeUri(lib.treeUri) === treeUri;
+                });
+                const [kept, ...duplicates] = matching;
+                const existing = (kept === undefined ? undefined : all[names.indexOf(kept)]);
+                for (const duplicate of duplicates)
+                    await repo.delete(duplicate);
                 const id = existing?.id ?? (0, uuid_1.v4)();
                 await repo.write(id, {
                     id,
-                    treeUri: folderInfo.uri,
+                    treeUri,
                     displayName: folderInfo.displayName,
                     lastScanned: new Date().toISOString(),
                     routeCount
                 });
             }
             catch (err) {
-                this.logError(err, 'upsertImportHistory', { uri: folderInfo.uri });
-            }
+                this.logError(err, 'upsertImportHistory', { folder: folderInfo.displayName });
+            }
+        }
+        normaliseTreeUri(uri) {
+            if (/^[a-z][a-z0-9+.-]*:\/\//i.test(uri))
+                return uri;
+            let end = uri.length;
+            while (end > 0 && (uri[end - 1] === '/' || uri[end - 1] === '\\'))
+                end--;
+            const trimmed = uri.slice(0, end);
+            const withDrive = trimmed.replace(/^([a-z]):/, (_, drive) => `${drive.toUpperCase()}:`);
+            if (withDrive === '')
+                return uri.slice(0, 1);
+            if (/^[A-Z]:$/.test(withDrive))
+                return withDrive + uri.charAt(2);
+            return withDrive;
         }
         buildFileInfo(uri, ext) {
             const { dir, base, name } = this.getBindings().path.parse(uri);
@@ -727,7 +914,7 @@ let RouteLibraryScannerService = (() => {
             return this.importProps.routes.find(r => r.id === parsed.controlFileUri);
         }
         buildRouteDisplayItem(parsed, observer) {
-            const { route, alreadyImported, parseError, format, controlFileUri } = parsed;
+            const { route, alreadyImported, parseError, format, controlFileUri, folderName } = parsed;
             const descr = route?.description ?? {};
             const [C, U] = this.getUnitConversionShortcuts();
             const distance = descr.distance === undefined ? undefined : {
@@ -741,6 +928,7 @@ let RouteLibraryScannerService = (() => {
                 id: route?.description?.id ?? info?.base,
                 distance,
                 label: route?.title ?? info?.base,
+                folder: folderName,
                 alreadyImported,
                 parseState: importProps?.parseState ?? 'waiting',
                 importable: parseError == null,
@@ -760,6 +948,14 @@ let RouteLibraryScannerService = (() => {
                 return [];
             }
         }
+        findMissingCompanion(parsers, primaryExt, baseName, folderFiles) {
+            return this.getCompanionExts(parsers, primaryExt).find(compExt => !folderFiles.some(f => this.getExtension(f.name).toLowerCase() === compExt.toLowerCase() &&
+                f.name.toLowerCase().startsWith(baseName.toLowerCase())));
+        }
+        getBaseName(filename) {
+            const ext = this.getExtension(filename);
+            return filename.slice(0, filename.length - ext.length - 1);
+        }
         getExtension(filename) {
             const dot = filename.lastIndexOf('.');
             return dot >= 0 ? filename.slice(dot + 1).toLowerCase() : '';
@@ -779,6 +975,9 @@ let RouteLibraryScannerService = (() => {
         getPreviewStore() {
             return (0, store_1.usePreviewStore)();
         }
+        getRouteShapeStore() {
+            return (0, store_2.useRouteShapeStore)();
+        }
         getParsers() {
             return (0, parsers_1.useParsers)();
         }