typia 13.1.1 → 13.2.0

package/lib/executable/TypiaGenerateWizard.js

@@ -17,8 +17,10 @@ const commander_1 = require("commander");
 const fs_1 = __importDefault(require("fs"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const module_1 = require("module");
+const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const tinyglobby_1 = require("tinyglobby");
+const FileSystemIdentity_1 = require("./FileSystemIdentity");
 var TypiaGenerateWizard;
 (function (TypiaGenerateWizard) {
     function generate() {
@@ -94,21 +96,50 @@ var TypiaGenerateWizard;
         return __awaiter(this, void 0, void 0, function* () {
             location.output = path_1.default.resolve(location.output);
             location.project = resolveProjectConfigFile(location.project);
+            const policy = new FileSystemIdentity_1.FileSystemIdentity.Policy();
+            const outputProbe = yield nearestExistingAncestor(location.output);
+            yield ensureExistingDirectoryPath({
+                label: "output parent path",
+                directory: outputProbe,
+            });
+            policy.observe(yield FileSystemIdentity_1.FileSystemIdentity.probeDirectory(outputProbe), outputProbe);
+            policy.observe(yield FileSystemIdentity_1.FileSystemIdentity.inspectDirectory(path_1.default.dirname(location.project)), path_1.default.dirname(location.project));
             const entries = location.files.length === 0
-                ? yield prepareDirectoryInput(location)
-                : yield prepareFileInputs(location);
+                ? yield prepareDirectoryInput(location, policy)
+                : yield prepareFileInputs(location, policy);
+            const identity = policy.get();
+            yield inspectTargetDirectories({
+                identity,
+                output: location.output,
+                targets: entries.map((entry) => entry.target),
+            });
             const binary = resolveTsgoBinary();
             const cwd = path_1.default.dirname(location.project);
-            const transformed = transformProject({
-                binary,
-                cwd,
-                tsconfig: location.project,
+            const temporaryProject = yield createTemporaryProject({
+                entries,
+                project: location.project,
             });
-            const outputByKey = indexTransformedOutputs(transformed);
+            let transformed;
+            try {
+                transformed = transformProject({
+                    binary,
+                    cwd,
+                    projectRoot: cwd,
+                    tsconfig: temporaryProject.config,
+                });
+            }
+            finally {
+                yield fs_1.default.promises.rm(temporaryProject.directory, {
+                    force: true,
+                    recursive: true,
+                });
+            }
+            const outputByKey = indexTransformedOutputs(transformed, identity);
             const outputs = entries.map((entry) => {
                 const output = getTransformedOutput({
                     cwd,
                     entry,
+                    identity,
                     outputByKey,
                 });
                 if (output === undefined) {
@@ -118,19 +149,40 @@ var TypiaGenerateWizard;
             });
             yield ensureOutputDirectory(location.output);
             yield ensureTargetDirectories({
+                identity,
                 output: location.output,
                 targets: outputs.map(({ entry }) => entry.target),
             });
             yield ensurePhysicalTargets({
+                identity,
                 output: location.output,
                 entries: outputs.map(({ entry }) => entry),
             });
-            yield ensureTargetFiles(outputs.map(({ entry }) => entry));
+            yield ensureTargetFiles(outputs.map(({ entry }) => entry), identity);
             for (const { entry, output } of outputs) {
                 yield fs_1.default.promises.writeFile(entry.target, formatOutput(output), "utf8");
             }
         });
     }
+    function createTemporaryProject(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const directory = yield fs_1.default.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "typia-generate-project-"));
+            const config = path_1.default.join(directory, "tsconfig.json");
+            try {
+                yield fs_1.default.promises.writeFile(config, JSON.stringify({
+                    extends: props.project,
+                    exclude: [],
+                    files: props.entries.map((entry) => compilerInputPath(entry.file)),
+                    include: [],
+                }), "utf8");
+                return { config, directory };
+            }
+            catch (error) {
+                yield fs_1.default.promises.rm(directory, { force: true, recursive: true });
+                throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to prepare the bounded input project: ${formatUnknownError(error)}`);
+            }
+        });
+    }
     function ensureOutputDirectory(output) {
         return __awaiter(this, void 0, void 0, function* () {
             if (fs_1.default.existsSync(output) === false) {
@@ -147,13 +199,28 @@ var TypiaGenerateWizard;
     }
     function ensureTargetDirectories(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            const directories = new Map();
-            for (const target of props.targets) {
-                const directory = path_1.default.dirname(target);
-                directories.set(filesystemKey(directory), directory);
+            yield inspectTargetDirectories(props);
+            const directories = targetDirectories(props);
+            for (const directory of directories.values()) {
+                try {
+                    yield fs_1.default.promises.mkdir(directory, { recursive: true });
+                }
+                catch (exp) {
+                    throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to create output parent directory ${directory}: ${formatUnknownError(exp)}`);
+                }
+                yield ensureExistingDirectory({
+                    label: "output parent path",
+                    directory,
+                });
             }
+        });
+    }
+    function inspectTargetDirectories(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const directories = targetDirectories(props);
             for (const directory of directories.values()) {
                 yield ensureOutputAncestorDirectories({
+                    identity: props.identity,
                     output: props.output,
                     directory,
                 });
@@ -164,20 +231,16 @@ var TypiaGenerateWizard;
                     });
                 }
             }
-            for (const directory of directories.values()) {
-                try {
-                    yield fs_1.default.promises.mkdir(directory, { recursive: true });
-                }
-                catch (exp) {
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to create output parent directory ${directory}: ${formatUnknownError(exp)}`);
-                }
-                yield ensureExistingDirectory({
-                    label: "output parent path",
-                    directory,
-                });
-            }
         });
     }
+    function targetDirectories(props) {
+        const directories = new Map();
+        for (const target of props.targets) {
+            const directory = path_1.default.dirname(target);
+            directories.set(props.identity.filesystemKey(directory), directory);
+        }
+        return directories;
+    }
     function ensureCreatableDirectory(directory) {
         return __awaiter(this, void 0, void 0, function* () {
             const parent = yield nearestExistingAncestor(directory);
@@ -204,7 +267,7 @@ var TypiaGenerateWizard;
         return __awaiter(this, void 0, void 0, function* () {
             const output = path_1.default.resolve(props.output);
             const directory = path_1.default.resolve(props.directory);
-            if (isSameOrChildPath(directory, output) === false) {
+            if (props.identity.contains(directory, output) === false) {
                 throw new URIError(`Error on TypiaGenerateWizard.generate(): output parent path escapes output directory: ${props.directory}`);
             }
             const relative = path_1.default.relative(output, directory);
@@ -247,7 +310,7 @@ var TypiaGenerateWizard;
             for (const segment of relative === "" ? [] : relative.split(path_1.default.sep)) {
                 current = path_1.default.join(current, segment);
                 yield ensureExistingDirectorySegment({
-                    label: filesystemKey(current) === filesystemKey(directory)
+                    label: path_1.default.normalize(current) === path_1.default.normalize(directory)
                         ? props.label
                         : `${props.label} ancestor`,
                     directory: current,
@@ -271,33 +334,33 @@ var TypiaGenerateWizard;
             const output = yield fs_1.default.promises.realpath(props.output);
             const inputs = new Set();
             for (const entry of props.entries) {
-                inputs.add(filesystemKey(yield fs_1.default.promises.realpath(entry.file)));
+                inputs.add(props.identity.filesystemKey(yield fs_1.default.promises.realpath(entry.file)));
             }
             for (const entry of props.entries) {
                 const parent = path_1.default.dirname(entry.target);
                 const directory = yield fs_1.default.promises.realpath(parent);
-                if (isSameOrChildPath(directory, output) === false) {
+                if (props.identity.contains(directory, output) === false) {
                     throw new URIError(`Error on TypiaGenerateWizard.generate(): output parent path escapes output directory through a symbolic link: ${parent}`);
                 }
                 const target = path_1.default.join(directory, path_1.default.basename(entry.target));
-                if (inputs.has(filesystemKey(target))) {
+                if (inputs.has(props.identity.filesystemKey(target))) {
                     throw new URIError(`Error on TypiaGenerateWizard.generate(): output file would overwrite input file through a symbolic link: ${entry.target}`);
                 }
             }
         });
     }
-    function ensureTargetFiles(entries) {
+    function ensureTargetFiles(entries, identity) {
         return __awaiter(this, void 0, void 0, function* () {
             const inputs = new Set();
             const files = new Map();
             for (const entry of entries) {
-                inputs.add(fileIdentityKey(yield fs_1.default.promises.stat(entry.file)));
-                files.set(filesystemKey(entry.target), entry);
+                inputs.add(fileIdentityKey(yield fs_1.default.promises.stat(entry.file, { bigint: true }), yield fs_1.default.promises.realpath(entry.file)));
+                files.set(identity.filesystemKey(entry.target), entry);
             }
             for (const entry of files.values()) {
                 let stat;
                 try {
-                    stat = yield fs_1.default.promises.lstat(entry.target);
+                    stat = yield fs_1.default.promises.lstat(entry.target, { bigint: true });
                 }
                 catch (exp) {
                     if (isMissingFileError(exp)) {
@@ -308,16 +371,16 @@ var TypiaGenerateWizard;
                 if (stat.isFile() === false) {
                     throw new URIError(`Error on TypiaGenerateWizard.generate(): output file path is not a regular file: ${entry.target}`);
                 }
-                if (inputs.has(fileIdentityKey(stat))) {
+                if (inputs.has(fileIdentityKey(stat, yield fs_1.default.promises.realpath(entry.target)))) {
                     throw new URIError(`Error on TypiaGenerateWizard.generate(): output file would overwrite input file through a physical file alias: ${entry.target}`);
                 }
-                if (stat.nlink > 1) {
+                if (stat.nlink > BigInt(1)) {
                     throw new URIError(`Error on TypiaGenerateWizard.generate(): output file has multiple hard links: ${entry.target}`);
                 }
             }
         });
     }
-    function prepareDirectoryInput(location) {
+    function prepareDirectoryInput(location, policy) {
         return __awaiter(this, void 0, void 0, function* () {
             if (location.input === undefined) {
                 throw new URIError("Error on TypiaGenerateWizard.generate(): input path is required.");
@@ -329,15 +392,17 @@ var TypiaGenerateWizard;
             if ((yield isDirectory(input)) === false) {
                 throw new URIError("Error on TypiaGenerateWizard.generate(): input path is not a directory.");
             }
+            const inputReal = yield fs_1.default.promises.realpath(input);
+            const outputReal = yield optionalRealPath(location.output);
             const files = [];
             yield gather({
-                location: {
-                    input,
-                    output: location.output,
-                },
                 container: files,
                 from: input,
-                to: location.output,
+                inputReal,
+                outputReal,
+                policy,
+                visitedDirectories: new Set(),
+                visitedFiles: new Set(),
             });
             return files.map((file) => ({
                 file,
@@ -345,29 +410,31 @@ var TypiaGenerateWizard;
             }));
         });
     }
-    function prepareFileInputs(location) {
+    function prepareFileInputs(location, policy) {
         return __awaiter(this, void 0, void 0, function* () {
             const targets = new Set();
             const output = [];
-            for (const input of yield expandFileInputs(location.files, location.output)) {
+            for (const input of yield expandFileInputs(location.files, location.output, policy)) {
                 const file = path_1.default.resolve(input);
+                policy.observe(yield FileSystemIdentity_1.FileSystemIdentity.inspectDirectory(path_1.default.dirname(file)), path_1.default.dirname(file));
+                const identity = policy.get();
                 if (fs_1.default.existsSync(file) === false) {
                     throw new URIError(`Error on TypiaGenerateWizard.generate(): input file does not exist: ${input}`);
                 }
                 else if ((yield isFile(file)) === false) {
                     throw new URIError(`Error on TypiaGenerateWizard.generate(): input path is not a file: ${input}`);
                 }
-                else if (isDeclarationFile(file)) {
+                else if (identity.isDeclarationFile(file)) {
                     continue;
                 }
-                else if (isSupportedExtension(file) === false) {
+                else if (identity.isSupportedExtension(file) === false) {
                     throw new URIError(`Error on TypiaGenerateWizard.generate(): input file is not a supported TypeScript source: ${input}`);
                 }
                 const target = path_1.default.join(location.output, path_1.default.basename(file));
-                if (isSamePath(file, target)) {
+                if (identity.isSamePath(file, target)) {
                     throw new URIError(`Error on TypiaGenerateWizard.generate(): output file would overwrite input file: ${input}`);
                 }
-                const key = filesystemKey(target);
+                const key = identity.filesystemKey(target);
                 if (targets.has(key)) {
                     throw new URIError(`Error on TypiaGenerateWizard.generate(): duplicate output filename for ${target}`);
                 }
@@ -380,26 +447,34 @@ var TypiaGenerateWizard;
             return output;
         });
     }
-    function expandFileInputs(inputs, directory) {
+    function expandFileInputs(inputs, directory, policy) {
         return __awaiter(this, void 0, void 0, function* () {
             const output = [];
             for (const input of inputs) {
                 const pattern = toGlobPattern(input);
                 if ((0, tinyglobby_1.isDynamicPattern)(pattern, { caseSensitiveMatch: true })) {
+                    const searchDirectory = yield globSearchDirectory(input);
+                    const caseSensitive = yield FileSystemIdentity_1.FileSystemIdentity.inspectDirectory(searchDirectory);
+                    if (caseSensitive === undefined) {
+                        throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to determine filesystem case behavior for input pattern base ${searchDirectory}.`);
+                    }
+                    policy.observe(caseSensitive, searchDirectory);
+                    const identity = policy.get();
                     const matches = yield (0, tinyglobby_1.glob)(pattern, {
                         absolute: true,
-                        caseSensitiveMatch: isCaseSensitive(),
+                        caseSensitiveMatch: identity.caseSensitive,
                         cwd: process.cwd(),
                         onlyFiles: true,
                     });
                     if (matches.length === 0) {
                         throw new URIError(`Error on TypiaGenerateWizard.generate(): input pattern does not match any files: ${input}`);
                     }
-                    output.push(...excludeOutputFiles(matches, directory).filter(isSupportedExtension));
+                    output.push(...excludeOutputFiles(matches, directory, identity).filter((file) => identity.isSupportedExtension(file)));
                 }
                 else {
                     const file = path_1.default.resolve(input);
-                    if (isSameOrChildPath(file, directory) === false) {
+                    policy.observe(yield FileSystemIdentity_1.FileSystemIdentity.inspectDirectory(path_1.default.dirname(file)), path_1.default.dirname(file));
+                    if (policy.get().contains(file, directory) === false) {
                         output.push(file);
                     }
                 }
@@ -407,8 +482,22 @@ var TypiaGenerateWizard;
             return output;
         });
     }
-    function excludeOutputFiles(files, directory) {
-        return files.filter((file) => isSameOrChildPath(file, directory) === false);
+    function excludeOutputFiles(files, directory, identity) {
+        return files.filter((file) => identity.contains(file, directory) === false);
+    }
+    function globSearchDirectory(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let current = path_1.default.resolve(input);
+            while ((0, tinyglobby_1.isDynamicPattern)(toGlobPattern(current), { caseSensitiveMatch: true })) {
+                const parent = path_1.default.dirname(current);
+                if (parent === current)
+                    break;
+                current = parent;
+            }
+            if (fs_1.default.existsSync(current) && (yield isDirectory(current)))
+                return current;
+            return nearestExistingAncestor(path_1.default.dirname(current));
+        });
     }
     function toGlobPattern(input) {
         return input.replace(/\\/g, "/");
@@ -418,6 +507,7 @@ var TypiaGenerateWizard;
         const result = new TtscCompiler({
             binary: props.binary,
             cwd: props.cwd,
+            projectRoot: props.projectRoot,
             tsconfig: props.tsconfig,
         }).transform();
         if (result.type === "success") {
@@ -534,7 +624,7 @@ var TypiaGenerateWizard;
     function resolveFromRoots(request, roots) {
         for (const root of roots) {
             try {
-                return require.resolve(request, { paths: [root] });
+                return (0, module_1.createRequire)(path_1.default.join(root, "package.json")).resolve(request);
             }
             catch (_a) {
                 continue;
@@ -556,68 +646,115 @@ var TypiaGenerateWizard;
     }
     function gather(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (isSamePath(props.from, props.location.output))
+            const currentReal = yield resolveTraversalPath(props.from);
+            if (props.outputReal !== undefined &&
+                isPhysicalSameOrChildPath(currentReal, props.outputReal))
+                return;
+            ensurePhysicalInputContainment({
+                file: props.from,
+                input: props.inputReal,
+                real: currentReal,
+            });
+            const currentStat = yield fs_1.default.promises.stat(props.from, {
+                bigint: true,
+            });
+            const directoryIdentity = fileIdentityKey(currentStat, currentReal);
+            if (props.visitedDirectories.has(directoryIdentity)) {
+                const lexicalStat = yield fs_1.default.promises.lstat(props.from);
+                if (lexicalStat.isSymbolicLink()) {
+                    throw new URIError(`Error on TypiaGenerateWizard.generate(): input directory link revisits a physical directory: ${props.from}.`);
+                }
                 return;
-            for (const file of yield fs_1.default.promises.readdir(props.from)) {
-                const next = path_1.default.join(props.from, file);
-                const stat = yield fs_1.default.promises.stat(next);
+            }
+            props.visitedDirectories.add(directoryIdentity);
+            props.policy.observe(yield FileSystemIdentity_1.FileSystemIdentity.inspectDirectory(props.from), props.from);
+            const identity = props.policy.get();
+            const entries = yield Promise.all((yield fs_1.default.promises.readdir(props.from)).map((name) => __awaiter(this, void 0, void 0, function* () {
+                const file = path_1.default.join(props.from, name);
+                try {
+                    return { file, name, stat: yield fs_1.default.promises.lstat(file) };
+                }
+                catch (error) {
+                    throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to inspect input path ${file}: ${formatUnknownError(error)}`);
+                }
+            })));
+            entries.sort((x, y) => {
+                const linkOrder = Number(x.stat.isSymbolicLink()) - Number(y.stat.isSymbolicLink());
+                return linkOrder !== 0
+                    ? linkOrder
+                    : Buffer.compare(Buffer.from(x.name), Buffer.from(y.name));
+            });
+            for (const entry of entries) {
+                let stat;
+                let real;
+                try {
+                    stat = yield fs_1.default.promises.stat(entry.file, { bigint: true });
+                    real = yield fs_1.default.promises.realpath(entry.file);
+                }
+                catch (error) {
+                    throw new URIError(`Error on TypiaGenerateWizard.generate(): input link target is missing or unreadable: ${entry.file}: ${formatUnknownError(error)}`);
+                }
+                if (props.outputReal !== undefined &&
+                    isPhysicalSameOrChildPath(real, props.outputReal))
+                    continue;
+                ensurePhysicalInputContainment({
+                    file: entry.file,
+                    input: props.inputReal,
+                    real,
+                });
                 if (stat.isDirectory()) {
-                    yield gather({
-                        location: props.location,
-                        container: props.container,
-                        from: next,
-                        to: path_1.default.join(props.to, file),
-                    });
+                    yield gather(Object.assign(Object.assign({}, props), { from: entry.file }));
                     continue;
                 }
-                if (isSupportedExtension(file)) {
-                    props.container.push(next);
-                }
+                if (stat.isFile() === false ||
+                    identity.isSupportedExtension(entry.name) === false)
+                    continue;
+                const fileIdentity = fileIdentityKey(stat, real);
+                if (props.visitedFiles.has(fileIdentity))
+                    continue;
+                props.visitedFiles.add(fileIdentity);
+                props.container.push(entry.file);
             }
         });
     }
-    function isSupportedExtension(filename) {
-        const normalized = isCaseSensitive()
-            ? filename
-            : filename.toLowerCase();
-        return TS_PATTERN.test(normalized) && !DTS_PATTERN.test(normalized);
-    }
-    function isDeclarationFile(filename) {
-        const normalized = isCaseSensitive()
-            ? filename
-            : filename.toLowerCase();
-        return DTS_PATTERN.test(normalized);
-    }
     function formatOutput(output) {
         return output.startsWith("// @ts-nocheck")
             ? output
             : `// @ts-nocheck\n${output}`;
     }
-    function indexTransformedOutputs(outputs) {
+    function indexTransformedOutputs(outputs, identity) {
         const map = new Map();
         for (const [file, output] of Object.entries(outputs)) {
-            map.set(projectFileKey(file), output);
+            const key = identity.projectFileKey(file);
+            if (map.has(key)) {
+                throw new URIError(`Error on TypiaGenerateWizard.generate(): transformed outputs have ambiguous filesystem identities: ${file}.`);
+            }
+            map.set(key, output);
         }
         return map;
     }
     function getTransformedOutput(props) {
-        const output = props.outputByKey.get(projectFileKey(projectKey(props.cwd, props.entry.file)));
+        const output = props.outputByKey.get(props.identity.projectFileKey(projectKey(props.cwd, props.entry.file)));
         if (output !== undefined) {
             return output;
         }
+        const compilerFile = compilerInputPath(props.entry.file);
+        if (props.identity.isSamePath(compilerFile, props.entry.file) === false &&
+            props.identity.contains(compilerFile, props.cwd)) {
+            const compiled = props.outputByKey.get(props.identity.projectFileKey(projectKey(props.cwd, compilerFile)));
+            if (compiled !== undefined)
+                return compiled;
+        }
         const real = resolveRealPath(props.entry.file);
-        if (isSamePath(real, props.entry.file) ||
-            isSameOrChildPath(real, props.cwd) === false) {
+        if (props.identity.isSamePath(real, props.entry.file) ||
+            props.identity.contains(real, props.cwd) === false) {
             return undefined;
         }
-        return props.outputByKey.get(projectFileKey(projectKey(props.cwd, real)));
+        return props.outputByKey.get(props.identity.projectFileKey(projectKey(props.cwd, real)));
     }
     function projectKey(root, file) {
         return path_1.default.relative(root, file).replace(/\\/g, "/");
     }
-    function projectFileKey(file) {
-        return isCaseSensitive() ? file : file.toLowerCase();
-    }
     function resolveRealPath(file) {
         try {
             return fs_1.default.realpathSync(file);
@@ -626,23 +763,50 @@ var TypiaGenerateWizard;
             return file;
         }
     }
-    function isSamePath(x, y) {
-        return filesystemKey(x) === filesystemKey(y);
+    function compilerInputPath(file) {
+        try {
+            if (fs_1.default.lstatSync(file).isSymbolicLink()) {
+                return path_1.default.join(resolveRealPath(path_1.default.dirname(file)), path_1.default.basename(file));
+            }
+        }
+        catch (_a) {
+            return file;
+        }
+        return resolveRealPath(file);
     }
-    function isSameOrChildPath(file, directory) {
-        const fileKey = filesystemKey(path_1.default.resolve(file));
-        const directoryKey = filesystemKey(path_1.default.resolve(directory));
-        const directoryPrefix = directoryKey.endsWith(path_1.default.sep)
-            ? directoryKey
-            : `${directoryKey}${path_1.default.sep}`;
-        return fileKey === directoryKey || fileKey.startsWith(directoryPrefix);
+    function optionalRealPath(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield fs_1.default.promises.realpath(file);
+            }
+            catch (error) {
+                if (isMissingFileError(error))
+                    return undefined;
+                throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to resolve path ${file}: ${formatUnknownError(error)}`);
+            }
+        });
+    }
+    function resolveTraversalPath(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield fs_1.default.promises.realpath(file);
+            }
+            catch (error) {
+                throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to resolve input path ${file}: ${formatUnknownError(error)}`);
+            }
+        });
     }
-    function filesystemKey(file) {
-        const normalized = path_1.default.normalize(file);
-        return isCaseSensitive() ? normalized : normalized.toLowerCase();
+    function ensurePhysicalInputContainment(props) {
+        if (isPhysicalSameOrChildPath(props.real, props.input))
+            return;
+        throw new URIError(`Error on TypiaGenerateWizard.generate(): input path resolves outside the input directory: ${props.file}.`);
     }
-    function isCaseSensitive() {
-        return process.platform !== "win32" && process.platform !== "darwin";
+    function isPhysicalSameOrChildPath(file, directory) {
+        const relative = path_1.default.relative(directory, file);
+        return (relative === "" ||
+            (relative !== ".." &&
+                relative.startsWith(`..${path_1.default.sep}`) === false &&
+                path_1.default.isAbsolute(relative) === false));
     }
     function isMissingFileError(exp) {
         return (typeof exp === "object" &&
@@ -650,8 +814,12 @@ var TypiaGenerateWizard;
             "code" in exp &&
             exp.code === "ENOENT");
     }
-    function fileIdentityKey(stat) {
-        return `${stat.dev}:${stat.ino}`;
+    /**
+     * Delegates to {@link FileSystemIdentity.identityKey}, which owns the rule and
+     * carries the reasoning for reading the identity as a `bigint`.
+     */
+    function fileIdentityKey(stat, realpath) {
+        return FileSystemIdentity_1.FileSystemIdentity.identityKey(stat, realpath);
     }
     function formatDiagnostics(diagnostics) {
         return diagnostics.length === 0
@@ -681,6 +849,4 @@ var TypiaGenerateWizard;
         return String(error);
     }
 })(TypiaGenerateWizard || (exports.TypiaGenerateWizard = TypiaGenerateWizard = {}));
-const TS_PATTERN = /\.[cm]?tsx?$/;
-const DTS_PATTERN = /\.d\.[cm]?tsx?$/;
 //# sourceMappingURL=TypiaGenerateWizard.js.map