@isentinel/rojo-utils 0.1.0

package/out-tsc/rojo-resolver.js

@@ -0,0 +1,448 @@
+import { type } from "arktype";
+import * as fs from "node:fs";
+import path from "node:path";
+const LUA_EXT = ".lua";
+const LUAU_EXT = ".luau";
+const JSON_EXT = ".json";
+const TOML_EXT = ".toml";
+const ROJO_MODULE_EXTS = new Set([JSON_EXT, LUAU_EXT, TOML_EXT]);
+const ROJO_SCRIPT_EXTS = new Set([LUAU_EXT]);
+const INIT_NAME = "init";
+const SERVER_SUB_EXTENSION = ".server";
+const CLIENT_SUB_EXTENSION = ".client";
+const MODULE_SUB_EXTENSION = "";
+const ROJO_FILE_REGEX = /^.+\.project\.json$/;
+const ROJO_DEFAULT_NAME = "default.project.json";
+const ROJO_OLD_NAME = "roblox-project.json";
+export const RbxType = {
+    LocalScript: 2,
+    ModuleScript: 0,
+    Script: 1,
+    Unknown: 3,
+};
+const SUB_EXT_TYPE_MAP = new Map([
+    [CLIENT_SUB_EXTENSION, RbxType.LocalScript],
+    [MODULE_SUB_EXTENSION, RbxType.ModuleScript],
+    [SERVER_SUB_EXTENSION, RbxType.Script],
+]);
+const DEFAULT_ISOLATED_CONTAINERS = [
+    ["StarterPack"],
+    ["StarterGui"],
+    ["StarterPlayer", "StarterPlayerScripts"],
+    ["StarterPlayer", "StarterCharacterScripts"],
+    ["StarterPlayer", "StarterCharacter"],
+    ["PluginDebugService"],
+];
+const CLIENT_CONTAINERS = [["StarterPack"], ["StarterGui"], ["StarterPlayer"]];
+const SERVER_CONTAINERS = [["ServerStorage"], ["ServerScriptService"]];
+export const FileRelation = {
+    InToIn: 3,
+    InToOut: 2,
+    OutToIn: 1,
+    OutToOut: 0,
+};
+export const NetworkType = {
+    Client: 1,
+    Server: 2,
+    Unknown: 0,
+};
+function stripRojoExtensions(filePath) {
+    let stripped = filePath;
+    const extension = path.extname(stripped);
+    if (ROJO_MODULE_EXTS.has(extension)) {
+        stripped = stripped.slice(0, -extension.length);
+        if (ROJO_SCRIPT_EXTS.has(extension)) {
+            const subExtension = path.extname(stripped);
+            if (subExtension === SERVER_SUB_EXTENSION || subExtension === CLIENT_SUB_EXTENSION) {
+                stripped = stripped.slice(0, -subExtension.length);
+            }
+        }
+    }
+    return stripped;
+}
+function arrayStartsWith(a, b) {
+    const minLength = Math.min(a.length, b.length);
+    for (let index = 0; index < minLength; index++) {
+        if (a[index] !== b[index]) {
+            return false;
+        }
+    }
+    return true;
+}
+function isPathDescendantOf(filePath, directoryPath) {
+    return directoryPath === filePath || !path.relative(directoryPath, filePath).startsWith("..");
+}
+let rojoFileSchema;
+function isValidRojoConfig(value) {
+    // Built lazily on first use (not at module top level) so consumers can
+    // auto-mock this module without a hoisting TDZ on the arktype import, then
+    // memoized so repeated tree-walk validations don't re-allocate the schema. We
+    // validate only the fields the resolver reads; parseTree handles arbitrary
+    // tree shapes defensively.
+    rojoFileSchema ??= type({
+        "name": "string",
+        "servePort?": "number",
+        "tree": "object",
+    });
+    return !(rojoFileSchema(value) instanceof type.errors);
+}
+function convertToLuau(filePath) {
+    const extension = path.extname(filePath);
+    if (extension === LUA_EXT) {
+        return filePath.slice(0, -extension.length) + LUAU_EXT;
+    }
+    return filePath;
+}
+export const RbxPathParent = Symbol("Parent");
+export class RojoResolver {
+    rbxPath = new Array();
+    realpathCache = new Map();
+    walkedConfigFilesInternal = new Set();
+    walkedDirectoriesInternal = new Set();
+    filePathToRbxPathMap = new Map();
+    isolatedContainers = [...DEFAULT_ISOLATED_CONTAINERS];
+    partitions = new Array();
+    warnings = new Array();
+    isGame = false;
+    static findRojoConfigFilePath(projectPath) {
+        const warnings = new Array();
+        const defaultPath = path.join(projectPath, ROJO_DEFAULT_NAME);
+        if (fs.existsSync(defaultPath)) {
+            return { path: defaultPath, warnings };
+        }
+        const candidates = new Array();
+        for (const fileName of fs.readdirSync(projectPath)) {
+            if (fileName !== ROJO_DEFAULT_NAME &&
+                (fileName === ROJO_OLD_NAME || ROJO_FILE_REGEX.test(fileName))) {
+                candidates.push(path.join(projectPath, fileName));
+            }
+        }
+        if (candidates.length > 1) {
+            warnings.push(`Multiple *.project.json files found, using ${candidates[0]}`);
+        }
+        return { path: candidates[0], warnings };
+    }
+    static fromPath(rojoConfigFilePath) {
+        const resolver = new RojoResolver();
+        resolver.parseConfig(path.resolve(rojoConfigFilePath), true);
+        return resolver;
+    }
+    /**
+     * Restore a resolver from a {@link RojoResolverState} snapshot.
+     * @param state - The serialized resolver state to restore from.
+     * @returns A resolver equivalent to the one the state was captured from.
+     */
+    static fromState(state) {
+        const resolver = new RojoResolver();
+        resolver.partitions = state.partitions.map((partition) => {
+            return { fsPath: partition.fsPath, rbxPath: partition.rbxPath.slice() };
+        });
+        const filePathToRbxPathMap = new Map();
+        for (const [filePath, rbxPath] of state.filePathToRbxPathMap) {
+            filePathToRbxPathMap.set(filePath, rbxPath.slice());
+        }
+        resolver.filePathToRbxPathMap = filePathToRbxPathMap;
+        resolver.isolatedContainers = state.isolatedContainers.map((container) => {
+            return container.slice();
+        });
+        resolver.isGame = state.isGame;
+        resolver.warnings = state.warnings.slice();
+        for (const directory of state.walkedDirs) {
+            resolver.walkedDirectoriesInternal.add(directory);
+        }
+        for (const configFile of state.walkedConfigFiles) {
+            resolver.walkedConfigFilesInternal.add(configFile);
+        }
+        return resolver;
+    }
+    static fromTree(basePath, tree) {
+        const resolver = new RojoResolver();
+        resolver.parseTree(basePath, "", tree, true);
+        return resolver;
+    }
+    getFileRelation(fileRbxPath, moduleRbxPath) {
+        const fileContainer = this.getContainer(this.isolatedContainers, fileRbxPath);
+        const moduleContainer = this.getContainer(this.isolatedContainers, moduleRbxPath);
+        if (fileContainer && moduleContainer) {
+            if (fileContainer === moduleContainer) {
+                return FileRelation.InToIn;
+            }
+            return FileRelation.OutToIn;
+        }
+        if (fileContainer && !moduleContainer) {
+            return FileRelation.InToOut;
+        }
+        if (!fileContainer && moduleContainer) {
+            return FileRelation.OutToIn;
+        }
+        // !fileContainer && !moduleContainer
+        return FileRelation.OutToOut;
+    }
+    getNetworkType(rbxPath) {
+        if (this.getContainer(SERVER_CONTAINERS, rbxPath)) {
+            return NetworkType.Server;
+        }
+        if (this.getContainer(CLIENT_CONTAINERS, rbxPath)) {
+            return NetworkType.Client;
+        }
+        return NetworkType.Unknown;
+    }
+    getPartitions() {
+        return this.partitions;
+    }
+    getRbxPathFromFilePath(filePath) {
+        const resolved = convertToLuau(path.resolve(filePath));
+        const rbxPath = this.filePathToRbxPathMap.get(resolved);
+        if (rbxPath) {
+            return rbxPath;
+        }
+        const extension = path.extname(resolved);
+        for (const partition of this.partitions) {
+            if (isPathDescendantOf(resolved, partition.fsPath)) {
+                const stripped = stripRojoExtensions(resolved);
+                const relativePath = path.relative(partition.fsPath, stripped);
+                const relativeParts = relativePath === "" ? [] : relativePath.split(path.sep);
+                if (ROJO_SCRIPT_EXTS.has(extension) && relativeParts.at(-1) === INIT_NAME) {
+                    relativeParts.pop();
+                }
+                return [...partition.rbxPath, ...relativeParts];
+            }
+        }
+        return undefined;
+    }
+    getRbxTypeFromFilePath(filePath) {
+        const resolved = convertToLuau(filePath);
+        const extension = path.extname(resolved);
+        const subExtension = path.extname(path.basename(resolved, extension));
+        if (ROJO_SCRIPT_EXTS.has(extension)) {
+            return SUB_EXT_TYPE_MAP.get(subExtension) ?? RbxType.Unknown;
+        }
+        // non-script exts cannot use .server, .client, etc.
+        return RbxType.ModuleScript;
+    }
+    /**
+     * Serialize this resolver to a {@link RojoResolverState} snapshot.
+     * @returns A serializable snapshot of this resolver's state.
+     */
+    getState() {
+        const filePathToRbxPathMap = new Array();
+        for (const [filePath, rbxPath] of this.filePathToRbxPathMap) {
+            filePathToRbxPathMap.push([filePath, rbxPath.slice()]);
+        }
+        return {
+            filePathToRbxPathMap,
+            isGame: this.isGame,
+            isolatedContainers: this.isolatedContainers.map((container) => container.slice()),
+            partitions: this.partitions.map((partition) => {
+                return { fsPath: partition.fsPath, rbxPath: partition.rbxPath.slice() };
+            }),
+            walkedConfigFiles: [...this.walkedConfigFilesInternal],
+            walkedDirs: [...this.walkedDirectoriesInternal],
+            warnings: this.warnings.slice(),
+        };
+    }
+    getWarnings() {
+        return this.warnings;
+    }
+    isIsolated(rbxPath) {
+        return this.getContainer(this.isolatedContainers, rbxPath) !== undefined;
+    }
+    static relative(rbxFrom, rbxTo) {
+        const maxLength = Math.max(rbxFrom.length, rbxTo.length);
+        let diffIndex = maxLength;
+        for (let index = 0; index < maxLength; index++) {
+            if (rbxFrom[index] !== rbxTo[index]) {
+                diffIndex = index;
+                break;
+            }
+        }
+        const result = new Array();
+        if (diffIndex < rbxFrom.length) {
+            for (let index = 0; index < rbxFrom.length - diffIndex; index++) {
+                result.push(RbxPathParent);
+            }
+        }
+        for (let index = diffIndex; index < rbxTo.length; index++) {
+            // eslint-disable-next-line ts/no-non-null-assertion -- Loop index
+            result.push(rbxTo[index]);
+        }
+        return result;
+    }
+    /**
+     * Create a synthetic RojoResolver for ProjectType.Package. Forces all imports
+     * to be relative.
+     * @param basePath - The base filesystem path the package resolves against.
+     * @returns A resolver that maps every file in the package relatively.
+     */
+    static synthetic(basePath) {
+        const resolver = new RojoResolver();
+        resolver.parseTree(basePath, "", { $path: basePath }, true);
+        return resolver;
+    }
+    get walkedConfigFiles() {
+        return this.walkedConfigFilesInternal;
+    }
+    get walkedDirectories() {
+        return this.walkedDirectoriesInternal;
+    }
+    cachedRealpath(targetPath) {
+        let resolved = this.realpathCache.get(targetPath);
+        if (resolved === undefined) {
+            resolved = fs.realpathSync(targetPath);
+            this.realpathCache.set(targetPath, resolved);
+        }
+        return resolved;
+    }
+    getContainer(from, rbxPath) {
+        if (this.isGame && rbxPath) {
+            for (const container of from) {
+                if (arrayStartsWith(rbxPath, container)) {
+                    return container;
+                }
+            }
+        }
+        return undefined;
+    }
+    parseConfig(rojoConfigFilePath, doNotPush = false) {
+        if (!fs.existsSync(rojoConfigFilePath)) {
+            this.warn(`RojoResolver: Path does not exist "${rojoConfigFilePath}"`);
+            return;
+        }
+        const realPath = this.cachedRealpath(rojoConfigFilePath);
+        this.walkedConfigFilesInternal.add(realPath);
+        let configJson;
+        try {
+            configJson = JSON.parse(fs.readFileSync(realPath, "utf8"));
+        }
+        catch {
+            // Malformed JSON: leave configJson undefined and fall through so it
+            // is reported as an invalid configuration rather than crashing the
+            // caller.
+        }
+        if (isValidRojoConfig(configJson)) {
+            this.parseTree(path.dirname(rojoConfigFilePath), configJson.name, configJson.tree, doNotPush);
+        }
+        else {
+            this.warn("RojoResolver: Invalid configuration!");
+        }
+    }
+    parsePath(itemPath) {
+        const luauPath = convertToLuau(itemPath);
+        // A $path pointing straight at a *.project.json file embeds that nested
+        // project at the current rbxPath (Rojo composes projects this way), the
+        // same as a directory whose default.project.json is discovered below.
+        // Without this, the .json extension routes the file into
+        // filePathToRbxPathMap as an opaque leaf and the nested tree's mounts
+        // (its partitions, its @rbxts mounts) are never read.
+        if (ROJO_FILE_REGEX.test(path.basename(luauPath))) {
+            this.parseConfig(luauPath, true);
+            return;
+        }
+        const realPath = fs.existsSync(luauPath) ? this.cachedRealpath(luauPath) : luauPath;
+        const extension = path.extname(luauPath);
+        if (ROJO_MODULE_EXTS.has(extension)) {
+            this.filePathToRbxPathMap.set(luauPath, [...this.rbxPath]);
+        }
+        else {
+            const isDirectory = fs.existsSync(realPath) && fs.statSync(realPath).isDirectory();
+            if (isDirectory) {
+                this.walkedDirectoriesInternal.add(realPath);
+            }
+            if (isDirectory && fs.readdirSync(realPath).includes(ROJO_DEFAULT_NAME)) {
+                this.parseConfig(path.join(luauPath, ROJO_DEFAULT_NAME), true);
+            }
+            else {
+                this.partitions.unshift({
+                    fsPath: luauPath,
+                    rbxPath: [...this.rbxPath],
+                });
+                if (isDirectory) {
+                    this.searchDirectory(luauPath);
+                }
+            }
+        }
+    }
+    parseTree(basePath, name, tree, doNotPush = false) {
+        if (!doNotPush) {
+            this.rbxPath.push(name);
+        }
+        if (tree.$path !== undefined) {
+            this.parsePath(path.resolve(basePath, typeof tree.$path === "string" ? tree.$path : tree.$path.optional));
+        }
+        if (tree.$className === "DataModel") {
+            this.isGame = true;
+        }
+        const childNames = Object.keys(tree).filter((value) => !value.startsWith("$"));
+        for (const childName of childNames) {
+            // eslint-disable-next-line ts/no-non-null-assertion -- Object.keys ensures this is defined
+            this.parseTree(basePath, childName, tree[childName]);
+        }
+        if (!doNotPush) {
+            this.rbxPath.pop();
+        }
+    }
+    searchChildren(directory, directoryEntries) {
+        // Two-phase: parse every sibling *.project.json before recursing into
+        // sibling directories. parsePath / parseConfig insert partitions via
+        // unshift, and getRbxPathFromFilePath returns the first match, so
+        // interleaving in raw entry order would shuffle partition precedence
+        // for overlapping mounts.
+        const projectFiles = new Array();
+        const subDirectories = new Array();
+        for (const entry of directoryEntries) {
+            const childPath = path.join(directory, entry.name);
+            let isFile = entry.isFile();
+            let isDirectory = entry.isDirectory();
+            // Symlinks (both flags false), unknown-type entries on NFS/SMB/FUSE
+            // mounts and some Windows network drives, and NTFS junctions on
+            // Node versions that don't classify them: resolve and stat the
+            // target so we still discover nested *.project.json files and
+            // walkable directories. A broken symlink throws ENOENT here —
+            // warn and skip rather than crash the whole walk.
+            if (!isFile && !isDirectory) {
+                try {
+                    const stat = fs.statSync(this.cachedRealpath(childPath));
+                    isFile = stat.isFile();
+                    isDirectory = stat.isDirectory();
+                }
+                catch (err) {
+                    this.warn(`RojoResolver: Failed to resolve "${childPath}" (${err.message})`);
+                    continue;
+                }
+            }
+            if (isFile && ROJO_FILE_REGEX.test(entry.name)) {
+                projectFiles.push(childPath);
+            }
+            else if (isDirectory) {
+                subDirectories.push({ name: entry.name, path: childPath });
+            }
+        }
+        for (const childPath of projectFiles) {
+            this.parseConfig(childPath);
+        }
+        for (const { name, path: childPath } of subDirectories) {
+            this.searchDirectory(childPath, name);
+        }
+    }
+    searchDirectory(directory, item) {
+        const realPath = this.cachedRealpath(directory);
+        this.walkedDirectoriesInternal.add(realPath);
+        // readdirSync transparently follows a symlink on the argument; the
+        // result is equivalent to readdirSync(realpathSync(directory)).
+        const directoryEntries = fs.readdirSync(directory, { withFileTypes: true });
+        if (directoryEntries.some((entry) => entry.name === ROJO_DEFAULT_NAME)) {
+            this.parseConfig(path.join(directory, ROJO_DEFAULT_NAME));
+            return;
+        }
+        if (item !== undefined) {
+            this.rbxPath.push(item);
+        }
+        this.searchChildren(directory, directoryEntries);
+        if (item !== undefined) {
+            this.rbxPath.pop();
+        }
+    }
+    warn(str) {
+        this.warnings.push(str);
+    }
+}

package/out-tsc/rojo-tree.d.ts

@@ -0,0 +1,15 @@
+import type { RojoTreeNode } from "./types.ts";
+/**
+ * Like {@link resolveNestedProjects}, but also reports the absolute path of
+ * every nested project file inlined during resolution. Change-detection
+ * callers hash these so an edit to a nested `*.project.json` invalidates the
+ * build.
+ */
+export declare function resolveNestedProjectSources(tree: RojoTreeNode, rootDirectory: string): {
+    projectFiles: Array<string>;
+    tree: RojoTreeNode;
+};
+export declare function resolveNestedProjects(tree: RojoTreeNode, rootDirectory: string): RojoTreeNode;
+export declare function collectPaths(node: RojoTreeNode, result: Array<string>): void;
+export declare function rebaseTreePaths(node: RojoTreeNode, fromDirectory: string, toDirectory: string): RojoTreeNode;
+//# sourceMappingURL=rojo-tree.d.ts.map

package/out-tsc/rojo-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rojo-tree.d.ts","sourceRoot":"","sources":["../src/rojo-tree.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAa/C;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAC1C,IAAI,EAAE,YAAY,EAClB,aAAa,EAAE,MAAM,GACnB;IAAE,YAAY,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAAC,IAAI,EAAE,YAAY,CAAA;CAAE,CAIrD;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,GAAG,YAAY,CAE7F;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,CAQ5E;AAED,wBAAgB,eAAe,CAC9B,IAAI,EAAE,YAAY,EAClB,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,GACjB,YAAY,CAmBd"}

package/out-tsc/rojo-tree.js

@@ -0,0 +1,106 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+/**
+ * Like {@link resolveNestedProjects}, but also reports the absolute path of
+ * every nested project file inlined during resolution. Change-detection
+ * callers hash these so an edit to a nested `*.project.json` invalidates the
+ * build.
+ */
+export function resolveNestedProjectSources(tree, rootDirectory) {
+    const context = { sources: new Set(), visited: new Set() };
+    const resolved = resolveTree(tree, rootDirectory, rootDirectory, context);
+    return { projectFiles: [...context.sources], tree: resolved };
+}
+export function resolveNestedProjects(tree, rootDirectory) {
+    return resolveNestedProjectSources(tree, rootDirectory).tree;
+}
+export function collectPaths(node, result) {
+    for (const [key, value] of Object.entries(node)) {
+        if (key === "$path" && typeof value === "string") {
+            result.push(value.replaceAll("\\", "/"));
+        }
+        else if (typeof value === "object" && !Array.isArray(value) && !key.startsWith("$")) {
+            collectPaths(value, result);
+        }
+    }
+}
+export function rebaseTreePaths(node, fromDirectory, toDirectory) {
+    const result = {};
+    for (const [key, value] of Object.entries(node)) {
+        if (key === "$path" && typeof value === "string") {
+            const absolutePath = resolve(fromDirectory, value);
+            result[key] = relative(toDirectory, absolutePath).replaceAll("\\", "/");
+            continue;
+        }
+        if (key.startsWith("$") || typeof value !== "object" || Array.isArray(value)) {
+            result[key] = value;
+            continue;
+        }
+        result[key] = rebaseTreePaths(value, fromDirectory, toDirectory);
+    }
+    return result;
+}
+function nestedProjectPath(currentDirectory, value) {
+    // Resolve a `$path` string to the nested project file it should inline, or
+    // undefined when the path is a plain source mount. Rojo treats a `$path`
+    // pointing at a directory containing `default.project.json` as a nested
+    // project (e.g. `$path: ".."` into a package root), so honor that alongside
+    // explicit `*.project.json` references.
+    if (value.endsWith(".project.json")) {
+        return join(currentDirectory, value);
+    }
+    const directoryDefault = join(currentDirectory, value, "default.project.json");
+    return existsSync(directoryDefault) ? directoryDefault : undefined;
+}
+function inlineNestedProject(projectPath, currentDirectory, originalRoot, context) {
+    const chain = new Set(context.visited);
+    chain.add(projectPath);
+    context.sources.add(projectPath);
+    let content;
+    try {
+        content = readFileSync(projectPath, "utf-8");
+    }
+    catch (err) {
+        const relativePath = relative(currentDirectory, projectPath);
+        throw new Error(`Could not read nested Rojo project: ${relativePath}`, { cause: err });
+    }
+    let project;
+    try {
+        project = JSON.parse(content);
+    }
+    catch (err) {
+        const relativePath = relative(currentDirectory, projectPath);
+        throw new Error(`Failed to parse nested Rojo project: ${relativePath}`, { cause: err });
+    }
+    return resolveTree(project.tree, dirname(projectPath), originalRoot, {
+        sources: context.sources,
+        visited: chain,
+    });
+}
+function resolveRootRelativePath(currentDirectory, value, originalRoot) {
+    const absolutePath = join(currentDirectory, value);
+    return relative(originalRoot, absolutePath).replaceAll("\\", "/");
+}
+function resolveTree(node, currentDirectory, originalRoot, context) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(node)) {
+        if (key === "$path" && typeof value === "string") {
+            const projectPath = nestedProjectPath(currentDirectory, value);
+            if (projectPath === undefined) {
+                resolved[key] = resolveRootRelativePath(currentDirectory, value, originalRoot);
+                continue;
+            }
+            if (context.visited.has(projectPath)) {
+                throw new Error(`Circular project reference: ${value}`);
+            }
+            Object.assign(resolved, inlineNestedProject(projectPath, currentDirectory, originalRoot, context));
+            continue;
+        }
+        if (key.startsWith("$") || typeof value !== "object" || Array.isArray(value)) {
+            resolved[key] = value;
+            continue;
+        }
+        resolved[key] = resolveTree(value, currentDirectory, originalRoot, context);
+    }
+    return resolved;
+}

package/out-tsc/tree-mapper.d.ts

@@ -0,0 +1,4 @@
+import type { RojoTreeNode } from "./types.ts";
+export declare function matchNodePath(childNode: RojoTreeNode, targetPath: string, childDataModelPath: string): string | undefined;
+export declare function findInTree(node: RojoTreeNode, targetPath: string, currentDataModelPath: string): string | undefined;
+//# sourceMappingURL=tree-mapper.d.ts.map

package/out-tsc/tree-mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-mapper.d.ts","sourceRoot":"","sources":["../src/tree-mapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C,wBAAgB,aAAa,CAC5B,SAAS,EAAE,YAAY,EACvB,UAAU,EAAE,MAAM,EAClB,kBAAkB,EAAE,MAAM,GACxB,MAAM,GAAG,SAAS,CAiBpB;AAED,wBAAgB,UAAU,CACzB,IAAI,EAAE,YAAY,EAClB,UAAU,EAAE,MAAM,EAClB,oBAAoB,EAAE,MAAM,GAC1B,MAAM,GAAG,SAAS,CAsBpB"}

package/out-tsc/tree-mapper.js

@@ -0,0 +1,34 @@
+const TRAILING_SLASH = /\/$/;
+export function matchNodePath(childNode, targetPath, childDataModelPath) {
+    const nodePath = childNode.$path;
+    if (typeof nodePath !== "string") {
+        return undefined;
+    }
+    const normalizedNodePath = nodePath.replace(TRAILING_SLASH, "");
+    if (normalizedNodePath === targetPath) {
+        return childDataModelPath;
+    }
+    if (targetPath.startsWith(`${normalizedNodePath}/`)) {
+        const remainder = targetPath.slice(normalizedNodePath.length + 1);
+        return `${childDataModelPath}/${remainder}`;
+    }
+    return undefined;
+}
+export function findInTree(node, targetPath, currentDataModelPath) {
+    for (const [key, value] of Object.entries(node)) {
+        if (key.startsWith("$") || typeof value !== "object") {
+            continue;
+        }
+        const childNode = value;
+        const childDataModelPath = currentDataModelPath === "" ? key : `${currentDataModelPath}/${key}`;
+        const pathMatch = matchNodePath(childNode, targetPath, childDataModelPath);
+        if (pathMatch !== undefined) {
+            return pathMatch;
+        }
+        const found = findInTree(childNode, targetPath, childDataModelPath);
+        if (found !== undefined) {
+            return found;
+        }
+    }
+    return undefined;
+}

package/out-tsc/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"version":"7.0.0-dev.20260607.1","fileInfos":[],"options":{"allowJs":true,"allowUnreachableCode":false,"composite":true,"declarationMap":true,"erasableSyntaxOnly":true,"module":99,"noFallthroughCasesInSwitch":true,"noImplicitReturns":true,"noPropertyAccessFromIndexSignature":true,"noUncheckedIndexedAccess":true,"noUnusedLocals":true,"noUnusedParameters":true,"noImplicitOverride":true,"outDir":"./","skipLibCheck":true,"strict":true,"strictBuiltinIteratorReturn":true,"strictNullChecks":true,"target":99,"verbatimModuleSyntax":true,"esModuleInterop":true}}

package/out-tsc/types.d.ts

@@ -0,0 +1,26 @@
+export interface RojoTreeNode {
+    $className?: string;
+    $ignoreUnknownInstances?: boolean;
+    $path?: string | {
+        optional: string;
+    };
+    $properties?: Record<string, unknown>;
+    [key: string]: boolean | Record<string, unknown> | RojoTreeNode | string | undefined | {
+        optional: string;
+    };
+}
+export interface RojoProject {
+    name: string;
+    servePort?: number;
+    tree: RojoTreeNode;
+}
+/**
+ * Result of `loadRojoProject` — the validated narrow shape plus the original
+ * parsed JSON. Callers that need top-level fields beyond name/servePort/tree
+ * (gameId, placeId, globIgnorePaths, etc.) read them from `raw` rather than
+ * re-parsing the project file.
+ */
+export interface LoadedRojoProject extends RojoProject {
+    raw: Record<string, unknown>;
+}
+//# sourceMappingURL=types.d.ts.map

package/out-tsc/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,KAAK,CAAC,EAAE,MAAM,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IACtC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,CAAC,GAAG,EAAE,MAAM,GACT,OAAO,GACP,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACvB,YAAY,GACZ,MAAM,GACN,SAAS,GACT;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,YAAY,CAAC;CACnB;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAkB,SAAQ,WAAW;IACrD,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC7B"}

package/out-tsc/types.js

@@ -0,0 +1 @@
+export {};

package/out-tsc/vitest/eslint.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: Promise<import("@isentinel/eslint-config").FlatConfigComposer<import("@isentinel/eslint-config").TypedFlatConfigItem, import("@isentinel/eslint-config").ConfigNames>>;
+export default _default;
+//# sourceMappingURL=eslint.config.d.ts.map

package/out-tsc/vitest/eslint.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eslint.config.d.ts","sourceRoot":"","sources":["../../eslint.config.ts"],"names":[],"mappings":""}

package/out-tsc/vitest/eslint.shared.d.ts

@@ -0,0 +1,13 @@
+import { type ConfigNames, type FlatConfigComposer, type NamedFlatConfigItem, type OptionsConfig, type TypedFlatConfigItem } from "@isentinel/eslint-config";
+type EslintPassthrough = {
+    [K in keyof OptionsConfig as K extends "namedConfigs" ? never : K]?: OptionsConfig[K];
+};
+export interface HalcyonSharedOptions extends EslintPassthrough {
+    name: string;
+    ignores?: Array<string>;
+    roblox: boolean;
+    rules?: NonNullable<TypedFlatConfigItem["rules"]>;
+}
+export declare function halcyon(options: HalcyonSharedOptions, ...userConfigs: Array<NamedFlatConfigItem>): Promise<FlatConfigComposer<TypedFlatConfigItem, ConfigNames>>;
+export {};
+//# sourceMappingURL=eslint.shared.d.ts.map