@nifrajs/cli 4.0.2 → 5.1.0

package/dist/internal/nifra-project.js

@@ -0,0 +1,183 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { CONFIG_FILE, FRAMEWORK_FILE } from "../app-files.js";
+const NIFRA_PACKAGE = /^(?:@nifrajs\/|nifra$)/;
+const DEPENDENCY_FIELDS = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies",
+];
+/** Whether a package.json text names `nifra` or a `@nifrajs/` package, or carries a `nifra` setting. */
+function declaresNifra(manifest) {
+    let parsed;
+    try {
+        parsed = JSON.parse(manifest);
+    }
+    catch {
+        // A manifest nobody can read proves nothing either way, so the directory stays checked.
+        return true;
+    }
+    if (typeof parsed !== "object" || parsed === null)
+        return true;
+    if ("nifra" in parsed)
+        return true;
+    return DEPENDENCY_FIELDS.some((field) => {
+        const deps = Reflect.get(parsed, field);
+        return (typeof deps === "object" &&
+            deps !== null &&
+            Object.keys(deps).some((name) => NIFRA_PACKAGE.test(name)));
+    });
+}
+/**
+ * Whether a project-relative directory ("" for the root) belongs to a nifra project, read statically.
+ * The checked root always does: running the check there says so. Below it, walking up, the first
+ * directory with a nifra config decides yes, and the first package.json decides by naming `nifra` or
+ * a `@nifrajs/` package, or carrying a `nifra` setting; a nested package that does none of that is
+ * another project, such as another framework's app kept beside this one.
+ */
+export function createNifraProjectProbe(root) {
+    const cache = new Map();
+    const probe = (dir) => {
+        const cached = cache.get(dir);
+        if (cached !== undefined)
+            return cached;
+        const at = join(root, dir);
+        let nifra;
+        if (dir === "" || existsSync(join(at, CONFIG_FILE)) || existsSync(join(at, FRAMEWORK_FILE)))
+            nifra = true;
+        else if (existsSync(join(at, "package.json"))) {
+            let manifest;
+            try {
+                manifest = readFileSync(join(at, "package.json"), "utf8");
+            }
+            catch {
+                manifest = "";
+            }
+            nifra = declaresNifra(manifest);
+        }
+        else
+            nifra = probe(dir.slice(0, Math.max(dir.lastIndexOf("/"), 0)));
+        cache.set(dir, nifra);
+        return nifra;
+    };
+    return probe;
+}
+function readJson(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+const recordOf = (value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    ? Object.fromEntries(Object.entries(value))
+    : undefined;
+/**
+ * The `"nifra": { "kind" }` that governs a project-relative directory: read from the nearest
+ * package.json at or above it, the way the zone setting is read, with no app code run.
+ */
+export function createKindProbe(root) {
+    const cache = new Map();
+    const probe = (absolute) => {
+        const cached = cache.get(absolute);
+        if (cached !== undefined)
+            return cached;
+        let declaration;
+        const manifestPath = join(absolute, "package.json");
+        if (existsSync(manifestPath)) {
+            const manifest = relative(root, manifestPath).replaceAll("\\", "/");
+            const kind = recordOf(recordOf(readJson(manifestPath))?.nifra)?.kind;
+            if (kind === undefined)
+                declaration = { kind: undefined, manifest };
+            else if (kind === "api" || kind === "web")
+                declaration = { kind, manifest };
+            else
+                declaration = {
+                    kind: undefined,
+                    manifest,
+                    invalid: `[nifra] ${manifest} "nifra.kind" must be "api" or "web", not ${JSON.stringify(kind)}`,
+                };
+        }
+        else {
+            const parent = dirname(absolute);
+            declaration = parent === absolute ? { kind: undefined, manifest: undefined } : probe(parent);
+        }
+        cache.set(absolute, declaration);
+        return declaration;
+    };
+    return (dir) => probe(join(root, dir));
+}
+/** Whether a project-relative directory holds web config: a `nifra.config.ts` exporting `adapter`, or
+ * `backend/framework.ts`. */
+export function hasWebConfig(root, dir) {
+    if (existsSync(join(root, dir, FRAMEWORK_FILE)))
+        return true;
+    const config = join(root, dir, CONFIG_FILE);
+    if (!existsSync(config))
+        return false;
+    let text;
+    try {
+        text = readFileSync(config, "utf8");
+    }
+    catch {
+        return true;
+    }
+    return /\bexport\s+(?:const|let|var|function)\s+adapter\b|\bexport\s*\{[^}]*\badapter\b/.test(text);
+}
+const WEB_PACKAGE = /^@nifrajs\/web(?:-[a-z0-9-]+)?$/;
+/**
+ * Whether a project-relative directory ("" for the root) is inside a nifra web app. Walking up, the
+ * first directory with `nifra.config.ts` or `backend/framework.ts` makes it one; the first package.json
+ * decides instead: `"nifra": { "kind": "api" }` says no, otherwise naming `@nifrajs/web` or an adapter
+ * says yes. Nothing up to the root means no.
+ */
+export function createWebAppProbe(root) {
+    const cache = new Map();
+    const probe = (dir) => {
+        const cached = cache.get(dir);
+        if (cached !== undefined)
+            return cached;
+        const at = join(root, dir);
+        let web;
+        if (existsSync(join(at, CONFIG_FILE)) || existsSync(join(at, FRAMEWORK_FILE)))
+            web = true;
+        else if (existsSync(join(at, "package.json"))) {
+            const manifest = recordOf(readJson(join(at, "package.json")));
+            web =
+                recordOf(manifest?.nifra)?.kind !== "api" &&
+                    DEPENDENCY_FIELDS.some((field) => {
+                        const deps = recordOf(manifest?.[field]);
+                        return deps !== undefined && Object.keys(deps).some((name) => WEB_PACKAGE.test(name));
+                    });
+        }
+        else
+            web = dir !== "" && probe(dir.slice(0, Math.max(dir.lastIndexOf("/"), 0)));
+        cache.set(dir, web);
+        return web;
+    };
+    return probe;
+}
+/** A zone or server-only finding outside any web app, with the API-only setting named. */
+export const withApiKindHint = (message) => `${message}${message.endsWith(".") ? "" : "."} If this project serves no pages, declare it in package.json: "nifra": { "kind": "api" }`;
+/**
+ * Whether `"nifra": { "kind": "api" }` takes a project-relative directory out of the zone checks. It
+ * does only where no web config sits at or above the directory, up to the checked root: an app that
+ * serves pages keeps its zone checks whatever its package.json says (NF-C037 reports the clash).
+ */
+export function createApiOnlyProbe(root) {
+    const kindOf = createKindProbe(root);
+    const web = new Map();
+    const webConfigUp = (dir) => {
+        const cached = web.get(dir);
+        if (cached !== undefined)
+            return cached;
+        const found = hasWebConfig(root, dir) ||
+            (dir !== "" && webConfigUp(dir.slice(0, Math.max(dir.lastIndexOf("/"), 0))));
+        web.set(dir, found);
+        return found;
+    };
+    return (dir) => kindOf(dir).kind === "api" && !webConfigUp(dir);
+}
+//# sourceMappingURL=nifra-project.js.map

package/dist/internal/nifra-project.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nifra-project.js","sourceRoot":"","sources":["../../src/internal/nifra-project.ts"],"names":[],"mappings":"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"}

package/dist/internal/project-specifiers.d.ts

@@ -0,0 +1,29 @@
+/** `(absolute importing file, specifier)` to the real path of the file it loads, or `undefined`. */
+export type SpecifierResolver = (fromFile: string, specifier: string) => string | undefined;
+export interface ProjectResolver extends SpecifierResolver {
+    /**
+     * `specifier`, an alias as `fromFile` writes it, rewritten through the same alias to name `file`
+     * instead, in the same style (extension, index). `undefined` when `specifier` is not an alias or no
+     * target of its alias covers `file`. Paths are absolute and unresolved, as `fromFile` is spelled.
+     */
+    readonly respell: (fromFile: string, specifier: string, file: string) => string | undefined;
+    /** The `paths` patterns of the nearest tsconfig at or above `dir`, after its `extends` chain. */
+    readonly pathPatterns: (dir: string) => readonly string[];
+    /**
+     * Whether the compiler settings for `file` keep an import whose named specifiers are all
+     * type-only, as `import {} from "x"` (`verbatimModuleSyntax`). `true` when its tsconfig chain
+     * cannot be read, so a scan that trusts the answer keeps the edge.
+     */
+    readonly keepsTypeOnlyImports: (file: string) => boolean;
+}
+/** JSON with comments and trailing commas, as tsconfig files are written. Throws on anything else. */
+export declare function parseJsonc(text: string): unknown;
+/** Whether `path` is a file. A path through a file (`a.ts/index.ts`) is none, not an error. */
+export declare const isFile: (path: string) => boolean;
+export interface SpecifierResolverOptions {
+    /** Whether a module file exists, for resolving against a planned layout rather than the disk.
+     * Config files (tsconfig, package.json) are still read from the disk. */
+    readonly moduleExists?: (path: string) => boolean;
+}
+export declare function createSpecifierResolver(options?: SpecifierResolverOptions): ProjectResolver;
+//# sourceMappingURL=project-specifiers.d.ts.map

package/dist/internal/project-specifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-specifiers.d.ts","sourceRoot":"","sources":["../../src/internal/project-specifiers.ts"],"names":[],"mappings":"AAYA,oGAAoG;AACpG,MAAM,MAAM,iBAAiB,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAA;AAE3F,MAAM,WAAW,eAAgB,SAAQ,iBAAiB;IACxD;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAA;IAC3F,iGAAiG;IACjG,QAAQ,CAAC,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,SAAS,MAAM,EAAE,CAAA;IACzD;;;;OAIG;IACH,QAAQ,CAAC,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CACzD;AAkDD,sGAAsG;AACtG,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAgChD;AAOD,+FAA+F;AAC/F,eAAO,MAAM,MAAM,GAAI,MAAM,MAAM,KAAG,OAMrC,CAAA;AA8DD,MAAM,WAAW,wBAAwB;IACvC;6EACyE;IACzE,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CAClD;AAED,wBAAgB,uBAAuB,CAAC,OAAO,GAAE,wBAA6B,GAAG,eAAe,CAyR/F"}

package/dist/internal/project-specifiers.js

@@ -0,0 +1,435 @@
+/**
+ * The first-party file an import specifier names, found the way a bundler finds it: a relative or
+ * absolute path, a tsconfig `paths` alias or `baseUrl` name (following `extends`), or a package.json
+ * `imports` entry (`#x`). A bare package specifier, a file under `node_modules` and a name that matches
+ * nothing resolve to `undefined`, so a check never mistakes a dependency for project code.
+ *
+ * Never `Bun.resolveSync`: it can install a missing package and remembers answers for the life of the
+ * process, and the MCP server is long-lived. A resolver caches what it reads for one check run only.
+ */
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { basename, dirname, extname, isAbsolute, join } from "node:path";
+const STAR = "\u0000";
+const EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs", ".json"];
+// TypeScript's ESM convention: `./x.js` names `x.ts` when only the source exists.
+const SOURCE_FOR = {
+    ".js": [".ts", ".tsx"],
+    ".jsx": [".tsx"],
+    ".mjs": [".mts"],
+    ".cjs": [".cts"],
+};
+// The package.json `imports` conditions a server-side bundle of this project matches, in no order:
+// the target object's own key order decides, as in Node.
+const CONDITIONS = new Set(["bun", "import", "default"]);
+const MAX_EXTENDS = 16;
+// The options that decide whether an import left with only type specifiers is emitted. The last two
+// are removed in TypeScript 6 but still read by older compilers and bundlers.
+const IMPORT_EMIT_OPTIONS = [
+    "verbatimModuleSyntax",
+    "importsNotUsedAsValues",
+    "preserveValueImports",
+];
+/** JSON with comments and trailing commas, as tsconfig files are written. Throws on anything else. */
+export function parseJsonc(text) {
+    let code = "";
+    for (let i = 0; i < text.length;) {
+        const ch = text[i];
+        if (ch === '"') {
+            let end = i + 1;
+            while (end < text.length && text[end] !== '"')
+                end += text[end] === "\\" ? 2 : 1;
+            code += text.slice(i, end + 1);
+            i = end + 1;
+        }
+        else if (ch === "/" && text[i + 1] === "/") {
+            const newline = text.indexOf("\n", i);
+            i = newline === -1 ? text.length : newline;
+        }
+        else if (ch === "/" && text[i + 1] === "*") {
+            const close = text.indexOf("*/", i + 2);
+            i = close === -1 ? text.length : close + 2;
+        }
+        else {
+            code += ch;
+            i += 1;
+        }
+    }
+    let json = "";
+    for (let i = 0; i < code.length; i += 1) {
+        const ch = code[i];
+        if (ch === '"') {
+            let end = i + 1;
+            while (end < code.length && code[end] !== '"')
+                end += code[end] === "\\" ? 2 : 1;
+            json += code.slice(i, end + 1);
+            i = end;
+        }
+        else if (ch === "," && /^\s*[}\]]/.test(code.slice(i + 1))) {
+        }
+        else
+            json += ch;
+    }
+    return JSON.parse(json.replace(/^\uFEFF/, ""));
+}
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    ? Object.fromEntries(Object.entries(value))
+    : undefined;
+/** Whether `path` is a file. A path through a file (`a.ts/index.ts`) is none, not an error. */
+export const isFile = (path) => {
+    try {
+        return statSync(path, { throwIfNoEntry: false })?.isFile() ?? false;
+    }
+    catch {
+        return false;
+    }
+};
+const real = (path) => {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return path;
+    }
+};
+/** The file a path names: as written, its source for a `.js` name, with an extension, or an index. */
+function probe(base, exists) {
+    if (exists(base))
+        return base;
+    const ext = extname(base);
+    for (const source of SOURCE_FOR[ext] ?? []) {
+        const candidate = `${base.slice(0, -ext.length)}${source}`;
+        if (exists(candidate))
+            return candidate;
+    }
+    for (const extension of EXTENSIONS)
+        if (exists(`${base}${extension}`))
+            return `${base}${extension}`;
+    for (const extension of EXTENSIONS) {
+        const index = join(base, `index${extension}`);
+        if (exists(index))
+            return index;
+    }
+    return undefined;
+}
+/**
+ * `file` written the way `written` names `found`: as is, without its extension, as its folder when
+ * `found` is an index, or with the `.js` name of a `.ts` source.
+ */
+function sameStyle(written, found, file) {
+    if (written === found)
+        return file;
+    const ext = extname(file);
+    const bare = file.slice(0, file.length - ext.length);
+    if (found.startsWith(`${written}/index.`) || found.startsWith(`${written}\\index.`))
+        return basename(file).startsWith("index.") ? dirname(file) : bare;
+    if (found.startsWith(written))
+        return bare;
+    const writtenExt = extname(written);
+    return SOURCE_FOR[writtenExt] === undefined ? file : `${bare}${writtenExt}`;
+}
+/** Longest-prefix `*` match, TypeScript's rule for `paths` and Node's for `imports`. */
+function matchPattern(patterns, specifier) {
+    if (patterns.includes(specifier))
+        return { pattern: specifier, star: undefined };
+    let best;
+    for (const pattern of patterns) {
+        const at = pattern.indexOf("*");
+        if (at === -1 || pattern.indexOf("*", at + 1) !== -1)
+            continue;
+        const prefix = pattern.slice(0, at);
+        const suffix = pattern.slice(at + 1);
+        if (specifier.length < prefix.length + suffix.length)
+            continue;
+        if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix))
+            continue;
+        if (best !== undefined && prefix.length <= best.pattern.indexOf("*"))
+            continue;
+        best = { pattern, star: specifier.slice(prefix.length, specifier.length - suffix.length) };
+    }
+    return best;
+}
+export function createSpecifierResolver(options = {}) {
+    const exists = options.moduleExists ?? isFile;
+    const configs = new Map();
+    const tsconfigByDir = new Map();
+    const manifests = new Map();
+    const packageByDir = new Map();
+    const readJsonc = (path) => {
+        try {
+            return record(parseJsonc(readFileSync(path, "utf8")));
+        }
+        catch {
+            return undefined;
+        }
+    };
+    /** The nearest `tsconfig.json` (or `jsconfig.json`) at or above `dir`, as Bun's resolver picks it. */
+    const tsconfigFor = (dir) => {
+        if (tsconfigByDir.has(dir))
+            return tsconfigByDir.get(dir);
+        const own = ["tsconfig.json", "jsconfig.json"].map((name) => join(dir, name)).find(isFile);
+        const parent = dirname(dir);
+        const found = own ?? (parent === dir ? undefined : tsconfigFor(parent));
+        tsconfigByDir.set(dir, found);
+        return found;
+    };
+    /** An `extends` entry's file: a path relative to the config, or a package found in `node_modules`. */
+    const extendedConfig = (from, name) => {
+        const withJson = (path) => isFile(path) ? path : isFile(`${path}.json`) ? `${path}.json` : undefined;
+        if (name.startsWith("./") || name.startsWith("../") || isAbsolute(name))
+            return withJson(join(dirname(from), name));
+        for (let dir = dirname(from);; dir = dirname(dir)) {
+            const target = join(dir, "node_modules", name);
+            const direct = withJson(target);
+            if (direct !== undefined)
+                return direct;
+            const manifest = readJsonc(join(target, "package.json"));
+            const field = manifest?.tsconfig;
+            const nested = typeof field === "string"
+                ? withJson(join(target, field))
+                : withJson(join(target, "tsconfig"));
+            if (nested !== undefined)
+                return nested;
+            if (dirname(dir) === dir)
+                return undefined;
+        }
+    };
+    /** The `paths`, `baseUrl` and import-emit options a config ends up with after its `extends` chain. */
+    const pathsConfig = (file, seen = new Set()) => {
+        if (configs.has(file))
+            return configs.get(file);
+        if (seen.has(file) || seen.size >= MAX_EXTENDS)
+            return undefined;
+        const config = readJsonc(file);
+        let inherited;
+        let importEmit = {};
+        const extended = config?.extends;
+        for (const name of typeof extended === "string"
+            ? [extended]
+            : Array.isArray(extended)
+                ? extended
+                : []) {
+            if (typeof name !== "string")
+                continue;
+            const base = extendedConfig(file, name);
+            const parent = base === undefined ? undefined : pathsConfig(base, new Set([...seen, file]));
+            importEmit =
+                importEmit === undefined || parent?.importEmit === undefined
+                    ? undefined
+                    : { ...importEmit, ...parent.importEmit };
+            if (parent === undefined)
+                continue;
+            inherited = {
+                paths: parent.paths.length > 0 ? parent.paths : (inherited?.paths ?? []),
+                baseUrl: parent.baseUrl ?? inherited?.baseUrl,
+                pathsBase: parent.paths.length > 0 ? parent.pathsBase : (inherited?.pathsBase ?? parent.pathsBase),
+                importEmit,
+            };
+        }
+        const options = record(config?.compilerOptions);
+        if (importEmit !== undefined) {
+            for (const key of IMPORT_EMIT_OPTIONS)
+                if (options?.[key] !== undefined)
+                    importEmit = { ...importEmit, [key]: options[key] };
+        }
+        const baseUrl = typeof options?.baseUrl === "string"
+            ? join(dirname(file), options.baseUrl)
+            : inherited?.baseUrl;
+        const ownPaths = record(options?.paths);
+        const paths = ownPaths === undefined
+            ? (inherited?.paths ?? [])
+            : Object.entries(ownPaths).map(([pattern, targets]) => [
+                pattern,
+                Array.isArray(targets)
+                    ? targets.filter((t) => typeof t === "string")
+                    : [],
+            ]);
+        const pathsBase = baseUrl ?? (ownPaths === undefined ? (inherited?.pathsBase ?? dirname(file)) : dirname(file));
+        const resolved = config === undefined ? undefined : { paths, baseUrl, pathsBase, importEmit };
+        configs.set(file, resolved);
+        return resolved;
+    };
+    // Keyed by config, not directory: every package name reaches here, from every folder of the project.
+    const aliases = new Map();
+    const viaTsconfig = (fromFile, specifier) => {
+        const tsconfig = tsconfigFor(dirname(fromFile));
+        if (tsconfig === undefined)
+            return undefined;
+        const key = `${tsconfig}\0${specifier}`;
+        if (aliases.has(key))
+            return aliases.get(key);
+        const found = aliasTarget(tsconfig, specifier);
+        aliases.set(key, found);
+        return found;
+    };
+    const aliasTarget = (tsconfig, specifier) => pathsRule(tsconfig, specifier)?.found;
+    /** The nearest package.json at or above `dir`: the package scope Node reads `imports` from. */
+    const packageFor = (dir) => {
+        if (packageByDir.has(dir))
+            return packageByDir.get(dir);
+        const own = join(dir, "package.json");
+        const parent = dirname(dir);
+        const found = isFile(own) ? own : parent === dir ? undefined : packageFor(parent);
+        packageByDir.set(dir, found);
+        return found;
+    };
+    const importTarget = (target, star) => {
+        if (typeof target === "string")
+            return target.startsWith("./") ? target.replaceAll("*", star ?? "") : undefined;
+        if (Array.isArray(target)) {
+            for (const entry of target) {
+                const found = importTarget(entry, star);
+                if (found !== undefined)
+                    return found;
+            }
+            return undefined;
+        }
+        const conditions = record(target);
+        if (conditions === undefined)
+            return undefined;
+        for (const [condition, value] of Object.entries(conditions)) {
+            if (CONDITIONS.has(condition))
+                return importTarget(value, star);
+        }
+        return undefined;
+    };
+    const importsRule = (fromFile, specifier) => {
+        const manifestPath = packageFor(dirname(fromFile));
+        if (manifestPath === undefined)
+            return undefined;
+        if (!manifests.has(manifestPath))
+            manifests.set(manifestPath, readJsonc(manifestPath));
+        const imports = record(manifests.get(manifestPath)?.imports);
+        if (imports === undefined)
+            return undefined;
+        const keys = Object.keys(imports);
+        const match = matchPattern(keys, specifier);
+        if (match === undefined)
+            return undefined;
+        const template = importTarget(imports[match.pattern], STAR);
+        if (template === undefined)
+            return undefined;
+        const base = dirname(manifestPath);
+        const written = join(base, template.replaceAll(STAR, match.star ?? ""));
+        const found = probe(written, exists);
+        return found === undefined
+            ? undefined
+            : { key: match.pattern, keys, base, templates: [template], written, found };
+    };
+    const viaImports = (fromFile, specifier) => importsRule(fromFile, specifier)?.found;
+    const tsconfigRule = (fromFile, specifier) => {
+        const tsconfig = tsconfigFor(dirname(fromFile));
+        return tsconfig === undefined ? undefined : pathsRule(tsconfig, specifier);
+    };
+    const pathsRule = (tsconfig, specifier) => {
+        const config = pathsConfig(tsconfig);
+        if (config === undefined)
+            return undefined;
+        const keys = config.paths.map(([pattern]) => pattern);
+        const match = matchPattern(keys, specifier);
+        if (match === undefined) {
+            if (config.baseUrl === undefined)
+                return undefined;
+            const written = join(config.baseUrl, specifier);
+            const found = probe(written, exists);
+            return found === undefined
+                ? undefined
+                : { key: undefined, keys, base: config.baseUrl, templates: [STAR], written, found };
+        }
+        // TypeScript permits at most one wildcard in each substitution, as in the alias key.
+        const targets = (config.paths.find(([pattern]) => pattern === match.pattern)?.[1] ?? []).filter((target) => target.indexOf("*") === target.lastIndexOf("*"));
+        for (const target of targets) {
+            const written = join(config.pathsBase, target.replaceAll("*", match.star ?? ""));
+            const found = probe(written, exists);
+            if (found === undefined)
+                continue;
+            const templates = targets.map((t) => t.replaceAll("*", STAR));
+            return { key: match.pattern, keys, base: config.pathsBase, templates, written, found };
+        }
+        return undefined;
+    };
+    const respell = (fromFile, specifier, file) => {
+        if (/^\.\.?(?:\/|$)/.test(specifier) || isAbsolute(specifier))
+            return undefined;
+        const rule = (specifier.startsWith("#") ? importsRule(fromFile, specifier) : undefined) ??
+            tsconfigRule(fromFile, specifier);
+        if (rule === undefined)
+            return undefined;
+        const spelled = sameStyle(rule.written, rule.found, file);
+        for (const template of rule.templates) {
+            const at = template.indexOf(STAR);
+            if (at === -1)
+                continue;
+            // An empty head still ends at a folder boundary: `src2/x` is not under a `baseUrl` of `src`.
+            const prefix = join(rule.base, template.slice(0, at) || "./");
+            const suffix = template.slice(at + STAR.length);
+            if (!spelled.startsWith(prefix) || !spelled.endsWith(suffix))
+                continue;
+            if (spelled.length < prefix.length + suffix.length)
+                continue;
+            const star = spelled
+                .slice(prefix.length, spelled.length - suffix.length)
+                .replaceAll("\\", "/");
+            if (star === "" || star.startsWith("/"))
+                continue;
+            const keyAt = rule.key?.indexOf("*") ?? 0;
+            if (keyAt === -1)
+                continue;
+            const next = rule.key === undefined
+                ? star
+                : `${rule.key.slice(0, keyAt)}${star}${rule.key.slice(keyAt + 1)}`;
+            // The rewritten name must take the same route: another, longer pattern would claim it.
+            if (matchPattern(rule.keys, next)?.pattern !== rule.key)
+                continue;
+            return next;
+        }
+        return undefined;
+    };
+    const resolved = new Map();
+    const resolve = (fromFile, specifier) => {
+        // Every rule below reads only the importing file's directory, so the answer is the directory's.
+        const key = `${dirname(fromFile)}\0${specifier}`;
+        if (resolved.has(key))
+            return resolved.get(key);
+        const path = resolveFrom(fromFile, specifier);
+        resolved.set(key, path);
+        return path;
+    };
+    const pathPatterns = (dir) => {
+        const tsconfig = tsconfigFor(dir);
+        const config = tsconfig === undefined ? undefined : pathsConfig(tsconfig);
+        return (config?.paths ?? []).map(([pattern]) => pattern);
+    };
+    const keepsTypeOnlyImports = (file) => {
+        const tsconfig = tsconfigFor(dirname(file));
+        if (tsconfig === undefined)
+            return false;
+        const emit = pathsConfig(tsconfig)?.importEmit;
+        if (emit === undefined)
+            return true;
+        return (emit.verbatimModuleSyntax === true ||
+            emit.preserveValueImports === true ||
+            emit.importsNotUsedAsValues === "preserve" ||
+            emit.importsNotUsedAsValues === "error");
+    };
+    return Object.assign(resolve, { respell, pathPatterns, keepsTypeOnlyImports });
+    function resolveFrom(fromFile, specifier) {
+        let found;
+        if (specifier.startsWith("./") ||
+            specifier.startsWith("../") ||
+            specifier === "." ||
+            specifier === "..")
+            found = probe(join(dirname(fromFile), specifier), exists);
+        else if (isAbsolute(specifier))
+            found = probe(specifier, exists);
+        // A `#` name is a package.json import first; a tsconfig may still map it.
+        else if (specifier.startsWith("#"))
+            found = viaImports(fromFile, specifier) ?? viaTsconfig(fromFile, specifier);
+        else
+            found = viaTsconfig(fromFile, specifier);
+        if (found === undefined)
+            return undefined;
+        const path = real(found);
+        return /[\\/]node_modules[\\/]/.test(path) ? undefined : path;
+    }
+}
+//# sourceMappingURL=project-specifiers.js.map