@jbrowse/cli 4.3.0 → 5.0.0-beta.2

package/dist/commands/shared/validators.js

@@ -1,14 +1,49 @@
-import { sync as commandExistsSync } from 'command-exists';
+import { execFileSync } from 'node:child_process';
+import { accessSync, constants, statSync } from 'node:fs';
 export function validateFileArgument(file, commandName, fileType) {
-    if (!file && process.stdin.isTTY) {
+    if (file) {
+        // The sort pipeline's exit status is `sort`'s, which succeeds on empty
+        // input, so a missing/unreadable file would otherwise "succeed" with empty
+        // output. Fail loudly here instead.
+        if (!statSync(file, { throwIfNoEntry: false })?.isFile()) {
+            throw new Error(`Input file does not exist or is not a regular file: ${file}`);
+        }
+        try {
+            accessSync(file, constants.R_OK);
+        }
+        catch {
+            throw new Error(`Input file is not readable: ${file}`);
+        }
+    }
+    else if (process.stdin.isTTY) {
         throw new Error(`Missing required argument: file\n` +
             `Usage: jbrowse ${commandName} <file>\n` +
             `       OR pipe data via stdin: cat file.${fileType} | jbrowse ${commandName}`);
     }
 }
+// Replaces command-exists: is `command` runnable? On POSIX, `command -v` (a
+// shell builtin, so invoked via `sh`) resolves builtins, PATH entries, and
+// absolute paths; on Windows, `where` does the same. The name is passed as an
+// argv item, never interpolated into the shell, so it can't be injected.
+function commandExistsSync(command) {
+    try {
+        if (process.platform === 'win32') {
+            execFileSync('where', [command], { stdio: 'ignore' });
+        }
+        else {
+            execFileSync('sh', ['-c', 'command -v "$1"', 'sh', command], {
+                stdio: 'ignore',
+            });
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function validateRequiredCommands(requiredCommands) {
     const missingCommands = requiredCommands.filter(cmd => !commandExistsSync(cmd));
     if (missingCommands.length > 0) {
-        throw new Error(`Unable to run command, requires unix type environment with: ${requiredCommands.join(', ')}`);
+        throw new Error(`Unable to run command, requires a unix type environment with the following available: ${requiredCommands.join(', ')}. Missing: ${missingCommands.join(', ')}`);
     }
 }

package/dist/commands/sort-bed.js

@@ -1,35 +1,4 @@
-import { parseArgs } from 'util';
-import { printHelp } from "../utils.js";
-import { waitForProcessClose } from "./process-utils.js";
-import { BED_CONFIG, spawnSortProcess } from "./shared/sort-utils.js";
-import { validateFileArgument, validateRequiredCommands, } from "./shared/validators.js";
+import { BED_CONFIG, runSort } from './shared/sort-utils.js';
 export async function run(args) {
-    const options = {
-        help: {
-            type: 'boolean',
-            short: 'h',
-        },
-    };
-    const { values: flags, positionals } = parseArgs({
-        args,
-        options,
-        allowPositionals: true,
-    });
-    if (flags.help) {
-        printHelp({
-            description: BED_CONFIG.description,
-            examples: BED_CONFIG.examples,
-            usage: 'jbrowse sort-bed [file] [options]',
-            options,
-        });
-        return;
-    }
-    const file = positionals[0];
-    validateFileArgument(file, 'sort-bed', 'bed');
-    validateRequiredCommands(['sh', 'sort', 'grep']);
-    const child = spawnSortProcess(file, BED_CONFIG.sortColumn);
-    const exitCode = await waitForProcessClose(child);
-    if (exitCode !== 0) {
-        throw new Error(`Sort process exited with code ${exitCode}`);
-    }
+    return runSort(BED_CONFIG, 'sort-bed', args);
 }

package/dist/commands/sort-gff.js

@@ -1,35 +1,4 @@
-import { parseArgs } from 'util';
-import { printHelp } from "../utils.js";
-import { waitForProcessClose } from "./process-utils.js";
-import { GFF_CONFIG, spawnSortProcess } from "./shared/sort-utils.js";
-import { validateFileArgument, validateRequiredCommands, } from "./shared/validators.js";
+import { GFF_CONFIG, runSort } from './shared/sort-utils.js';
 export async function run(args) {
-    const options = {
-        help: {
-            type: 'boolean',
-            short: 'h',
-        },
-    };
-    const { values: flags, positionals } = parseArgs({
-        args,
-        options,
-        allowPositionals: true,
-    });
-    if (flags.help) {
-        printHelp({
-            description: GFF_CONFIG.description,
-            examples: GFF_CONFIG.examples,
-            usage: 'jbrowse sort-gff [file] [options]',
-            options,
-        });
-        return;
-    }
-    const file = positionals[0];
-    validateFileArgument(file, 'sort-gff', 'gff');
-    validateRequiredCommands(['sh', 'sort', 'grep']);
-    const child = spawnSortProcess(file, GFF_CONFIG.sortColumn);
-    const exitCode = await waitForProcessClose(child);
-    if (exitCode !== 0) {
-        throw new Error(`Sort process exited with code ${exitCode}`);
-    }
+    return runSort(GFF_CONFIG, 'sort-gff', args);
 }

package/dist/commands/text-index/adapter-utils.js

@@ -1,38 +1,21 @@
-import { sanitizeNameForPath } from "./config-utils.js";
-export function getLoc(elt) {
-    return elt.locationType === 'LocalPathLocation' ? elt.localPath : elt.uri;
-}
+import { sanitizeForFilename, trixFileUris } from '@jbrowse/text-indexing-core';
 export function createTrixAdapter(name, assemblyNames, idSuffix = 'index') {
-    const safeName = sanitizeNameForPath(name);
+    const uris = trixFileUris(name);
     return {
         type: 'TrixTextSearchAdapter',
-        textSearchAdapterId: `${safeName}-${idSuffix}`,
+        textSearchAdapterId: `${sanitizeForFilename(name)}-${idSuffix}`,
         ixFilePath: {
-            uri: `trix/${safeName}.ix`,
+            uri: uris.ix,
             locationType: 'UriLocation',
         },
         ixxFilePath: {
-            uri: `trix/${safeName}.ixx`,
+            uri: uris.ixx,
             locationType: 'UriLocation',
         },
         metaFilePath: {
-            uri: `trix/${safeName}_meta.json`,
+            uri: uris.meta,
             locationType: 'UriLocation',
         },
         assemblyNames,
     };
 }
-const ADAPTER_LOCATION_KEYS = {
-    Gff3TabixAdapter: 'gffGzLocation',
-    Gff3Adapter: 'gffLocation',
-    VcfAdapter: 'vcfLocation',
-    VcfTabixAdapter: 'vcfGzLocation',
-};
-export function getAdapterLocation(adapter) {
-    const key = ADAPTER_LOCATION_KEYS[adapter?.type ?? ''];
-    return key
-        ? // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            (adapter?.[key] ??
-                adapter)
-        : undefined;
-}

package/dist/commands/text-index/aggregate.js

@@ -1,13 +1,15 @@
-import { createTrixAdapter } from "./adapter-utils.js";
-import { getAssemblyNames, getTrackConfigs, loadConfigForIndexing, parseCommaSeparatedString, prepareIndexDriverFlags, writeConf, } from "./config-utils.js";
-import { indexDriver } from "./indexing-utils.js";
-import { resolveConfigPath } from "../../utils.js";
+import { parseCommaSeparatedString, writeJsonFile } from '../../utils.js';
+import { createTrixAdapter } from './adapter-utils.js';
+import { formatDryRun, getAssemblyNames, getTrackConfigs, loadConfigForIndexing, prepareIndexDriverFlags, } from './config-utils.js';
+import { indexDriver } from './indexing-utils.js';
 export async function aggregateIndex(flags) {
-    const { out, target, tracks, excludeTracks, assemblies, attributes, quiet, force, exclude, dryrun, prefixSize, } = flags;
-    const { config, configPath, outLocation } = await loadConfigForIndexing(target, out, resolveConfigPath);
-    const aggregateTextSearchAdapters = config.aggregateTextSearchAdapters || [];
-    const asms = getAssemblyNames(config, assemblies);
-    for (const asm of asms) {
+    const { out, target, tracks, excludeTracks, assemblies, attributes, quiet, force, exclude, include, dryrun, prefixSize, } = flags;
+    const { config, configPath, outLocation } = await loadConfigForIndexing(target, out);
+    const existing = config.aggregateTextSearchAdapters ?? [];
+    // sequential, not Promise.all: each assembly's indexer owns the progress bar
+    // and streams whole files through ixIxx
+    const written = [];
+    for (const asm of getAssemblyNames(config, assemblies)) {
         const trackConfigs = getTrackConfigs(config, parseCommaSeparatedString(tracks), asm, parseCommaSeparatedString(excludeTracks));
         if (!trackConfigs.length) {
             console.log(`Indexing assembly ${asm}...(no tracks found)...`);
@@ -15,35 +17,39 @@ export async function aggregateIndex(flags) {
         }
         console.log(`Indexing assembly ${asm}...`);
         if (dryrun) {
-            console.log(trackConfigs.map(e => `${e.trackId}	${e.adapter?.type}`).join('\n'));
+            console.log(formatDryRun(trackConfigs));
+            continue;
         }
-        else {
-            const id = `${asm}-index`;
-            const idx = aggregateTextSearchAdapters.findIndex(x => x.textSearchAdapterId === id);
-            if (idx !== -1 && !force) {
-                console.log(`Note: ${asm} has already been indexed with this configuration, use --force to overwrite this assembly. Skipping for now`);
-                continue;
-            }
-            await indexDriver({
-                trackConfigs,
-                outLocation,
-                name: asm,
-                assemblyNames: [asm],
-                ...prepareIndexDriverFlags({ attributes, exclude, quiet, prefixSize }),
-            });
-            const trixConf = createTrixAdapter(asm, [asm]);
-            if (idx === -1) {
-                aggregateTextSearchAdapters.push(trixConf);
-            }
-            else {
-                aggregateTextSearchAdapters[idx] = trixConf;
-            }
+        const trixConf = createTrixAdapter(asm, [asm]);
+        if (!force &&
+            existing.some(x => x.textSearchAdapterId === trixConf.textSearchAdapterId)) {
+            console.log(`Note: ${asm} has already been indexed with this configuration, use --force to overwrite this assembly. Skipping for now`);
+            continue;
         }
+        await indexDriver({
+            trackConfigs,
+            outLocation,
+            name: asm,
+            assemblyNames: [asm],
+            ...prepareIndexDriverFlags({
+                attributes,
+                exclude,
+                include,
+                quiet,
+                prefixSize,
+            }),
+        });
+        written.push(trixConf);
     }
     if (!dryrun) {
-        writeConf({
+        await writeJsonFile(configPath, {
             ...config,
-            aggregateTextSearchAdapters,
-        }, configPath);
+            // upsert by adapter id: a Map keyed on it keeps the first occurrence's
+            // position while the last value wins, so re-indexing an assembly replaces
+            // its adapter in place and a new one lands at the end
+            aggregateTextSearchAdapters: [
+                ...new Map([...existing, ...written].map(a => [a.textSearchAdapterId, a])).values(),
+            ],
+        });
     }
 }

package/dist/commands/text-index/command.js

@@ -1,6 +1,7 @@
-import { parseArgs } from 'util';
-import { aggregateIndex, indexFileList, perTrackIndex } from "./index.js";
-import { printHelp } from "../../utils.js";
+import { parseArgs } from 'node:util';
+import { defaultAttributesToIndex, indexableAdapters, } from '@jbrowse/text-indexing-core';
+import { printHelp } from '../../utils.js';
+import { aggregateIndex, indexFileList, perTrackIndex } from './index.js';
 export async function run(args) {
     const options = {
         help: {
@@ -14,7 +15,7 @@ export async function run(args) {
         },
         excludeTracks: {
             type: 'string',
-            description: 'Specific tracks to exclude from indexing, formatted as comma separated trackIds',
+            description: 'Specific tracks to exclude from indexing, formatted as comma separated trackIds. To exclude a track permanently, set metadata.skipTextIndex on it in config.json instead (see Notes)',
         },
         target: {
             type: 'string',
@@ -24,7 +25,7 @@ export async function run(args) {
         attributes: {
             type: 'string',
             description: 'Comma separated list of attributes to index',
-            default: 'Name,ID',
+            default: defaultAttributesToIndex.join(','),
         },
         assemblies: {
             type: 'string',
@@ -49,9 +50,13 @@ export async function run(args) {
         },
         exclude: {
             type: 'string',
-            description: 'Adds gene type to list of excluded types',
+            description: 'Comma separated list of feature types to exclude from indexing',
             default: 'CDS,exon',
         },
+        include: {
+            type: 'string',
+            description: 'Comma separated list of feature types to index, dropping every other type. Unset by default, which indexes every type --exclude does not name. GFF3 only',
+        },
         prefixSize: {
             type: 'string',
             description: 'Specify the prefix size for the ixx index. We attempt to automatically calculate this, but you can manually specify this too. If many genes have similar gene IDs e.g. Z000000001, Z000000002 the prefix size should be larger so that they get split into different bins',
@@ -76,6 +81,28 @@ export async function run(args) {
         options,
     });
     const description = 'Make a text-indexing file for any given track(s).';
+    const notes = 'Individual tracks in config.json can be permanently excluded from ' +
+        'indexing by setting "metadata": { "skipTextIndex": true } on the track. ' +
+        'Such tracks are skipped even when indexing all tracks or a whole ' +
+        'assembly, so you do not have to pass --excludeTracks on every run.\n\n' +
+        // read off the table rather than restated, because the hand-written version
+        // of this sentence outlived GtfTabixAdapter's absence from it
+        `Only tracks with an indexable adapter type (${Object.keys(indexableAdapters).sort().join(', ')}) are indexed; ` +
+        'tracks with other adapter types are skipped automatically.\n\n' +
+        'GTF has no Name/ID attributes, so the default --attributes also match ' +
+        'their GTF spellings (gene_name, transcript_name, gene_id, transcript_id).' +
+        '\n\n' +
+        '--exclude names types not to index; --include names the only types to ' +
+        'index. Reach for --include when the file draws from a vocabulary you do ' +
+        'not control: an NCBI RefSeq GFF3 uses 115 feature types, 80 of them leaf ' +
+        'records with no name to search (a match is labelled with a bare UUID, a ' +
+        'cDNA_match with an MD5, every biological_region with the string ' +
+        '"biological region"), so a deny list leaks whichever type is added next ' +
+        'while the allow list — gene, pseudogene and the transcript types — does ' +
+        'not grow. Both may be given: --include admits, --exclude then narrows. ' +
+        'Either can also be set per track in config.json as ' +
+        'textSearching.indexingFeatureTypesToInclude / ' +
+        'indexingFeatureTypesToExclude, which takes precedence over the flag.';
     const examples = [
         "# indexes all tracks that it can find in the current directory's config.json",
         '$ jbrowse text-index',
@@ -84,7 +111,7 @@ export async function run(args) {
         '$ jbrowse text-index --tracks=track1,track2,track3',
         '',
         '# indexes all tracks except specific trackIds',
-        '$ jbrowse text-index --exclude-tracks=track1,track2,track3',
+        '$ jbrowse text-index --excludeTracks=track1,track2,track3',
         '',
         "# indexes all tracks in a directory's config.json or in a specific config file",
         '$ jbrowse text-index --out /path/to/jb2/',
@@ -99,6 +126,7 @@ export async function run(args) {
         printHelp({
             description,
             examples,
+            notes,
             usage: 'jbrowse text-index [options]',
             options,
         });

package/dist/commands/text-index/config-utils.js

@@ -1,114 +1,91 @@
-import fs from 'fs';
-import path from 'path';
-import { supported } from "../../types/common.js";
-/**
- * Parses a comma-separated string into an array of trimmed, non-empty strings
- */
-export function parseCommaSeparatedString(value) {
-    return (value
-        ?.split(',')
-        .map(s => s.trim())
-        .filter(Boolean) ?? []);
-}
-/**
- * Validates and parses a prefix size value
- */
-export function validatePrefixSize(value) {
+import path from 'node:path';
+import { supported } from '../../types/common.js';
+import { parseCommaSeparatedString, readConfigFile, resolveConfigPath, } from '../../utils.js';
+function validatePrefixSize(value) {
     if (!value) {
         return undefined;
     }
     const parsed = typeof value === 'number' ? value : parseInt(value, 10);
-    if (isNaN(parsed) || parsed < 0) {
+    if (Number.isNaN(parsed) || parsed <= 0) {
         throw new Error(`Invalid prefixSize: "${value}". Must be a positive number.`);
     }
     return parsed;
 }
-/**
- * Prepares common indexDriver parameters from raw flag values
- */
 export function prepareIndexDriverFlags(flags) {
     return {
         attributes: parseCommaSeparatedString(flags.attributes),
         typesToExclude: parseCommaSeparatedString(flags.exclude),
+        // undefined rather than [] when the flag is absent, because an empty allow
+        // list has to mean "no allow list" and not "index nothing"
+        typesToInclude: flags.include
+            ? parseCommaSeparatedString(flags.include)
+            : undefined,
         quiet: flags.quiet ?? false,
         prefixSize: validatePrefixSize(flags.prefixSize),
     };
 }
-export function readConf(configPath) {
-    return JSON.parse(fs.readFileSync(configPath, 'utf8'));
-}
-export function writeConf(obj, configPath) {
-    fs.writeFileSync(configPath, JSON.stringify(obj, null, 2));
-}
-/**
- * Loads config and prepares output location for indexing
- */
-export async function loadConfigForIndexing(target, out, resolveConfigPath) {
+export async function loadConfigForIndexing(target, out) {
     const configPath = await resolveConfigPath(target, out);
-    const outLocation = path.dirname(configPath);
-    const config = readConf(configPath);
-    ensureTrixDir(outLocation);
-    return { config, configPath, outLocation };
-}
-export function ensureTrixDir(outLocation) {
-    const trixDir = path.join(outLocation, 'trix');
-    if (!fs.existsSync(trixDir)) {
-        fs.mkdirSync(trixDir, { recursive: true });
-    }
-    return trixDir;
-}
-/**
- * Extracts all assembly names from a config object
- * Handles both single assembly (config.assembly) and multiple assemblies (config.assemblies)
- */
-function extractAssemblyNamesFromConfig(config) {
-    if (config.assemblies) {
-        return config.assemblies.map(a => a.name);
-    }
-    if (config.assembly) {
-        return [config.assembly.name];
-    }
-    return [];
+    // readConfigFile, not a bare readFileSync: run from the wrong directory, this
+    // is the error the user sees, and it should name the config.json it looked for
+    const config = await readConfigFile(configPath);
+    return { config, configPath, outLocation: path.dirname(configPath) };
 }
 export function getAssemblyNames(config, assemblies) {
     const asms = assemblies
         ? parseCommaSeparatedString(assemblies)
-        : extractAssemblyNamesFromConfig(config);
+        : (config.assemblies?.map(a => a.name) ??
+            (config.assembly ? [config.assembly.name] : []));
     if (!asms.length) {
         throw new Error('No assemblies found');
     }
     return asms;
 }
-export function getTrackConfigs(config, trackIds, assemblyName, excludeTrackIds) {
-    const { tracks } = config;
-    if (!tracks) {
-        return [];
+export function formatDryRun(trackConfigs) {
+    return trackConfigs.map(t => `${t.trackId}\t${t.adapter?.type}`).join('\n');
+}
+// why a track was left out, or undefined if it is indexable
+function skipReason(track, assemblyName, excludeSet) {
+    if (assemblyName && !track.assemblyNames.includes(assemblyName)) {
+        return `not in assembly '${assemblyName}'`;
     }
-    const trackIdsToIndex = trackIds?.length
-        ? trackIds
-        : tracks.map(track => track.trackId);
-    const excludeSet = new Set(excludeTrackIds || []);
-    return trackIdsToIndex
-        .map(trackId => {
-        const currentTrack = tracks.find(t => trackId === t.trackId);
-        if (!currentTrack) {
-            throw new Error(`Track not found in config.json for trackId ${trackId}, please add track configuration before indexing.`);
-        }
-        return currentTrack;
-    })
-        .filter(track => {
-        if (excludeSet.has(track.trackId)) {
-            // console.log(`Skipping ${track.trackId}: excluded via --exclude-tracks`)
-            return false;
-        }
-        if (!supported(track.adapter?.type)) {
-            return false;
-        }
-        if (assemblyName && !track.assemblyNames.includes(assemblyName)) {
-            console.log(`Skipping ${track.trackId}: not in assembly '${assemblyName}'`);
-            return false;
+    else if (excludeSet.has(track.trackId)) {
+        return 'excluded with --excludeTracks';
+    }
+    else if (track.metadata?.skipTextIndex) {
+        return 'metadata.skipTextIndex is set';
+    }
+    else if (!supported(track.adapter?.type)) {
+        return `adapter type ${track.adapter?.type} is not indexable`;
+    }
+    else {
+        return undefined;
+    }
+}
+export function getTrackConfigs(config, trackIds, assemblyName, excludeTrackIds) {
+    const tracks = config.tracks ?? [];
+    // when specific trackIds are requested every one must exist; otherwise
+    // consider all tracks in the config
+    const requested = trackIds?.length
+        ? trackIds.map(trackId => {
+            const track = tracks.find(t => t.trackId === trackId);
+            if (track) {
+                return track;
+            }
+            else {
+                throw new Error(`Track not found in config.json for trackId ${trackId}, please add track configuration before indexing.`);
+            }
+        })
+        : tracks;
+    const excludeSet = new Set(excludeTrackIds);
+    return requested.filter(track => {
+        const reason = skipReason(track, assemblyName, excludeSet);
+        // only narrate skips for tracks the user named: sweeping a multi-assembly
+        // config otherwise prints a line per track per assembly
+        if (reason && trackIds?.length) {
+            console.log(`Skipping ${track.trackId}: ${reason}`);
         }
-        return true;
+        return !reason;
     });
 }
 export { sanitizeForFilename as sanitizeNameForPath } from '@jbrowse/text-indexing-core';

package/dist/commands/text-index/file-list.js

@@ -1,22 +1,36 @@
-import path from 'path';
-import { ensureTrixDir, prepareIndexDriverFlags, sanitizeNameForPath, } from "./config-utils.js";
-import { indexDriver, prepareFileTrackConfigs } from "./indexing-utils.js";
-import { validateFileInput } from "./validators.js";
+import path from 'node:path';
+import { formatDryRun, prepareIndexDriverFlags, sanitizeNameForPath, } from './config-utils.js';
+import { indexDriver, prepareFileTrackConfigs } from './indexing-utils.js';
+import { validateFileInput } from './validators.js';
 export async function indexFileList(flags) {
-    const { out, target, fileId, file, attributes, quiet, exclude, prefixSize } = flags;
+    const { out, target, fileId, file, attributes, quiet, exclude, include, prefixSize, dryrun, } = flags;
     validateFileInput(file);
-    const outFlag = target || out || '.';
-    ensureTrixDir(outFlag);
+    // --out/--target names either the install directory or its config.json, as
+    // every other command accepts; the trix output goes beside the config, and
+    // pointing at the config.json used to mkdir config.json/trix and fail ENOTDIR
+    const outArg = target || out || '.';
+    const outLocation = outArg.endsWith('.json') ? path.dirname(outArg) : outArg;
     const trackConfigs = prepareFileTrackConfigs(file, fileId);
-    const name = trackConfigs.length > 1
-        ? 'aggregate'
-        : sanitizeNameForPath(path.basename(file[0]));
-    await indexDriver({
-        trackConfigs,
-        outLocation: outFlag,
-        name,
-        assemblyNames: [],
-        ...prepareIndexDriverFlags({ attributes, exclude, quiet, prefixSize }),
-    });
-    console.log('Successfully created index for these files. See https://jbrowse.org/storybook/lgv/main/?path=/story/text-searching--page for info about usage');
+    if (dryrun) {
+        console.log(formatDryRun(trackConfigs));
+    }
+    else {
+        const name = trackConfigs.length > 1
+            ? 'aggregate'
+            : sanitizeNameForPath(path.basename(file[0]));
+        await indexDriver({
+            trackConfigs,
+            outLocation,
+            name,
+            assemblyNames: [],
+            ...prepareIndexDriverFlags({
+                attributes,
+                exclude,
+                include,
+                quiet,
+                prefixSize,
+            }),
+        });
+        console.log('Successfully created index for these files. See https://jbrowse.org/storybook/lgv/with-aggregate-text-searching/ for info about usage');
+    }
 }

package/dist/commands/text-index/index.js

@@ -1,4 +1,4 @@
-export { aggregateIndex } from "./aggregate.js";
-export { perTrackIndex } from "./per-track.js";
-export { indexFileList } from "./file-list.js";
-export { run } from "./command.js";
+export { aggregateIndex } from './aggregate.js';
+export { perTrackIndex } from './per-track.js';
+export { indexFileList } from './file-list.js';
+export { run } from './command.js';