@jbrowse/launch-args 5.0.0-beta.16 → 5.0.0-beta.18

package/esm/launchPlan.js

@@ -1,30 +1,75 @@
 import path from 'node:path';
-import { fileAdapter, fileTrack, isSequenceAdapter, sequenceAssembly, trackFlags, } from './fileInput.js';
+import { buildComparative, comparativeRole, hasComparativeArgs, isSyntenyFlag, syntenyFlags, } from './comparative.js';
+import { checkModifiers } from './displaySettings.js';
+import { fileTrack, genomeAssembly, genomeFlags, isGenomeFlag, isTrackFlag, trackFlags, } from './fileInput.js';
 import { genomeConfigUrl } from './genome.js';
-import { FILE_FLAG, isDataFile, modifierValue, splitModifier, } from './parseArgv.js';
+import { FILE_FLAG, isUrl, locValue, splitModifier } from './parseArgv.js';
+import { viewSettings } from './slotPath.js';
+/**
+ * The views jb2export's subcommand words name, which Desktop takes as its
+ * first argument too.
+ */
+export const launchViewTypes = {
+    lgv: 'LinearGenomeView',
+    synteny: 'LinearSyntenyView',
+    dotplot: 'DotplotView',
+};
+export function launchViewType(word) {
+    return Object.hasOwn(launchViewTypes, word)
+        ? launchViewTypes[word]
+        : undefined;
+}
+// the app applies modifiers once the track is open, so a bad one fails here
+function showTrack(trackId, modifiers) {
+    try {
+        checkModifiers(modifiers);
+    }
+    catch (e) {
+        throw new Error(`${trackId}: ${e instanceof Error ? e.message : e}`, {
+            cause: e,
+        });
+    }
+    return { trackId, modifiers };
+}
 export const launchFlags = new Set([
     'genome',
     'config',
     'assembly',
     'loc',
+    'view',
     'track',
-    'fasta',
-    'aliases',
-    'cytobands',
+    ...genomeFlags,
     FILE_FLAG,
     ...trackFlags,
+    ...syntenyFlags,
+]);
+/**
+ * jb2export's flags that take only true or false, so a file after one is a
+ * file of its own. Desktop reads them to report one without taking the file.
+ */
+export const exportBooleanFlags = new Set([
+    'noRasterize',
+    'defaultSession',
+    'showGridlines',
+    'refseq',
+    'passOnly',
+    'resume',
+    'manifest',
+    'dryRun',
 ]);
-// consumed while building the config, so they reach the view as config
-const BUILD_MODIFIERS = new Set(['name', 'index', 'aliases', 'cytobands']);
 const PATH_MODIFIERS = new Set(['index', 'aliases', 'cytobands']);
-const URL_SCHEME = /^[a-z][a-z0-9+.-]*:\/\//i;
-function isTrackFlag(key) {
-    return key === FILE_FLAG || trackFlags.includes(key);
+function opensTrack(key) {
+    return key === FILE_FLAG || isTrackFlag(key);
 }
-function modifierName(mod) {
-    return splitModifier(mod)?.[0] ?? '';
+/** Whether a flag opens a data file, as a track, genome or comparison flag does. */
+export function takesFile(key) {
+    return opensTrack(key) || isGenomeFlag(key) || isSyntenyFlag(key);
 }
-function uniqueId(used, base) {
+/**
+ * `base`, or the first of `base-2`, `base-3`, ... that `used` lacks, which it
+ * adds to `used`.
+ */
+export function uniqueId(used, base) {
     let id = base;
     for (let i = 2; used.has(id); i++) {
         id = `${base}-${i}`;
@@ -32,37 +77,26 @@ function uniqueId(used, base) {
     used.add(id);
     return id;
 }
+function entryText([key, values]) {
+    return [...(key === FILE_FLAG ? [] : [`--${key}`]), ...values].join(' ');
+}
 /**
  * The plan a command line describes, with every local path resolved against
  * `cwd`: the directory the command ran in, which is not the app's own once a
  * second launch hands its arguments to a running one.
+ *
+ * `viewType` is the view a subcommand word named. Without one, a second genome
+ * or a comparison file opens a synteny view, and anything else a linear one.
  */
-export function launchPlan(entries, cwd) {
-    const abs = (file) => URL_SCHEME.test(file) ? file : path.resolve(cwd, file);
-    const absMod = (mod) => PATH_MODIFIERS.has(modifierName(mod))
-        ? `${modifierName(mod)}:${abs(mod.slice(mod.indexOf(':') + 1))}`
-        : mod;
-    const one = (key) => {
-        const given = entries.filter(([k]) => k === key);
-        if (given.length > 1) {
-            throw new Error(`--${key} is given more than once`);
-        }
-        return given[0]?.[1][0];
+export function launchPlan(entries, cwd, viewType) {
+    const abs = (file) => (isUrl(file) ? file : path.resolve(cwd, file));
+    const absMod = (mod) => {
+        const [name, value] = splitModifier(mod) ?? [];
+        return name && PATH_MODIFIERS.has(name) ? `${name}:${abs(value)}` : mod;
     };
-    const genome = one('genome');
-    const config = one('config');
-    const fasta = one('fasta');
-    if (genome && config) {
-        throw new Error('pass --genome or --config, not both');
-    }
-    const configRef = genome
-        ? genomeConfigUrl(genome)
-        : config
-            ? abs(config)
-            : undefined;
     const resolved = entries.map(([key, values]) => {
         const [file, ...mods] = values;
-        if (!isTrackFlag(key)) {
+        if (!takesFile(key)) {
             return [key, values];
         }
         else if (!file) {
@@ -72,12 +106,76 @@ export function launchPlan(entries, cwd) {
             return [key, [abs(file), ...mods.map(absMod)]];
         }
     });
-    const fastaMods = entries.find(([key]) => key === 'fasta')?.[1].slice(1) ?? [];
-    const genomeFile = fasta
-        ? ['fasta', [abs(fasta), ...fastaMods.map(absMod)]]
-        : resolved.find(([key, [file = '']]) => key === FILE_FLAG && isSequenceAdapter(fileAdapter(file)));
+    const type = viewType ??
+        (hasComparativeArgs(resolved) ? 'LinearSyntenyView' : 'LinearGenomeView');
+    return type === 'LinearGenomeView'
+        ? linearPlan(resolved, abs)
+        : comparativePlan(resolved, type);
+}
+function givenOnce(entries, key) {
+    const found = entries.filter(([k]) => k === key);
+    if (found.length > 1) {
+        throw new Error(`--${key} is given more than once`);
+    }
+    return found[0]?.[1];
+}
+const VIEW_NAMES = {
+    LinearSyntenyView: 'A synteny view',
+    DotplotView: 'A dotplot',
+};
+function comparativePlan(entries, type) {
+    const viewName = VIEW_NAMES[type];
+    if (entries.some(([key]) => key === 'config')) {
+        throw new Error(`${viewName} opens one row per genome, and --config names a config; pass --genome names or FASTA, 2bit or .chrom.sizes files`);
+    }
+    const data = buildComparative(entries);
+    const count = data.rows.length;
+    if (type === 'DotplotView' ? count !== 2 : count < 2) {
+        throw new Error(`${viewName} compares ${type === 'DotplotView' ? 'two genomes' : 'two genomes or more'}, and this command line names ${count}`);
+    }
+    const used = new Set();
+    for (const track of data.syntenyTracks) {
+        track.trackId = uniqueId(used, track.trackId);
+    }
+    return {
+        type,
+        assemblies: data.assemblies,
+        hosted: data.hosted.map(name => ({ name, config: genomeConfigUrl(name) })),
+        views: data.rows,
+        tracks: data.syntenyTracks,
+        view: viewSettings(givenOnce(entries, 'view') ?? []),
+        unapplied: entries
+            .filter(entry => !comparativeRole(entry) && entry[0] !== 'view')
+            .map(entryText),
+    };
+}
+function linearPlan(resolved, abs) {
+    const given = (key) => givenOnce(resolved, key);
+    const one = (key) => given(key)?.[0];
+    const genome = one('genome');
+    const config = one('config');
+    if (genome && config) {
+        throw new Error('pass --genome or --config, not both');
+    }
+    else if (config && isUrl(config) && !/^https?:\/\//i.test(config)) {
+        throw new Error(`--config ${config}: JBrowse fetches a config over http or https, or reads one from a file`);
+    }
+    const configRef = genome
+        ? genomeConfigUrl(genome)
+        : config
+            ? abs(config)
+            : undefined;
+    const roles = resolved.map(comparativeRole);
+    const comparison = resolved.find((_, i) => roles[i] === 'synteny');
+    const [genomeFile, otherGenome] = resolved.filter(([key], i) => roles[i] === 'genome' && key !== 'genome');
     const genomePath = genomeFile?.[1][0];
-    if (genomePath && configRef) {
+    if (comparison) {
+        throw new Error(`${comparison[1][0]} compares two genomes, which a linear view does not show; open it in a synteny view`);
+    }
+    else if (otherGenome) {
+        throw new Error(`${otherGenome[1][0]} is a genome, and this view already has one; open one genome per view`);
+    }
+    else if (genomePath && configRef) {
         throw new Error(`${genomePath} is a genome, and ${genome ? '--genome' : '--config'} names one too; pass one or the other`);
     }
     else if (!genomePath && !configRef) {
@@ -86,50 +184,42 @@ export function launchPlan(entries, cwd) {
     else if (genomePath && one('assembly')) {
         throw new Error(`--assembly picks among the genomes of --genome or --config; ${genomePath} is its own`);
     }
-    let assembly;
-    if (genomeFile && genomePath) {
-        const mods = genomeFile[1].slice(1);
-        const aliases = one('aliases') ?? modifierValue(mods, 'aliases');
-        const cytobands = one('cytobands') ?? modifierValue(mods, 'cytobands');
-        const adapter = fileAdapter(genomePath, {
-            adapterType: genomeFile[0] === 'fasta' && !isDataFile(genomePath)
-                ? 'IndexedFastaAdapter'
-                : undefined,
-        });
-        assembly = sequenceAssembly(adapter, genomePath, {
-            aliases: aliases && abs(aliases),
-            cytobands: cytobands && abs(cytobands),
-        });
-    }
+    const built = genomeFile && genomeAssembly(genomeFile[0], genomeFile[1]);
+    const assembly = built?.assembly;
+    const unapplied = built?.unused.map(mod => `${built.assembly.name} ${mod}`) ?? [];
     const assemblyName = assembly?.name ?? one('assembly');
     const used = new Set();
     const tracks = [];
     const show = [];
-    const unapplied = [];
     for (const entry of resolved) {
         const [key, [first, ...mods]] = entry;
-        if (key === 'track') {
+        if (entry === genomeFile || key === 'loc' || key === 'view') {
+            continue;
+        }
+        else if (key === 'track') {
             if (!first) {
                 throw new Error('--track requires a trackId');
             }
-            show.push(first);
-            unapplied.push(...mods.map(mod => `${first} ${mod}`));
+            show.push(showTrack(first, mods));
         }
-        else if (isTrackFlag(key) && entry !== genomeFile) {
+        else if (opensTrack(key)) {
             const track = fileTrack(key, entry[1], assemblyName);
             track.trackId = uniqueId(used, track.trackId);
             tracks.push(track);
-            show.push(track.trackId);
-            unapplied.push(...mods
-                .filter(mod => !BUILD_MODIFIERS.has(modifierName(mod)))
-                .map(mod => `${track.trackId} ${mod}`));
+            show.push(showTrack(track.trackId, mods));
+        }
+        else {
+            unapplied.push(...mods.map(extra => `--${key} ${extra}`));
         }
     }
+    const loc = given('loc');
     return {
+        type: 'LinearGenomeView',
         config: configRef,
         assembly,
         assemblyName,
-        loc: one('loc'),
+        loc: loc && locValue(loc),
+        view: viewSettings(given('view') ?? []),
         tracks,
         show,
         unapplied,

package/esm/modifierValues.d.ts

@@ -0,0 +1,10 @@
+export declare function invalidModifierValue(prefix: string, val: string, expected: string): never;
+export declare function parseNum(prefix: string, val: string, expected?: string): number;
+export declare function parseStr(prefix: string, val: string, expected?: string): string;
+export declare function parseEnum<T extends string>(prefix: string, val: string, allowed: readonly T[]): T;
+export declare function parseBool(prefix: string, val: string): boolean;
+/**
+ * A JSON modifier, reported with its token, since a bare SyntaxError from a
+ * shell-mangled brace names nothing.
+ */
+export declare function parseJsonModifier(token: string): Record<string, unknown>;

package/esm/modifierValues.js

@@ -0,0 +1,47 @@
+// One rule for every modifier value, so the grammar reads the same whatever the
+// track type: a value that isn't one of the things the modifier accepts is an
+// error. jb2export writes a figure and exits, so a warning about a typo scrolls
+// past and leaves a wrong image behind: `arcs:upp` used to render a plot with no
+// arcs at all.
+export function invalidModifierValue(prefix, val, expected) {
+    throw new Error(val === ''
+        ? `Missing ${prefix} value. Expected ${prefix}:<${expected}>.`
+        : `Invalid ${prefix} value "${val}". Expected ${expected}.`);
+}
+// A bare `height:` would otherwise become a silent 0 via `+''`. `expected`
+// names the wider grammar for the modifiers that also accept keywords.
+export function parseNum(prefix, val, expected = 'a number') {
+    const n = val.trim() === '' ? Number.NaN : Number(val);
+    return Number.isFinite(n) ? n : invalidModifierValue(prefix, val, expected);
+}
+// A modifier whose value is mandatory and free-form (a color, a tag, a display
+// name): `color:` with nothing after the colon is a typo.
+export function parseStr(prefix, val, expected = 'value') {
+    return val || invalidModifierValue(prefix, val, expected);
+}
+// A value from a fixed set, returned as the matched member so the caller keeps
+// the narrow literal type.
+export function parseEnum(prefix, val, allowed) {
+    return (allowed.find(a => a === val) ??
+        invalidModifierValue(prefix, val, allowed.join(', ')));
+}
+// Bare (`force`) or `:true` is on, `:false` is off, anything else is a typo.
+export function parseBool(prefix, val) {
+    return val === '' || val === 'true'
+        ? true
+        : val === 'false'
+            ? false
+            : invalidModifierValue(prefix, val, 'true or false');
+}
+/**
+ * A JSON modifier, reported with its token, since a bare SyntaxError from a
+ * shell-mangled brace names nothing.
+ */
+export function parseJsonModifier(token) {
+    try {
+        return JSON.parse(token);
+    }
+    catch (e) {
+        throw new Error(`Invalid JSON track option: ${token}`, { cause: e });
+    }
+}

package/esm/parseArgv.d.ts

@@ -4,6 +4,8 @@ export type Entry = [string, string[]];
  * reads.bam`, a file typed by its name.
  */
 export declare const FILE_FLAG = "file";
+/** Whether a command-line file is a URL (http, s3, ftp, …) rather than a path. */
+export declare function isUrl(file: string): boolean;
 /**
  * A `name:value` or `path=value` modifier, or a JSON one. A URL and a Windows
  * path carry a colon too, which is why the name before it has to be more than
@@ -22,10 +24,11 @@ export declare function isDataFile(token: string): boolean;
  *   `value`. A bare `-` is stdin, so it is a value.
  * - The token after a flag is its value, except after a flag in `booleans`,
  *   which takes only `true` or `false`.
- * - Later tokens are the entry's modifiers (`height:100`, `color.field=tags.HP`,
- *   `{"json":1}`), until a token that names a data file, which opens a
- *   {@link FILE_FLAG} entry of its own. So `--loc chr1:1-100 reads.bam` keeps
- *   both, and `reads.bam height:100` gives the file its modifier.
+ * - Later tokens are the entry's modifiers (`height:100`,
+ *   `encoding.color.field=tags.HP`, `{"json":1}`), until a token that names a
+ *   data file, which opens a {@link FILE_FLAG} entry of its own. So
+ *   `--loc chr1:1-100 reads.bam` keeps both, and `reads.bam height:100` gives
+ *   the file its modifier.
  * - A bare token before any flag that is not a data file throws; it used to be
  *   dropped without a word.
  */
@@ -33,8 +36,35 @@ export declare function parseArgv(rawArgv: string[], { booleans }?: {
     booleans?: ReadonlySet<string>;
 }): Entry[];
 export declare function splitModifier(token: string): [string, string] | undefined;
+/**
+ * The value of a `key:value` modifier in `tokens`. The last one given wins, as
+ * with the display modifiers, so a script overrides a shared list by
+ * appending to it.
+ */
 export declare function modifierValue(tokens: string[], key: string): string | undefined;
-export declare function standardizeArgv(args: Entry[], trackTypes: string[]): {
+/** `--loc`'s tokens, which together name the regions of one view. */
+export declare function locValue(values: string[]): string | undefined;
+/**
+ * Words a flag's value is followed by, read off as one error: a flag that
+ * takes one value has no use for them.
+ */
+export declare function extraValuesMessage(flag: string, extra: string[]): string;
+/**
+ * The command line as option values, with the track entries apart, in order.
+ *
+ * - `--loc` takes all its tokens, so `--loc chr1:1-100 chr2:1-100` names the
+ *   regions a quoted `--loc` does.
+ * - A flag in `repeatable` may repeat and so has no single value here; the
+ *   caller reads it from the entries.
+ * - A flag in `withModifiers` takes modifiers after its value, which the
+ *   caller reads from the entries too.
+ * - Any other flag given twice, or followed by a token it has no use for,
+ *   throws.
+ */
+export declare function standardizeArgv(args: Entry[], trackTypes: string[], { repeatable, withModifiers, }?: {
+    repeatable?: string[];
+    withModifiers?: string[];
+}): {
     trackList: Entry[];
     [key: string]: unknown;
 };

package/esm/parseArgv.js

@@ -5,6 +5,10 @@ import { fileNameOf, matchFormat } from '@jbrowse/add-track-core';
  */
 export const FILE_FLAG = 'file';
 const URL_SCHEME = /^[a-z][a-z0-9+.-]*:\/\//i;
+/** Whether a command-line file is a URL (http, s3, ftp, …) rather than a path. */
+export function isUrl(file) {
+    return URL_SCHEME.test(file);
+}
 const DRIVE_LETTER = /^[a-z]:[\\/]/i;
 const MODIFIER = /^[a-z_][\w.-]*[:=]/i;
 /**
@@ -14,9 +18,7 @@ const MODIFIER = /^[a-z_][\w.-]*[:=]/i;
  */
 export function isModifier(token) {
     return (token.startsWith('{') ||
-        (MODIFIER.test(token) &&
-            !URL_SCHEME.test(token) &&
-            !DRIVE_LETTER.test(token)));
+        (MODIFIER.test(token) && !isUrl(token) && !DRIVE_LETTER.test(token)));
 }
 /**
  * A file the shared format table recognizes by name, as a local path or a URL:
@@ -33,10 +35,11 @@ export function isDataFile(token) {
  *   `value`. A bare `-` is stdin, so it is a value.
  * - The token after a flag is its value, except after a flag in `booleans`,
  *   which takes only `true` or `false`.
- * - Later tokens are the entry's modifiers (`height:100`, `color.field=tags.HP`,
- *   `{"json":1}`), until a token that names a data file, which opens a
- *   {@link FILE_FLAG} entry of its own. So `--loc chr1:1-100 reads.bam` keeps
- *   both, and `reads.bam height:100` gives the file its modifier.
+ * - Later tokens are the entry's modifiers (`height:100`,
+ *   `encoding.color.field=tags.HP`, `{"json":1}`), until a token that names a
+ *   data file, which opens a {@link FILE_FLAG} entry of its own. So
+ *   `--loc chr1:1-100 reads.bam` keeps both, and `reads.bam height:100` gives
+ *   the file its modifier.
  * - A bare token before any flag that is not a data file throws; it used to be
  *   dropped without a word.
  */
@@ -73,35 +76,65 @@ export function parseArgv(rawArgv, { booleans = new Set() } = {}) {
     }
     return entries;
 }
-// Split a `key:value` modifier token at its FIRST colon, keeping any colons in
-// the value (URLs, locstrings — e.g. `aliases:https://x/a.txt`). Returns
-// undefined for a token with no colon or a leading colon. This is the
-// colon-preserving grammar the assembly-flag (`loc:`/`aliases:`) and track-file
-// (`index:`/`name:`) modifiers use; the display modifiers instead split every
-// colon (`color:tag:XS`) directly where they're parsed.
+// `key:value` split at the first colon, so `aliases:https://x/a.txt` keeps its
+// URL. The display modifiers split every colon instead (`color:tag:XS`).
 export function splitModifier(token) {
     const i = token.indexOf(':');
     return i > 0 ? [token.slice(0, i), token.slice(i + 1)] : undefined;
 }
-// The value of the first `key:value` modifier in `tokens` matching `key`.
+/**
+ * The value of a `key:value` modifier in `tokens`. The last one given wins, as
+ * with the display modifiers, so a script overrides a shared list by
+ * appending to it.
+ */
 export function modifierValue(tokens, key) {
-    for (const token of tokens) {
-        const split = splitModifier(token);
-        if (split?.[0] === key) {
-            return split[1];
-        }
-    }
-    return undefined;
+    return tokens.map(splitModifier).findLast(split => split?.[0] === key)?.[1];
+}
+/** `--loc`'s tokens, which together name the regions of one view. */
+export function locValue(values) {
+    return values.join(' ').trim() || undefined;
 }
-export function standardizeArgv(args, trackTypes) {
+/**
+ * Words a flag's value is followed by, read off as one error: a flag that
+ * takes one value has no use for them.
+ */
+export function extraValuesMessage(flag, extra) {
+    return `--${flag} takes one value, so ${extra.map(e => `"${e}"`).join(' ')} ${extra.length > 1 ? 'apply' : 'applies'} to nothing`;
+}
+/**
+ * The command line as option values, with the track entries apart, in order.
+ *
+ * - `--loc` takes all its tokens, so `--loc chr1:1-100 chr2:1-100` names the
+ *   regions a quoted `--loc` does.
+ * - A flag in `repeatable` may repeat and so has no single value here; the
+ *   caller reads it from the entries.
+ * - A flag in `withModifiers` takes modifiers after its value, which the
+ *   caller reads from the entries too.
+ * - Any other flag given twice, or followed by a token it has no use for,
+ *   throws.
+ */
+export function standardizeArgv(args, trackTypes, { repeatable = ['track'], withModifiers = ['track', 'view', 'fasta', 'chromSizes'], } = {}) {
     const trackList = [];
     const rest = {};
     for (const [key, vals] of args) {
         if (key === FILE_FLAG || trackTypes.includes(key)) {
             trackList.push([key, vals]);
         }
+        else if (repeatable.includes(key)) {
+            continue;
+        }
+        else if (Object.hasOwn(rest, key)) {
+            throw new Error(`--${key} is given more than once`);
+        }
+        else if (key === 'loc') {
+            rest[key] = locValue(vals) ?? true;
+        }
         else {
-            rest[key] = vals[0] ?? true;
+            const [value, ...extra] = vals;
+            if (extra.length && !withModifiers.includes(key)) {
+                throw new Error(extraValuesMessage(key, extra));
+            }
+            rest[key] = value ?? true;
         }
     }
     return { trackList, ...rest };

package/esm/slotPath.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The value of a `path=value` modifier: `true`/`false`, a number, a
+ * comma-separated list (a trailing comma makes a list of one, and a `jexl:`
+ * item keeps the commas inside its own brackets and quotes), or the text as
+ * written.
+ */
+export declare function slotValue(text: string): string | number | boolean | (string | number | boolean)[];
+/** Whether a track option is a `path=value` slot write rather than a named modifier. */
+export declare function isSlotPathOption(opt: string): boolean;
+/**
+ * Whether a slot write names a member of a setting, `encoding.color.field=…`,
+ * rather than a whole setting, `height=…`.
+ */
+export declare function isMemberWrite(opt: string): boolean;
+/**
+ * Merge `patch` into `target`, object into object and anything else replacing
+ * what was there, so `encoding.color.field=…` and
+ * `encoding.color.scale.range=…` fill one object in either order.
+ */
+export declare function mergeSettings(target: Record<string, unknown>, patch: Record<string, unknown>): Record<string, unknown>;
+/** A `path=value` modifier read apart: the segments it walks, and what it sets. */
+export interface SlotWrite {
+    opt: string;
+    segments: string[];
+    value: unknown;
+}
+/**
+ * `encoding.color.scale.range=tan,teal` and `marks.0.encoding.y=score`, read
+ * apart.
+ */
+export declare function slotWrite(opt: string): SlotWrite;
+/**
+ * Apply one `path=value` write to `target`, creating the objects and lists the
+ * path walks through and leaving everything beside them alone, so the writes of
+ * one command line compose whatever order they come in.
+ *
+ * Indexing a list is what carries the grammar: `marks`, the `transform` steps
+ * under a mark and an aggregate's `ops` are all lists of objects, and while a
+ * path stopped at the first of them a declared figure could only be written as
+ * raw JSON.
+ */
+export declare function applySlotWrite(target: Record<string, unknown>, write: SlotWrite): Record<string, unknown>;
+/**
+ * The settings `--view`'s tokens write onto the view, as a session spec's view
+ * object holds them: `mark.interpolate=bump`, `filter.0.field=length`, or a
+ * JSON object merged in whole.
+ */
+export declare function viewSettings(tokens: string[]): Record<string, unknown>;