blume 2.1.2 → 2.2.0

package/dist/types/core/links.d.ts

@@ -22,7 +22,9 @@ export interface RelativeLinkBase {
  * `/install`. A `.md`/`.mdx` target is a file link: `resolveFile` maps its
  * decoded path, relative to the linking file, to the route that file
  * publishes at, so a target with its own `slug` or an ordering prefix still
- * lands on its page instead of on its raw Markdown source. Without
+ * lands on its page instead of on its raw Markdown source. A file renamed
+ * from `.md` to `.mdx`, or back, is found under its other extension first,
+ * so a link written before the rename keeps that slug or prefix. Without
  * `resolveFile`, or for a file it doesn't know, the target resolves
  * route-relative with the extension dropped.
  *
@@ -31,6 +33,23 @@ export interface RelativeLinkBase {
  * name (`./node.js` for `node.js.mdx`, `./v1.2`) is still a page link.
  */
 export declare const resolveRelativeHref: (href: string, from: RelativeLinkBase, resolveFile?: (path: string) => string | undefined, hasRoute?: (route: string) => boolean) => string | undefined;
+/**
+ * Where a root-relative link to a content file (`/guide/new.md`, the way
+ * VitePress, Docsify, and TypeDoc write one) lands: the route of the source
+ * file it names under the content root, with the authored `?query#hash`
+ * kept, or `undefined` when it names no source file (or isn't a root-relative
+ * `.md`/`.mdx` link at all). It's read as written from the content root, or,
+ * when it starts with `deployment.base`, as including the base (see
+ * `withBasePath`). `routeOfFile` maps an absolute source path to the route
+ * that file publishes at. A link that names no source file is left alone:
+ * `/guide/new.md` is also the URL of a page's Markdown copy, which a link may
+ * mean on purpose.
+ */
+export declare const resolveRootFileHref: (href: string, options: {
+    contentRoot: string;
+    deployBase: string;
+    routeOfFile: (file: string) => string | undefined;
+}) => string | undefined;
 /**
  * Whether a content file is its folder's index, from its name as written on
  * disk: `index.md(x)` after an ordering prefix, optionally carrying one of
@@ -92,14 +111,35 @@ export declare const validateLinks: (graph: ContentGraph, options: {
      * full-route-set resolution in `nav-diagnostics.ts`/`generateRuntime`.
      */
     extraRoutes?: string[];
+    /**
+     * The files the build generates beside `public/` (`/llms.txt`,
+     * `/sitemap.xml`; see `deploy/generated-files.ts`), base-less: links to
+     * them resolve like links to `public/` files.
+     */
+    generatedFiles?: string[];
     /** Locale routing when i18n is on; links then resolve into the page's locale. */
     i18n?: LocaleRouting | null;
+    /** The project's `public/` folder, or `null` when it has none (and so
+     * ships no public files). */
     publicDir: string | null;
     checkExternal?: boolean;
     /** External URLs not to request (`--ignore`). Internal links are always checked. */
     ignore?: (url: string) => boolean;
-    /** Configured redirects; their `from` paths count as valid link targets. */
+    /**
+     * Configured redirects: their `from` paths count as valid link targets,
+     * and an internal `to` must land somewhere the site serves.
+     */
     redirects?: {
         from: string;
+        to: string;
     }[];
+    /** The config file the redirects are written in, for their positions. */
+    configFile?: string;
+    /**
+     * The `docs` collection's content root, which a root-relative link to a
+     * content file (`/guide/new.md`) is read from.
+     */
+    contentRoot?: string;
+    /** `deployment.base` (`""` or `/seg`), which such a link may start with. */
+    deployBase?: string;
 }) => Promise<Diagnostic[]>;

package/dist/types/core/load-module.d.ts

@@ -1,8 +1,18 @@
+/**
+ * jiti aliases that resolve `blume` and every subpath it exports to the
+ * running Blume package, read from its own `exports` map. Without them a user
+ * module resolves `blume` by walking up from its own folder, so a `meta.ts`
+ * under a content root outside the project (`content.root: "../docs"`, a
+ * sibling workspace package) or a file `blume.config.ts` imports from beside
+ * the project can't find the `blume` installed in the project. A wildcard
+ * export (`./core/*`) becomes a prefix alias (`blume/core/`), which jiti
+ * extends with the rest of the specifier.
+ */
+export declare const blumeModuleAliases: () => Record<string, string>;
 /**
  * Create a loader for user-authored ESM/TS modules (`blume.config.ts`,
- * `meta.ts`). One jiti instance is reused across every file the returned loader
- * is called with. `moduleCache: false` ensures edits are picked up on each load,
- * which is what makes dev-server regeneration reflect config/meta changes.
+ * `meta.ts`), in which `blume` resolves to the running package wherever the
+ * module lives (see {@link blumeModuleAliases}).
  */
 export declare const createModuleLoader: () => ((file: string) => Promise<unknown>);
 /**
@@ -12,6 +22,11 @@ export declare const createModuleLoader: () => ((file: string) => Promise<unknow
  * exports `null`/`undefined`, resolves to `undefined` so the caller can say
  * so, instead of validating `{}` (a bare `defineConfig({…})` call) or
  * `{ config }` (a named export). jiti's default interop is off because it
- * throws on `export default null`.
+ * throws on `export default null`. Turning it off changes how jiti compiles
+ * every module the config reaches, Blume's own source included, but jiti keys
+ * its disk cache by file and source alone, so this loader keeps a cache of its
+ * own: sharing one, it would run code compiled for {@link createModuleLoader}
+ * (and that loader, code compiled for this one), whichever loaded the file
+ * first.
  */
 export declare const createDefaultExportLoader: typeof createModuleLoader;

package/dist/types/core/manifest.d.ts

@@ -8,7 +8,20 @@ export declare const MANIFEST_VERSION = 1;
  * site search provider is enabled, so features like the MCP server can index
  * docs even when on-page search is off.
  */
-export declare const contentIndexable: (page: PageRecord, config: ResolvedConfig) => boolean;
+export declare const contentIndexable: (page: PageRecord, config: ResolvedConfig, graph: ContentGraph) => boolean;
+/**
+ * Fallback materialization: render the fallback locale's content at the
+ * localized URL for any translation a non-default locale is missing, so static
+ * output is fully prerendered (render-fallback, no client redirect). Fallback
+ * routes are not indexed and carry no `hreflang` of their own.
+ */
+/**
+ * The description a page's `<head>` emits — `seo.description` over the front
+ * matter `description` — mirrored onto its route so the OG card's subtitle
+ * matches the page's `og:description`, and the summary page indexes like
+ * `llms.txt` give it.
+ */
+export declare const metaDescription: (page: PageRecord) => string | undefined;
 /** Build the runtime manifest that bridges core and the generated Astro app. */
 export declare const buildManifest: (options: {
     context: ProjectContext;

package/dist/types/core/markdown-mirrors.d.ts

@@ -0,0 +1,22 @@
+import type { RouteSet } from "./locale-links.ts";
+/**
+ * Where Blume serves each page's raw Markdown: a copy beside the page, named
+ * for its route (`/guide.md`, `/guide.mdx`; see `rawMarkdownEndpointTemplate`).
+ */
+/** The extensions every page's Markdown copies are served at. */
+export declare const MIRROR_EXTENSIONS: readonly [".md", ".mdx"];
+/** The name a page's Markdown copies are served under, from its route. */
+export declare const mirrorName: (route: string) => string;
+/**
+ * The page whose Markdown copies are served under `name`, if any are: the
+ * root's under `/index`, and a page's under its own route. `/index` is no
+ * page's route, yet it names the root's copies, so a path that isn't a page
+ * can still name a served copy.
+ */
+export declare const mirrorOwner: (pages: RouteSet, name: string) => string | undefined;
+/**
+ * The page a served Markdown copy at `path` belongs to (`/guide.md` the page
+ * `/guide`'s, `/index.mdx` the root's), or `undefined` when `path` is no
+ * served copy.
+ */
+export declare const mirroredPage: (pages: RouteSet, path: string) => string | undefined;

package/dist/types/core/mdx-elements.d.ts

@@ -0,0 +1,32 @@
+import type { Nodes } from "mdast";
+import type { ElementUse } from "./types.ts";
+/**
+ * JSX elements in an `.mdx` body whose props don't render as written:
+ *
+ * - `handler`: an HTML element with a JavaScript event handler
+ *   (`<button onClick={() => …}>`). The page is static HTML, so the function
+ *   is written into the attribute as text and never runs. A string handler
+ *   (`onclick="…"`) is inline script the browser does run, and is left alone.
+ * - `prop`: a built-in that shows its children (see `BUILTIN_CHILD_PROPS`),
+ *   used without any, with props it doesn't take. Those are ignored, so the
+ *   element renders without the content they carry.
+ */
+type JsxElement = Extract<Nodes, {
+    type: "mdxJsxFlowElement" | "mdxJsxTextElement";
+}>;
+type AttributeValue = Extract<JsxElement["attributes"][number], {
+    type: "mdxJsxAttribute";
+}>["value"];
+type ExpressionValue = Extract<AttributeValue, {
+    type: string;
+}>;
+/** Whether an attribute's value is a `{…}` expression, not a string or nothing. */
+export declare const isExpression: (value: AttributeValue) => value is ExpressionValue;
+/**
+ * Every element in an `.mdx` body whose props don't render as written (see
+ * the module comment), in source order, its line shifted by `lineOffset`. The
+ * body is parsed only when a cheap test finds a suspect, and a body MDX can't
+ * parse fails to render with its own error, so it yields none.
+ */
+export declare const extractElementUses: (body: string, lineOffset?: number) => ElementUse[];
+export {};

package/dist/types/core/mdx-syntax.d.ts

@@ -0,0 +1,100 @@
+import type { SourceEntry } from "./sources/types.ts";
+import type { Diagnostic } from "./types.ts";
+import type { ContentVariables } from "./variables.ts";
+/**
+ * MDX that doesn't parse, found before Astro compiles it. The parse is
+ * Sätteri's, with the feature set the renderer uses, so a body that fails it
+ * here fails `astro build` too: Astro compiles every `.mdx` file in the
+ * collection, drafts and pages the scan dropped included. Parsing only (no
+ * plugins, no render) keeps it cheap enough to run on every page.
+ *
+ * - `BLUME_MDX_SYNTAX` (error): the page's own text doesn't parse, so the
+ *   build fails at it.
+ * - `BLUME_MDX_SYNTAX` (warning): the page parses, but not once its
+ *   `<include>`s are spliced in. Reported in the partial. The render splices a
+ *   partial more leniently than this parse reads it, so the page may still
+ *   build, with the partial's markup rendered wrong (an HTML comment shown as
+ *   text, an unclosed `<img>` taking in what follows it).
+ *
+ * The same reading locates a build failure Astro reports with no line: an
+ * `.mdx` page that throws while it renders (a `{…}` expression reading a name
+ * nothing defines), or a partial that breaks the including page's compile.
+ */
+/** Where MDX stopped reading a text, and why. */
+export interface MdxSyntaxError {
+    column: number;
+    line: number;
+    /** Sätteri's message, without its leading position and trailing rule id. */
+    reason: string;
+}
+/**
+ * The first MDX syntax error in `text`, a page body with its front matter
+ * off, or null when it parses.
+ *
+ * Only the verdict is needed, so the parse stays native: Sätteri's tree is
+ * dropped unread rather than built as JavaScript objects, which costs as much
+ * again as the parse itself on every page. A parse error carries its own
+ * position, so node positions aren't tracked either.
+ */
+export declare const mdxSyntaxError: (text: string) => MdxSyntaxError | null;
+/** A position in the file the author wrote. */
+interface Site {
+    column?: number;
+    file: string;
+    line: number;
+}
+/** Maps a line and column of the parsed text to the file it came from. */
+type SiteOf = (line: number, column?: number) => Site;
+/**
+ * The `BLUME_MDX_SYNTAX` diagnostic for `error`, read from a text whose lines
+ * `siteOf` places.
+ */
+export declare const mdxSyntaxDiagnostic: (error: MdxSyntaxError, siteOf: SiteOf, options: {
+    includedIn?: string;
+    severity: Diagnostic["severity"];
+}) => Diagnostic;
+/** What the scan learned from parsing an `.mdx` entry. */
+export interface MdxSyntaxCheck {
+    diagnostics: Diagnostic[];
+    /** Whether the page's own text fails to parse, so its build would fail. */
+    unparsable: boolean;
+}
+/**
+ * Parse an `.mdx` entry's body, and its include-expanded text when it has
+ * one (see the module comment). The body is read as the build reads it: with
+ * the site's variables substituted, which the scan has already done when
+ * there was no expansion to do it in.
+ */
+export declare const mdxSyntaxCheck: (entry: SourceEntry, sourceName: string, variables?: ContentVariables) => MdxSyntaxCheck;
+/** A page as the build failure locator reads it. */
+export interface FailedPage {
+    /** The owning source's content root, which bounds its includes. */
+    contentRoot?: string;
+    /** How a message names the page: its path from the project root. */
+    name: string;
+    sourcePath: string;
+    variables?: ContentVariables;
+}
+/** What a build failure in an `.mdx` page said about itself. */
+export type MdxFailure = {
+    kind: "syntax";
+} | {
+    kind: "undefined-name";
+    name: string;
+};
+/** Where a build failure happened in the files the author wrote. */
+export interface MdxFailureSite extends Site {
+    /** For a syntax failure, the parse's own diagnostic. */
+    diagnostic?: Diagnostic;
+    /** For an undefined name, the expression that reads it, braces included. */
+    expression?: string;
+}
+/**
+ * Locate a build failure Astro reported against an `.mdx` page with no line:
+ * the expression that reads an undefined name, or the syntax error that
+ * stopped the compile (which, when the page's own text parsed, sits in a
+ * partial it includes). Null when the page can't be read or the cause can't
+ * be found in it.
+ */
+export declare const locateMdxFailure: (page: FailedPage, failure: MdxFailure) => Promise<MdxFailureSite | null>;
+export {};

package/dist/types/core/meta-diagnostics.d.ts

@@ -0,0 +1,7 @@
+import type { DiscoveredFolderMeta } from "./meta.ts";
+import type { Diagnostic, PageRecord } from "./types.ts";
+/** Folder-meta diagnostics against every page the sources produced. */
+export declare const folderMetaDiagnostics: (discovered: DiscoveredFolderMeta, pages: readonly PageRecord[], options?: {
+    localeDirs?: readonly string[];
+    versionDirs?: readonly string[];
+}) => Promise<Diagnostic[]>;

package/dist/types/core/meta.d.ts

@@ -19,6 +19,26 @@ export interface FolderMetaSource {
  * translates through this too, so it covers exactly the ones the scan reads.
  */
 export declare const findFolderMetaFiles: (source: FolderMetaSource, patterns?: readonly string[]) => Promise<string[]>;
+/** Folder meta by key: per-locale `meta.*` files, and shared `meta.$.*` ones. */
+export interface FolderMetaMaps {
+    meta: Map<string, FolderMeta>;
+    shared: Map<string, FolderMeta>;
+}
+/** A folder-meta file Blume found but doesn't read, and the key it would have. */
+export interface UnreadFolderMeta {
+    /** Its folder, relative to the source root. */
+    dir: string;
+    file: string;
+    key: string;
+}
+/** What {@link discoverFolderMeta} found across the sources. */
+export interface DiscoveredFolderMeta extends FolderMetaMaps {
+    diagnostics: Diagnostic[];
+    /** The file each meta in `meta` and `shared` was read from. */
+    files: Map<FolderMeta, string>;
+    /** Meta files under a source root that no source's `include` globs reach. */
+    unread: UnreadFolderMeta[];
+}
 /**
  * Discover `meta.{ts,js,mjs}` files across the given filesystem sources. Keys are
  * the source's route prefix joined with the directory relative to that source's
@@ -43,8 +63,15 @@ export declare const findFolderMetaFiles: (source: FolderMetaSource, patterns?:
 export declare const discoverFolderMeta: (sources: string | FolderMetaSource[], options?: {
     localeDirs?: readonly string[];
     versionDirs?: readonly string[];
-}) => Promise<{
-    meta: Map<string, FolderMeta>;
-    shared: Map<string, FolderMeta>;
-    diagnostics: Diagnostic[];
-}>;
+}) => Promise<DiscoveredFolderMeta>;
+/**
+ * Lay the folder meta content sources derive (the OpenAPI source's tag
+ * titles and order) beneath the user's `meta.ts` and `meta.$.ts` files, field
+ * by field: a user file's own keys win, and the generated ones fill the rest,
+ * so a `meta.ts` that only renames a tag group keeps its generated `order`.
+ * Generated meta is locale-agnostic, keyed like `meta.$.*`, so it also sits
+ * beneath a locale's own `meta.ts` (`fr/reference/pets` over
+ * `reference/pets`). It doesn't reach into an archived version's snapshot,
+ * whose groups read only meta keyed under the version.
+ */
+export declare const withGeneratedFolderMeta: (user: FolderMetaMaps, generated: Map<string, FolderMeta>, localeDirs?: readonly string[]) => FolderMetaMaps;

package/dist/types/core/nav-diagnostics.d.ts

@@ -14,9 +14,16 @@ export declare const validateSearchPopularIcons: (popular: {
  * Warn when a config-linked tab/selector target has no matching page. `routes`
  * must be the full set of servable routes — content, custom `.astro` pages, and
  * generated routes — so this runs where all three are known (`generateRuntime`),
- * not in the content-only graph build.
+ * not in the content-only graph build. `servesFile` answers for the files the
+ * site serves beside its pages — `public/` and the generated ones (see
+ * `staticFileResolver`) — so a featured link to `/spec.pdf` or `/llms.txt`
+ * resolves too.
+ *
+ * A tab is checked where it links: its `href` — the author's, or the
+ * section's first page that navigation resolved for a `path` with no page of
+ * its own — and its `path` only when it links there.
  */
-export declare const validateNavTargets: (navigation: Navigation, routes: Set<string>) => Diagnostic[];
+export declare const validateNavTargets: (navigation: Navigation, routes: Set<string>, servesFile?: (path: string) => boolean) => Diagnostic[];
 /**
  * Warn about explicit `navigation.sidebar` items that can't render as written,
  * instead of dropping them without a word: a page ref that matches no page

package/dist/types/core/navigation.d.ts

@@ -25,6 +25,19 @@ export declare const isRootTab: (tab: NavTab, root: string) => boolean;
  * named alike read alike.
  */
 export declare const titleWord: (word: string) => string;
+/**
+ * A page's key in its folder meta `pages` list: its file name without the
+ * extension, ordering prefix, or parentheses (`01-quickstart.mdx` is
+ * `quickstart`).
+ */
+export declare const pageKey: (filename: string) => string;
+/**
+ * The keys a folder meta `pages` list can name, by group path: each folder's
+ * pages and subfolders, keyed as `buildFileSystemSidebar` keys its nodes (the
+ * name without its extension, ordering prefix, or parentheses). Read off nav
+ * paths, so it covers pages the sidebar leaves out, like hidden ones.
+ */
+export declare const folderChildKeys: (navPaths: Iterable<string>) => Map<string, Set<string>>;
 /**
  * An explicit-sidebar ref (`"guides/"`, `"/guides/index"`, `"index"`) in the
  * slashless route form pages are keyed by (`/guides`, `/`).

package/dist/types/core/ordering-prefix.d.ts

@@ -2,3 +2,9 @@
 export declare const orderingPrefix: (name: string) => string | undefined;
 /** `name` without its ordering prefix (`01-intro` -> `intro`). */
 export declare const stripOrderingPrefix: (name: string) => string;
+/**
+ * The name an earlier Blume routed `name` as, when it differs from today's:
+ * a {@link DATE_NAME} lost its first number as an ordering prefix
+ * (`12-05-2022` routed as `05-2022`, `2024-01` as `01`).
+ */
+export declare const formerRouteName: (name: string) => string | undefined;

package/dist/types/core/pinned-ids.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A pinned heading id (`## Heading [#a--b]`, `{#a--b}`) is used verbatim, but
+ * the parse that reads it applies smart punctuation (Astro's `smartypants`,
+ * on by default) to the whole heading first: `--` became `–`, `...` became
+ * `…`, and quotes curled, so the id rendered as `a–b` while every link
+ * written to it says `#a--b`. Smart punctuation leaves a backslash-escaped
+ * character alone, so before a source is parsed, the punctuation in each
+ * heading's trailing markers is escaped where the author wrote it, and the
+ * parse reads the id as typed. An id with a typed `–` keeps it.
+ *
+ * The page render, each `<include>` splice, and the scan-time heading reader
+ * all escape their source this way, so the rendered id and the anchor index
+ * `blume validate` checks against agree.
+ */
+import type { SourceFormat } from "satteri";
+/**
+ * `source` with the smart-punctuation characters in each heading's pinned id
+ * backslash-escaped, so a parse with smart punctuation reads the id as
+ * written. `source` must be the whole text the parse will read, link
+ * definitions included: they decide which brackets are links. A source
+ * without such a pin is returned as is, unparsed.
+ */
+export declare const escapePinnedIds: (source: string, format: SourceFormat) => string;

package/dist/types/core/project-graph.d.ts

@@ -21,8 +21,16 @@ export interface BlumeProject {
     graph: ContentGraph;
     manifest: BlumeManifest;
     diagnostics: Diagnostic[];
-    /** Entries excluded from the graph because their frontmatter failed validation. */
+    /**
+     * Entries excluded from the graph because their frontmatter failed
+     * validation, or (in a build) their MDX doesn't parse.
+     */
     droppedPages: number;
+    /**
+     * The local `.mdx` files a build dropped because they don't parse, which
+     * the docs collection leaves out so Astro never compiles them.
+     */
+    unparsable: string[];
     /** The instantiated content sources, for lazy entry reads (search/AI/raw). */
     sources: ContentSource[];
     /**

package/dist/types/core/redirect-patterns.d.ts

@@ -61,6 +61,13 @@ export interface RedirectRule {
     status: number;
     to: string;
 }
+/**
+ * The literal start of a `to` that reads a capture, up to its first
+ * reference: `/guides/` for `/guides/:slug*`, `/new/article-` for
+ * `/new/article-*`. `undefined` for a `to` that reads none, which is one
+ * exact path.
+ */
+export declare const destinationPrefix: (to: string) => string | undefined;
 /** Whether a path is a pattern, rather than one exact path. */
 export declare const isPatternPath: (path: string) => boolean;
 /** Why a redirect's ends can't work, and which end to fix. */
@@ -80,6 +87,17 @@ export declare const redirectPatternError: (from: string, to: string) => Redirec
  * rules; an exact redirect gets none.
  */
 export declare const expandRedirect: (redirect: RedirectEnds) => RedirectRule[];
+/**
+ * The bare path a pattern ending in a rest also matches, as the exact
+ * redirect every host is given for it: `/beta/:slug*` (or `/beta/*`) to
+ * `/v2/:slug*` sends `/beta` itself to `/v2`. Null for an exact redirect,
+ * a pattern with no rest, and one whose bare path still holds a capture
+ * (`/:lang/*`), which names no single path.
+ */
+export declare const bareRedirect: (redirect: RedirectEnds) => {
+    from: string;
+    to: string;
+} | null;
 /** Put exact redirects ahead of patterns, which hosts try in order. */
 export declare const exactFirst: <Redirect extends {
     from: string;

package/dist/types/core/relative-files.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Whether a target is *shaped* like a colocated image reference: a relative
+ * filesystem path with an image extension. Exported so link validation can
+ * tell "not a colocated candidate" apart from "a candidate that resolves
+ * nowhere" — the former falls through to the public-dir probe, the latter is
+ * a broken reference beside the page source.
+ */
+export declare const isRelativeImageTarget: (target: string) => boolean;
+/**
+ * Resolve one image target against its page's directory. Returns the absolute
+ * file path when the target is relative, is an image, and exists on disk —
+ * anything else (remote URLs, `public/` absolutes, broken refs, code-block
+ * examples that happen to look like paths) is null and left untouched. Shared
+ * with link validation, so what counts as a colocated image is decided once.
+ */
+export declare const resolveRelativeImage: (sourceDir: string, target: string) => string | null;
+/** A file a link names beside its page, and the link's `?query#fragment`. */
+export interface RelativeFile {
+    path: string;
+    suffix: string;
+}
+/**
+ * Resolve the file a link, an element's `src`, or an `href` names beside its
+ * page (`./spec.pdf`, `../files/data.csv#L2`): a relative path whose name
+ * carries an extension other than a page's (`.md`, `.mdx`), on disk as
+ * written (see `existsAsWritten`). Its `?query` or `#fragment` is set aside,
+ * so `./spec.pdf#page=2` opens the served file at that page. Anything else is
+ * null: a page link, a URL, a root path, a missing file. Shared with link
+ * validation, which accepts what this resolves.
+ */
+export declare const resolveRelativeFile: (sourceDir: string, target: string) => RelativeFile | null;