cluaupp 0.1.4 → 0.2.0

package/generated/utils/project.js

@@ -0,0 +1,491 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.collectCpp = collectCpp;
+exports.build = build;
+exports.init = init;
+exports.watch = watch;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const package_info_js_1 = require("../package-info.js");
+const preprocess_js_1 = require("../preprocess.js");
+const intellisense_js_1 = require("../intellisense.js");
+const process_orchestrator_js_1 = require("./process-orchestrator.js");
+const rojo_mapper_js_1 = require("./rojo-mapper.js");
+const transpile_js_1 = require("../transpile.js");
+const safe_paths_js_1 = require("./safe-paths.js");
+function readProjectConfig(file) {
+    const raw = JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return {};
+    }
+    const data = raw;
+    const parsed = {};
+    if (typeof data.rootDir === "string") {
+        parsed.rootDir = data.rootDir;
+    }
+    if (typeof data.outDir === "string") {
+        parsed.outDir = data.outDir;
+    }
+    if (typeof data.strict === "boolean") {
+        parsed.strict = data.strict;
+    }
+    if (typeof data.architecture === "boolean") {
+        parsed.architecture = data.architecture;
+    }
+    return parsed;
+}
+function loadConfig(root) {
+    const defaults = { rootDir: "src", outDir: "out", strict: false, architecture: false };
+    const configNames = ["cluaupp.config.json", "cluau.config.json"];
+    let parsed = {};
+    for (const name of configNames) {
+        const file = node_path_1.default.join(root, name);
+        if (node_fs_1.default.existsSync(file)) {
+            parsed = readProjectConfig(file);
+            break;
+        }
+    }
+    const config = {
+        ...defaults,
+        ...parsed,
+        rootDir: (0, safe_paths_js_1.safeProjectSubdir)(parsed.rootDir || defaults.rootDir, defaults.rootDir, "rootDir"),
+        outDir: (0, safe_paths_js_1.safeProjectSubdir)(parsed.outDir || defaults.outDir, defaults.outDir, "outDir"),
+    };
+    if (config.rootDir === config.outDir) {
+        throw new Error("cluaupp: rootDir and outDir must be different");
+    }
+    const absRoot = node_path_1.default.resolve(root);
+    (0, safe_paths_js_1.assertInside)(absRoot, node_path_1.default.join(absRoot, config.rootDir), "rootDir");
+    (0, safe_paths_js_1.assertInside)(absRoot, node_path_1.default.join(absRoot, config.outDir), "outDir");
+    return config;
+}
+function copyDir(from, to) {
+    node_fs_1.default.mkdirSync(to, { recursive: true });
+    for (const entry of node_fs_1.default.readdirSync(from, { withFileTypes: true })) {
+        const src = node_path_1.default.join(from, entry.name);
+        const dest = node_path_1.default.join(to, entry.name);
+        if (entry.isDirectory()) {
+            copyDir(src, dest);
+        }
+        else {
+            node_fs_1.default.copyFileSync(src, dest);
+        }
+    }
+}
+function tryRm(target, root) {
+    if (root && !(0, safe_paths_js_1.isInside)(root, target)) {
+        console.error("cluaupp: skip remove outside project", target);
+        return false;
+    }
+    try {
+        node_fs_1.default.rmSync(target, { recursive: true, force: true });
+        return true;
+    }
+    catch (err) {
+        const error = err;
+        if (error.code === "EPERM" || error.code === "EBUSY" || error.code === "ENOTEMPTY") {
+            console.error("cluaupp: skip remove", target, `(${error.code})`);
+            return false;
+        }
+        throw err;
+    }
+}
+function copyFileIfChanged(src, dest, mode = "fill") {
+    if (mode === "fill" && node_fs_1.default.existsSync(dest)) {
+        return;
+    }
+    if (mode === "update" && node_fs_1.default.existsSync(dest)) {
+        const from = node_fs_1.default.statSync(src);
+        const to = node_fs_1.default.statSync(dest);
+        if (from.size === to.size && from.mtimeMs <= to.mtimeMs) {
+            return;
+        }
+    }
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(dest), { recursive: true });
+    try {
+        node_fs_1.default.copyFileSync(src, dest);
+    }
+    catch (err) {
+        const error = err;
+        if (error.code === "EPERM" || error.code === "EBUSY") {
+            console.error("cluaupp: skip copy", dest, `(${error.code})`);
+            return;
+        }
+        throw err;
+    }
+}
+function syncDir(from, to, mode = "fill") {
+    if (!node_fs_1.default.existsSync(from)) {
+        return;
+    }
+    node_fs_1.default.mkdirSync(to, { recursive: true });
+    for (const entry of node_fs_1.default.readdirSync(from, { withFileTypes: true })) {
+        const src = node_path_1.default.join(from, entry.name);
+        const dest = node_path_1.default.join(to, entry.name);
+        if (entry.isDirectory()) {
+            syncDir(src, dest, mode);
+        }
+        else {
+            copyFileIfChanged(src, dest, mode);
+        }
+    }
+}
+function copyRuntime(dest) {
+    const runtime = node_path_1.default.join(__dirname, "..", "..", "runtime");
+    if (!node_fs_1.default.existsSync(runtime)) {
+        return;
+    }
+    syncDir(runtime, node_path_1.default.join(dest, "libs"));
+}
+function copyHeaders(dest) {
+    const from = node_path_1.default.join(__dirname, "..", "..", "include", "cluaupp");
+    if (!node_fs_1.default.existsSync(from)) {
+        return;
+    }
+    syncDir(from, node_path_1.default.join(dest, "include", "cluaupp"));
+}
+function collectCpp(dir, files = []) {
+    if (!node_fs_1.default.existsSync(dir)) {
+        return files;
+    }
+    for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+        const full = node_path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            collectCpp(full, files);
+        }
+        else if ((0, preprocess_js_1.isSourceFile)(entry.name)) {
+            files.push(full);
+        }
+    }
+    return files;
+}
+function collectFiles(dir, files = []) {
+    if (!node_fs_1.default.existsSync(dir)) {
+        return files;
+    }
+    for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+        const full = node_path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            collectFiles(full, files);
+        }
+        else {
+            files.push(full);
+        }
+    }
+    return files;
+}
+function resolveKey(file) {
+    const resolved = node_path_1.default.resolve(file);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function posixRel(from, file) {
+    return node_path_1.default.relative(from, file).replace(/\\/g, "/");
+}
+function sourcePrefixes(rel) {
+    const noExt = rel.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, "");
+    const noTag = noExt.replace(/\.(server|client)$/i, "");
+    return [...new Set([noExt, noTag, (0, preprocess_js_1.toLuauPath)(rel).replace(/\\/g, "/")])];
+}
+function matchesPrefix(relOut, prefixes) {
+    const n = relOut.replace(/\\/g, "/").toLowerCase();
+    return prefixes.some((prefix) => {
+        const key = prefix.replace(/\\/g, "/").toLowerCase();
+        return n === key || n === `${key}.luau` || n.startsWith(`${key}/`) || n.startsWith(`${key}.`);
+    });
+}
+function removeEmptyOutDirs(outDir, projectRootDir) {
+    if (!node_fs_1.default.existsSync(outDir)) {
+        return;
+    }
+    const walk = (dir) => {
+        if (resolveKey(dir) === resolveKey(outDir)) {
+            for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+                if (entry.isDirectory()) {
+                    walk(node_path_1.default.join(dir, entry.name));
+                }
+            }
+            return;
+        }
+        for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                walk(node_path_1.default.join(dir, entry.name));
+            }
+        }
+        if (node_fs_1.default.existsSync(dir) && node_fs_1.default.readdirSync(dir).length === 0) {
+            if (tryRm(dir, projectRootDir)) {
+                console.log("cluaupp: removed", node_path_1.default.relative(projectRootDir, dir));
+            }
+        }
+    };
+    walk(outDir);
+}
+function pruneOut(root, config, written, failedPrefixes) {
+    const outDir = node_path_1.default.resolve(root, config.outDir);
+    if (!node_fs_1.default.existsSync(outDir) || !(0, safe_paths_js_1.isInside)(root, outDir)) {
+        return;
+    }
+    for (const file of collectFiles(outDir)) {
+        if (written.has(resolveKey(file))) {
+            continue;
+        }
+        if (!(0, safe_paths_js_1.isInside)(outDir, file)) {
+            continue;
+        }
+        const rel = posixRel(outDir, file);
+        if (matchesPrefix(rel, failedPrefixes)) {
+            continue;
+        }
+        if (tryRm(file, outDir)) {
+            console.log("cluaupp: removed", node_path_1.default.relative(root, file));
+        }
+    }
+    removeEmptyOutDirs(outDir, root);
+}
+function createMapper(root, config, rojoPath) {
+    const projectJson = node_path_1.default.resolve(root, rojoPath || "default.project.json");
+    const mapper = new rojo_mapper_js_1.RojoMapper(projectJson, node_path_1.default.join(root, config.rootDir), config.outDir);
+    mapper.loadSync();
+    return mapper;
+}
+function compileProject(root, config, mapper) {
+    const srcDir = node_path_1.default.join(root, config.rootDir);
+    const files = collectCpp(srcDir);
+    const jobs = [];
+    const errors = [];
+    for (const file of files) {
+        const source = node_fs_1.default.readFileSync(file, "utf8");
+        const rel = posixRel(srcDir, file);
+        try {
+            const result = (0, transpile_js_1.transpileSource)(source, rel, {
+                ...config,
+                filePath: file,
+                relativeName: rel,
+                outName: (0, preprocess_js_1.toLuauPath)(rel),
+                architecture: config.architecture === true,
+                includeDirs: [node_path_1.default.dirname(file), srcDir, node_path_1.default.join(root, "include")],
+                srcDir,
+                outDir: config.outDir,
+            }, mapper);
+            jobs.push({ rel, files: result.files, stale: result.stale || [] });
+        }
+        catch (err) {
+            errors.push({ rel, prefixes: sourcePrefixes(rel), message: err.message });
+        }
+    }
+    return { files, jobs, errors };
+}
+function writeTextIfChanged(dest, contents) {
+    if (node_fs_1.default.existsSync(dest) && node_fs_1.default.readFileSync(dest, "utf8") === contents) {
+        return false;
+    }
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(dest), { recursive: true });
+    node_fs_1.default.writeFileSync(dest, contents, "utf8");
+    return true;
+}
+function outDest(root, config, rel) {
+    const safe = (0, safe_paths_js_1.safeRelPath)(rel);
+    if (!safe) {
+        console.error("cluaupp: skip unsafe out path", rel);
+        return null;
+    }
+    const outRoot = node_path_1.default.resolve(root, config.outDir);
+    const dest = node_path_1.default.join(outRoot, safe);
+    if (!(0, safe_paths_js_1.isInside)(outRoot, dest) || !(0, safe_paths_js_1.isInside)(root, dest)) {
+        console.error("cluaupp: skip unsafe out path", rel);
+        return null;
+    }
+    return dest;
+}
+function writeJobs(root, config, jobs, format) {
+    const written = new Set();
+    for (const job of jobs) {
+        for (const artifact of job.files) {
+            const dest = outDest(root, config, artifact.name);
+            if (!dest) {
+                continue;
+            }
+            const changed = writeTextIfChanged(dest, artifact.contents);
+            written.add(resolveKey(dest));
+            if (changed) {
+                console.log("cluaupp:", job.rel, "→", node_path_1.default.relative(root, dest));
+            }
+            if (format && /\.luau$/i.test(dest)) {
+                process_orchestrator_js_1.ProcessOrchestrator.formatWithStyLuaSync(dest);
+            }
+        }
+        for (const stale of job.stale || []) {
+            const dest = outDest(root, config, stale);
+            if (dest && node_fs_1.default.existsSync(dest) && !written.has(resolveKey(dest))) {
+                if (tryRm(dest, node_path_1.default.resolve(root, config.outDir))) {
+                    console.log("cluaupp: removed", node_path_1.default.relative(root, dest));
+                }
+            }
+        }
+    }
+    return written;
+}
+function ensureVendor(root) {
+    copyRuntime(root);
+    copyHeaders(root);
+}
+function build(root, options = {}) {
+    const exitOnError = options.exitOnError !== false;
+    const holdOnError = options.holdOnError === true;
+    const format = options.format === true;
+    const config = loadConfig(root);
+    if (options.syncVendor !== false) {
+        ensureVendor(root);
+    }
+    const srcDir = node_path_1.default.join(root, config.rootDir);
+    if (!node_fs_1.default.existsSync(srcDir) || collectCpp(srcDir).length === 0) {
+        console.error("no .cpp/.h/.hpp files in", config.rootDir);
+        if (!holdOnError) {
+            pruneOut(root, config, new Set(), []);
+        }
+        if (exitOnError) {
+            process.exit(1);
+        }
+        return { failed: 0, written: new Set() };
+    }
+    const mapper = createMapper(root, config, options.rojo);
+    const compiled = compileProject(root, config, mapper);
+    if (compiled.errors.length > 0) {
+        for (const err of compiled.errors) {
+            console.error(err.message);
+        }
+        if (holdOnError) {
+            console.error(`cluaupp: out not updated (${compiled.errors.length} compile error${compiled.errors.length === 1 ? "" : "s"})`);
+            try {
+                (0, intellisense_js_1.syncEditorSupport)(root, config);
+            }
+            catch (err) {
+                console.error("cluaupp: intellisense sync failed", err.message);
+            }
+            return { failed: compiled.errors.length, written: new Set() };
+        }
+    }
+    const written = writeJobs(root, config, compiled.jobs, format);
+    const failedPrefixes = compiled.errors.flatMap((err) => err.prefixes);
+    pruneOut(root, config, written, failedPrefixes);
+    try {
+        (0, intellisense_js_1.syncEditorSupport)(root, config);
+    }
+    catch (err) {
+        console.error("cluaupp: intellisense sync failed", err.message);
+    }
+    if (options.analyze) {
+        for (const file of written) {
+            if (/\.luau$/i.test(file)) {
+                const report = process_orchestrator_js_1.ProcessOrchestrator.analyzeWithLuauSync(file);
+                if (report) {
+                    console.log("\n📊 Relatório de Análise Estática do Luau:\n", report);
+                }
+            }
+        }
+    }
+    if (compiled.errors.length > 0 && exitOnError) {
+        process.exit(1);
+    }
+    return { failed: compiled.errors.length, written };
+}
+async function init(dest) {
+    const target = (0, safe_paths_js_1.assertInitDest)(dest);
+    const template = node_path_1.default.join(__dirname, "..", "..", "templates", "game");
+    const include = node_path_1.default.join(__dirname, "..", "..", "include");
+    copyDir(template, target);
+    copyDir(include, node_path_1.default.join(target, "include"));
+    copyRuntime(target);
+    (0, intellisense_js_1.syncEditorSupport)(target);
+    const installed = await (0, intellisense_js_1.installEditorSupport)();
+    console.log("Cluaupp ready in", target);
+    console.log("  rokit install");
+    console.log("  cluaupp build");
+    console.log("  rojo serve");
+    if (installed.local.length ||
+        (installed.clangd && (installed.clangd.status === "installed" || installed.clangd.status === "already")) ||
+        (installed.llvm && (installed.llvm.status === "installed" || installed.llvm.status === "already"))) {
+        console.log("  reload Cursor (Ctrl+Shift+P → Developer: Reload Window)");
+    }
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function acquireWatchLock(root) {
+    const file = node_path_1.default.join(root, ".cluaupp-watch.lock");
+    if (node_fs_1.default.existsSync(file)) {
+        const pid = Number(node_fs_1.default.readFileSync(file, "utf8").trim());
+        if (Number.isFinite(pid) && pid !== process.pid && pidAlive(pid)) {
+            console.error(`cluaupp: watch already running (pid ${pid}). Stop it first — two watchers make Rojo crash on libs/.`);
+            process.exit(1);
+        }
+    }
+    node_fs_1.default.writeFileSync(file, String(process.pid), "utf8");
+    const release = () => {
+        try {
+            if (node_fs_1.default.existsSync(file) && node_fs_1.default.readFileSync(file, "utf8").trim() === String(process.pid)) {
+                node_fs_1.default.unlinkSync(file);
+            }
+        }
+        catch {
+            // ignore
+        }
+    };
+    process.on("exit", release);
+    process.on("SIGINT", () => {
+        release();
+        process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        release();
+        process.exit(0);
+    });
+}
+function watch(root, options = {}) {
+    acquireWatchLock(root);
+    build(root, { exitOnError: false, syncVendor: false, holdOnError: true, format: options.format, rojo: options.rojo });
+    const config = loadConfig(root);
+    const dir = node_path_1.default.join(root, config.rootDir);
+    let timer = null;
+    let running = false;
+    let queued = false;
+    const run = () => {
+        if (running) {
+            queued = true;
+            return;
+        }
+        running = true;
+        try {
+            build(root, { exitOnError: false, syncVendor: false, holdOnError: true, format: options.format, rojo: options.rojo });
+        }
+        catch (err) {
+            console.error(err.message);
+        }
+        finally {
+            running = false;
+            if (queued) {
+                queued = false;
+                run();
+            }
+        }
+    };
+    console.log("cluaupp", package_info_js_1.pkg.version, "watching", dir, "(libs untouched)");
+    if (!node_fs_1.default.existsSync(dir)) {
+        node_fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+    node_fs_1.default.watch(dir, { recursive: true }, () => {
+        if (timer) {
+            clearTimeout(timer);
+        }
+        timer = setTimeout(run, 400);
+    });
+}

package/generated/utils/rojo-mapper.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RojoMapper = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const comment_json_1 = require("comment-json");
+const libs_js_1 = require("../libs.js");
+const preprocess_js_1 = require("../preprocess.js");
+const SYSTEM_INCLUDES = new Set([
+    "iostream",
+    "string",
+    "string_view",
+    "vector",
+    "array",
+    "map",
+    "unordered_map",
+    "set",
+    "unordered_set",
+    "optional",
+    "memory",
+    "cstdint",
+    "cstddef",
+    "cmath",
+    "algorithm",
+    "utility",
+    "functional",
+    "span",
+    "tuple",
+    "type_traits",
+]);
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function posix(filePath) {
+    return filePath.replace(/\\/g, "/");
+}
+class RojoMapper {
+    projectJsonPath;
+    srcDir;
+    outDir;
+    config = null;
+    bindings = [];
+    constructor(projectJsonPath, srcDir, outDir) {
+        this.projectJsonPath = projectJsonPath;
+        this.srcDir = srcDir;
+        this.outDir = outDir;
+    }
+    async load() {
+        this.loadSync();
+    }
+    loadSync() {
+        this.config = null;
+        this.bindings = [];
+        if (!node_fs_1.default.existsSync(this.projectJsonPath)) {
+            return;
+        }
+        const content = node_fs_1.default.readFileSync(this.projectJsonPath, "utf8");
+        this.config = (0, comment_json_1.parse)(content);
+        this.bindings = this.walkTree(this.config.tree, []);
+    }
+    resolveIncludeToRequire(includePath) {
+        const raw = includePath.replace(/[<>'"]/g, "").trim();
+        if (!raw) {
+            return null;
+        }
+        const cleanPath = posix(raw).replace(/\.h(pp|h)?$/i, "");
+        const baseName = node_path_1.default.posix.basename(cleanPath);
+        const key = baseName.toLowerCase();
+        if ((0, preprocess_js_1.isEngineStub)(raw) || SYSTEM_INCLUDES.has(key) || SYSTEM_INCLUDES.has(cleanPath.toLowerCase())) {
+            return null;
+        }
+        const library = this.resolveLibrary(cleanPath, key);
+        if (library) {
+            return library;
+        }
+        const fromTree = this.resolveFromRojoTree(cleanPath, baseName);
+        if (fromTree) {
+            return fromTree;
+        }
+        const segments = cleanPath.split("/").filter(Boolean);
+        if (segments[0] === "src") {
+            segments.shift();
+        }
+        const alias = this.safeAlias(baseName);
+        if (segments[0] === "shared") {
+            return { alias, path: `ReplicatedStorage.Cluaupp.${segments.slice(1).join(".")}` };
+        }
+        if (segments[0] === "server") {
+            return { alias, path: `ServerScriptService.Cluaupp.${segments.slice(1).join(".")}` };
+        }
+        if (segments[0] === "client") {
+            return { alias, path: `StarterPlayer.StarterPlayerScripts.Cluaupp.${segments.slice(1).join(".")}` };
+        }
+        return { alias, path: `ReplicatedStorage.${segments.join(".")}` };
+    }
+    resolveLibrary(cleanPath, key) {
+        const mapped = libs_js_1.INCLUDE_TO_MODULE[key]
+            ?? libs_js_1.INCLUDE_TO_MODULE[node_path_1.default.posix.basename(cleanPath).toLowerCase()];
+        if (!mapped) {
+            return null;
+        }
+        const spec = libs_js_1.MODULES[mapped];
+        const bind = spec?.bind || mapped;
+        const file = spec?.file || mapped;
+        const libsRoot = this.findBinding((binding) => binding.robloxPath.endsWith(".CluauppLibs") || binding.robloxPath === "ReplicatedStorage.CluauppLibs");
+        const packagesRoot = this.findBinding((binding) => binding.robloxPath.endsWith(".Packages") || binding.robloxPath === "ReplicatedStorage.Packages");
+        if (libsRoot) {
+            return { alias: bind, path: `${libsRoot.robloxPath}.${file}` };
+        }
+        if (packagesRoot) {
+            return { alias: bind, path: `${packagesRoot.robloxPath}.${file}` };
+        }
+        return { alias: bind, path: `ReplicatedStorage.CluauppLibs.${file}` };
+    }
+    resolveFromRojoTree(cleanPath, baseName) {
+        const outRel = this.guessOutRel(cleanPath);
+        if (!outRel || this.bindings.length === 0) {
+            return null;
+        }
+        let best = null;
+        for (const binding of this.bindings) {
+            const prefix = posix(binding.fsPath).replace(/\/$/, "");
+            if (outRel === prefix || outRel.startsWith(`${prefix}/`)) {
+                const rest = outRel === prefix ? [] : outRel.slice(prefix.length + 1).split("/");
+                if (!best || prefix.length > posix(best.binding.fsPath).length) {
+                    best = { binding, rest };
+                }
+            }
+        }
+        if (!best) {
+            return null;
+        }
+        const tail = best.rest.join(".");
+        return {
+            alias: this.safeAlias(baseName),
+            path: tail ? `${best.binding.robloxPath}.${tail}` : best.binding.robloxPath,
+        };
+    }
+    guessOutRel(cleanPath) {
+        const relative = posix(cleanPath).replace(/^src\//, "");
+        const outName = relative.replace(/\.(cpp|cc|cxx|c|h|hpp|hh)$/i, "");
+        if (this.outDir) {
+            return posix(node_path_1.default.join(this.outDir, outName));
+        }
+        return posix(node_path_1.default.join("out", outName));
+    }
+    walkTree(node, robloxPath) {
+        const record = asRecord(node);
+        if (!record) {
+            return [];
+        }
+        const found = [];
+        if (typeof record.$path === "string" && robloxPath.length > 0) {
+            found.push({
+                robloxPath: robloxPath.join("."),
+                fsPath: posix(record.$path),
+            });
+        }
+        for (const [key, child] of Object.entries(record)) {
+            if (key.startsWith("$")) {
+                continue;
+            }
+            found.push(...this.walkTree(child, [...robloxPath, key]));
+        }
+        return found;
+    }
+    findBinding(predicate) {
+        return this.bindings.find(predicate);
+    }
+    safeAlias(name) {
+        const cleaned = name.replace(/[^A-Za-z0-9_]/g, "_");
+        return /^[A-Za-z_]/.test(cleaned) ? cleaned : `_${cleaned}`;
+    }
+}
+exports.RojoMapper = RojoMapper;