@flamework-experimental/transformer 2.0.0-alpha.0

package/out/util/projectConfig.js

@@ -0,0 +1,221 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME_SECTIONS = exports.PROJECT_CONFIG_NAME = void 0;
+exports.findProjectConfig = findProjectConfig;
+exports.readProjectConfig = readProjectConfig;
+exports.mergeTransformerConfig = mergeTransformerConfig;
+exports.getRuntimeConfig = getRuntimeConfig;
+exports.fingerprintProjectConfig = fingerprintProjectConfig;
+exports.loadProjectConfig = loadProjectConfig;
+var crypto_1 = __importDefault(require("crypto"));
+var fs_1 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
+var typescript_1 = __importDefault(require("typescript"));
+var logger_1 = require("../classes/logger");
+var env_1 = require("./env");
+var schema_1 = require("./schema");
+/** The file every Flamework package reads its options from, found from the tsconfig's directory up to the package root. */
+exports.PROJECT_CONFIG_NAME = "flamework.config.json";
+exports.RUNTIME_SECTIONS = ["core", "networking", "components", "scopes", "testing"];
+/**
+ * Locates `flamework.config.json`.
+ *
+ * With `configFile` set on the tsconfig entry, that path (relative to the tsconfig's directory) is
+ * used and must exist. Otherwise the tsconfig's directory is searched first, then each parent up to
+ * and including the package root, so a multi-place repository can keep one file at the root and
+ * still override it per place.
+ */
+function findProjectConfig(projectDirectory, rootDirectory, explicitPath) {
+    if (explicitPath !== undefined) {
+        var resolved = path_1.default.resolve(projectDirectory, explicitPath);
+        if (!fs_1.default.existsSync(resolved)) {
+            throw new Error("The Flamework config file '".concat(explicitPath, "' does not exist (looked at '").concat(resolved, "')."));
+        }
+        return resolved;
+    }
+    var root = path_1.default.resolve(rootDirectory);
+    var current = path_1.default.resolve(projectDirectory);
+    while (true) {
+        var candidate = path_1.default.join(current, exports.PROJECT_CONFIG_NAME);
+        if (fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+        if (path_1.default.relative(current, root) === "") {
+            return;
+        }
+        var parent_1 = path_1.default.dirname(current);
+        if (parent_1 === current) {
+            return;
+        }
+        current = parent_1;
+    }
+}
+/**
+ * Reads and validates a `flamework.config.json`. Comments and trailing commas are allowed, as in tsconfig.
+ *
+ * Every string in the file can reference the environment as `${NAME}` or `${NAME:-fallback}`
+ * (`$$` for a literal dollar). The environment is `.env` and `.env.local` next to the file with the
+ * process environment on top, unless one is given. A string sitting where the schema expects a
+ * boolean, a number or a list of strings is converted before validation, since a variable is
+ * always a string.
+ */
+function readProjectConfig(configPath, env) {
+    if (env === void 0) { env = (0, env_1.loadEnv)(path_1.default.dirname(configPath)); }
+    var text = fs_1.default.readFileSync(configPath, "utf8");
+    // TypeScript asserts a forward-slash path when it attaches a diagnostic to the JSON source file.
+    var _a = typescript_1.default.parseConfigFileTextToJson(configPath.replace(/\\/g, "/"), text), parsed = _a.config, error = _a.error;
+    if (error) {
+        throw new Error("Failed to parse ".concat(configPath, ": ").concat(typescript_1.default.flattenDiagnosticMessageText(error.messageText, "\n")));
+    }
+    var describe = function (pointer) { return "".concat(configPath, ": '").concat(pointer === "" ? "/" : pointer, "'"); };
+    var config = (0, env_1.coerceBySchema)((0, env_1.substituteEnv)(parsed, env, describe).value, (0, schema_1.getSchema)("projectConfig"), describe);
+    if (!(0, schema_1.validateSchema)("projectConfig", config)) {
+        var details = (0, schema_1.getSchemaErrors)().map(function (v) {
+            var location = v.instancePath === "" ? "/" : v.instancePath;
+            var extra = v.params && "additionalProperty" in v.params ? " '".concat(v.params.additionalProperty, "'") : "";
+            return "".concat(location, " ").concat(v.message).concat(extra);
+        });
+        throw new Error("Invalid ".concat(configPath, ":\n  ").concat(details.join("\n  ")));
+    }
+    var projectConfig = __assign({}, config);
+    delete projectConfig.$schema;
+    return projectConfig;
+}
+/**
+ * Combines the file's transformer section with the options set inline on the tsconfig entry.
+ *
+ * Inline options win: they are the more specific place to have written something. `optimizations`
+ * merges one level deep so that an inline override of one optimisation keeps the file's others.
+ */
+function mergeTransformerConfig(fileOptions, inlineConfig) {
+    var e_1, _a;
+    var merged = __assign({}, (fileOptions !== null && fileOptions !== void 0 ? fileOptions : {}));
+    try {
+        for (var _b = __values(Object.entries(inlineConfig)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var _d = __read(_c.value, 2), key = _d[0], value = _d[1];
+            if (value !== undefined) {
+                merged[key] = value;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if ((fileOptions === null || fileOptions === void 0 ? void 0 : fileOptions.optimizations) && inlineConfig.optimizations) {
+        merged.optimizations = __assign(__assign({}, fileOptions.optimizations), inlineConfig.optimizations);
+    }
+    return merged;
+}
+/**
+ * The runtime sections of a project config, or `undefined` when it has none, so that a project
+ * without any gets no `config.json` artifact.
+ */
+function getRuntimeConfig(project) {
+    var e_2, _a;
+    var runtime = {};
+    var any = false;
+    try {
+        for (var RUNTIME_SECTIONS_1 = __values(exports.RUNTIME_SECTIONS), RUNTIME_SECTIONS_1_1 = RUNTIME_SECTIONS_1.next(); !RUNTIME_SECTIONS_1_1.done; RUNTIME_SECTIONS_1_1 = RUNTIME_SECTIONS_1.next()) {
+            var section = RUNTIME_SECTIONS_1_1.value;
+            var value = project[section];
+            if (value !== undefined) {
+                runtime[section] = value;
+                any = true;
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (RUNTIME_SECTIONS_1_1 && !RUNTIME_SECTIONS_1_1.done && (_a = RUNTIME_SECTIONS_1.return)) _a.call(RUNTIME_SECTIONS_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return any ? runtime : undefined;
+}
+/**
+ * A fingerprint of everything a compilation takes from the config file and the environment: the
+ * effective options, the whole file after substitution, and the environment itself, since
+ * `Flamework.env` reads variables the file never mentions.
+ *
+ * A watcher reads all of this once, when it starts, and compares later reads against the first:
+ * a change means files that do not recompile would disagree with files that do, so the first read
+ * stays in force and the watcher says to restart.
+ */
+function fingerprintProjectConfig(loaded) {
+    var stable = function (value) {
+        if (Array.isArray(value)) {
+            return value.map(stable);
+        }
+        if (value !== null && typeof value === "object") {
+            return Object.fromEntries(Object.keys(value)
+                .sort()
+                .map(function (key) { return [key, stable(value[key])]; }));
+        }
+        return value;
+    };
+    var snapshot = { config: loaded.config, project: loaded.project, configPath: loaded.configPath, env: loaded.env };
+    return crypto_1.default
+        .createHash("sha1")
+        .update(JSON.stringify(stable(snapshot)))
+        .digest("hex");
+}
+/**
+ * Resolves the project config, the effective transformer options and the environment for a
+ * compilation.
+ */
+function loadProjectConfig(projectDirectory, rootDirectory, inlineConfig, processEnv) {
+    var configPath = findProjectConfig(projectDirectory, rootDirectory, inlineConfig.configFile);
+    var env = (0, env_1.loadEnv)(configPath !== undefined ? path_1.default.dirname(configPath) : projectDirectory, processEnv);
+    if (configPath === undefined) {
+        return { config: mergeTransformerConfig(undefined, inlineConfig), project: {}, env: env };
+    }
+    var project = readProjectConfig(configPath, env);
+    logger_1.Logger.infoIfVerbose("Loaded project config from ".concat(path_1.default.relative(projectDirectory, configPath) || configPath));
+    return { config: mergeTransformerConfig(project.transformer, inlineConfig), project: project, configPath: configPath, env: env };
+}

package/out/util/schema.js

@@ -0,0 +1,80 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaErrors = getSchemaErrors;
+exports.getSchema = getSchema;
+exports.validateSchema = validateSchema;
+var ajv_1 = __importDefault(require("ajv"));
+var path_1 = __importDefault(require("path"));
+var fs_1 = __importDefault(require("fs"));
+/** Schemas that live in their own file, so editors can reference them directly. */
+var STANDALONE_SCHEMAS = {
+    projectConfig: "flamework.config.schema.json",
+};
+var SCHEMA = createSchema();
+function createSchema() {
+    var e_1, _a;
+    var schema = new ajv_1.default();
+    schema.addSchema(readSchema("flamework-schema.json"), "root");
+    try {
+        for (var _b = __values(Object.entries(STANDALONE_SCHEMAS)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var _d = __read(_c.value, 2), key = _d[0], file = _d[1];
+            schema.addSchema(readSchema(file), key);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return schema;
+}
+function readSchema(file) {
+    return JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, "../..", file), { encoding: "utf8" }));
+}
+function getSchemaErrors() {
+    var _a;
+    return (_a = SCHEMA.errors) !== null && _a !== void 0 ? _a : [];
+}
+/** The parsed schema itself, for code that walks it alongside a value. */
+function getSchema(key) {
+    var validate = SCHEMA.getSchema(key in STANDALONE_SCHEMAS ? key : "root#/properties/".concat(key));
+    if (!validate || typeof validate.schema !== "object") {
+        throw new Error("No schema registered for '".concat(key, "'"));
+    }
+    return validate.schema;
+}
+function validateSchema(key, value) {
+    return SCHEMA.validate(key in STANDALONE_SCHEMAS ? key : "root#/properties/".concat(key), value);
+}

package/out/util/tsInternals.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TYPE_FLAG_DISJOINT_DOMAINS = exports.TYPE_FLAG_INTRINSIC = void 0;
+var typescript_1 = __importDefault(require("typescript"));
+/**
+ * TypeScript does not export these `TypeFlags` members, and enum declaration merging would require
+ * hardcoding their numeric values -- which are computed from other flags and drift between
+ * releases. Reading them off the real enum keeps them correct for whatever TypeScript the project
+ * happens to be compiling with.
+ */
+var internalTypeFlags = typescript_1.default.TypeFlags;
+exports.TYPE_FLAG_INTRINSIC = internalTypeFlags.Intrinsic;
+exports.TYPE_FLAG_DISJOINT_DOMAINS = internalTypeFlags.DisjointDomains;

package/out/util/uid.js

@@ -0,0 +1,227 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeUid = getTypeUid;
+exports.getNodeTypeUid = getNodeTypeUid;
+var path_1 = __importDefault(require("path"));
+var typescript_1 = __importDefault(require("typescript"));
+var diagnostics_1 = require("../classes/diagnostics");
+var getDeclarationName_1 = require("./functions/getDeclarationName");
+var tsInternals_1 = require("./tsInternals");
+var getPackageJson_1 = require("./functions/getPackageJson");
+var isDefinedType_1 = require("./functions/isDefinedType");
+var isPathDescendantOf_1 = require("./functions/isPathDescendantOf");
+var assert_1 = require("./functions/assert");
+/**
+ * Format the internal id to be shorter, remove `out` part of path, and use hashPrefix.
+ */
+function formatInternalid(state, internalId, hashPrefix) {
+    if (hashPrefix === void 0) { hashPrefix = state.config.hashPrefix; }
+    var match = new RegExp("^.*:(.*)@(.+)$").exec(internalId);
+    if (!match)
+        return internalId;
+    var _a = __read(match, 3), path = _a[1], name = _a[2];
+    var revisedPath = path.replace(/^(.*?)[\/\\]/, "");
+    return hashPrefix ? "".concat(hashPrefix, ":").concat(revisedPath, "@").concat(name) : "".concat(revisedPath, "@").concat(name);
+}
+/**
+ * Gets the short ID for a node and includes the hash for uniqueness.
+ */
+function getShortId(state, node, hashPrefix) {
+    if (hashPrefix === void 0) { hashPrefix = state.config.hashPrefix; }
+    var hash = state.hash(state.buildInfo.getLatestId(), true);
+    var fullName = (0, getDeclarationName_1.getDeclarationName)(node);
+    var fileName = path_1.default.parse(node.getSourceFile().fileName).name;
+    var luaFileName = fileName === "index" ? "init" : fileName;
+    var isShort = state.config.idGenerationMode === "short";
+    var shortId = "".concat(isShort ? luaFileName + "@" : "").concat(fullName, "{").concat(hash, "}");
+    return hashPrefix ? "".concat(state.config.hashPrefix, ":").concat(shortId) : shortId;
+}
+function getInternalId(state, node) {
+    var filePath = state.getSourceFile(node).fileName;
+    var fullName = (0, getDeclarationName_1.getDeclarationName)(node);
+    var _a = (0, getPackageJson_1.getPackageJson)(path_1.default.dirname(filePath)), directory = _a.directory, result = _a.result;
+    if ((0, isPathDescendantOf_1.isPathDescendantOfAny)(filePath, state.rootDirs)) {
+        var outputPath = state.pathTranslator.getOutputPath(filePath).replace(/(\.lua)$/, "");
+        var relativePath_1 = path_1.default.relative(state.currentDirectory, outputPath);
+        var internalId_1 = "".concat(result.name, ":").concat(relativePath_1.replace(/\\/g, "/"), "@").concat(fullName);
+        return {
+            isPackage: false,
+            internalId: internalId_1,
+        };
+    }
+    var relativePath = path_1.default.relative(directory, filePath.replace(/(\.d)?.ts$/, "").replace(/index$/, "init"));
+    var internalId = "".concat(result.name, ":").concat(relativePath.replace(/\\/g, "/"), "@").concat(fullName);
+    return {
+        isPackage: true,
+        internalId: internalId,
+    };
+}
+function getDeclarationUid(state, node) {
+    var _a = getInternalId(state, node), isPackage = _a.isPackage, internalId = _a.internalId;
+    var id = state.buildInfo.getIdentifierFromInternal(internalId);
+    if (id)
+        return id;
+    // this is a package, and the package itself did not generate an id
+    // use the internal ID to prevent breakage between packages and games.
+    if (isPackage) {
+        var buildInfo = state.buildInfo.getBuildInfoFromFile(state.getSourceFile(node).fileName);
+        if (buildInfo) {
+            var prefix = buildInfo.getIdentifierPrefix();
+            if (prefix) {
+                return formatInternalid(state, internalId, prefix);
+            }
+        }
+        return internalId;
+    }
+    var newId;
+    if (state.config.idGenerationMode === "obfuscated") {
+        newId = state.hash(state.buildInfo.getLatestId());
+    }
+    else if (state.config.idGenerationMode === "short" || state.config.idGenerationMode === "tiny") {
+        newId = getShortId(state, node);
+    }
+    else {
+        newId = formatInternalid(state, internalId);
+    }
+    state.buildInfo.addIdentifier(internalId, newId);
+    return newId;
+}
+function findValidDeclaration(symbol, trace) {
+    var e_1, _a, e_2, _b;
+    var _c, _d;
+    var usableDeclarations = new Array();
+    try {
+        for (var _e = __values((_c = symbol.declarations) !== null && _c !== void 0 ? _c : []), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var declaration = _f.value;
+            if (typescript_1.default.isTypeLiteralNode(declaration) || typescript_1.default.isTypeAliasDeclaration(declaration)) {
+                var typeAlias = typescript_1.default.findAncestor(declaration, typescript_1.default.isTypeAliasDeclaration);
+                if (typeAlias) {
+                    usableDeclarations.push(typeAlias);
+                    continue;
+                }
+            }
+            if (typescript_1.default.isInterfaceDeclaration(declaration)) {
+                usableDeclarations.push(declaration);
+                continue;
+            }
+            if (typescript_1.default.isClassDeclaration(declaration)) {
+                usableDeclarations.push(declaration);
+                continue;
+            }
+            if (typescript_1.default.isFunctionDeclaration(declaration)) {
+                usableDeclarations.push(declaration);
+                continue;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (usableDeclarations.length <= 1) {
+        return usableDeclarations[0];
+    }
+    var classesOnly = usableDeclarations.filter(typescript_1.default.isClassDeclaration);
+    if (classesOnly.length === 1) {
+        return classesOnly[0];
+    }
+    if (trace) {
+        var diagnostic = diagnostics_1.Diagnostics.createDiagnostic(trace, typescript_1.default.DiagnosticCategory.Error, "There are multiple possible IDs for this symbol: ".concat(symbol.name));
+        try {
+            for (var usableDeclarations_1 = __values(usableDeclarations), usableDeclarations_1_1 = usableDeclarations_1.next(); !usableDeclarations_1_1.done; usableDeclarations_1_1 = usableDeclarations_1.next()) {
+                var declaration = usableDeclarations_1_1.value;
+                typescript_1.default.addRelatedInfo(diagnostic, diagnostics_1.Diagnostics.createDiagnostic((_d = declaration.name) !== null && _d !== void 0 ? _d : declaration, typescript_1.default.DiagnosticCategory.Message, "This is a valid declaration with a unique ID."));
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (usableDeclarations_1_1 && !usableDeclarations_1_1.done && (_b = usableDeclarations_1.return)) _b.call(usableDeclarations_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        throw new diagnostics_1.DiagnosticError(diagnostic);
+    }
+}
+function getSymbolUid(state, symbol, trace) {
+    if (!symbol.declarations) {
+        if (trace) {
+            diagnostics_1.Diagnostics.error(trace, "This symbol does not have any ID: \"".concat(symbol.name, "\""));
+        }
+        return;
+    }
+    var validDeclaration = findValidDeclaration(symbol, trace);
+    if (validDeclaration) {
+        return getDeclarationUid(state, validDeclaration);
+    }
+    if (trace) {
+        diagnostics_1.Diagnostics.error(trace, "Could not find a declaration with a unique ID for '".concat(symbol.name, "'."), "Only classes, interfaces, type aliases and functions have IDs; a type parameter or an anonymous type cannot be used here.");
+    }
+}
+function getTypeUid(state, type, trace) {
+    var injectableConfig = state.typeChecker.getTypeOfPropertyOfType(type, "_flamework_injectable");
+    if (injectableConfig) {
+        var idOverride = state.typeChecker.getTypeOfPropertyOfType(injectableConfig, "id");
+        if (idOverride) {
+            return getTypeUid(state, idOverride, trace);
+        }
+        var originalType = state.typeChecker.getTypeOfPropertyOfType(injectableConfig, "type");
+        (0, assert_1.assert)(originalType !== undefined && originalType !== type, "malformed injectable type");
+        return getTypeUid(state, originalType, trace);
+    }
+    // A type parameter cannot be resolved here; a generic class's own constructor is the usual source,
+    // and only its subclasses -- where the argument is concrete -- are ever constructed. The placeholder
+    // keeps the parameter count intact and fails at resolution time with the parameter's name.
+    if (type.flags & typescript_1.default.TypeFlags.TypeParameter) {
+        return "$tp:".concat(type.checker.typeToString(type));
+    }
+    if (type.symbol) {
+        return getSymbolUid(state, type.symbol, trace);
+    }
+    else if ((0, isDefinedType_1.isDefinedType)(type)) {
+        return "$p:defined";
+    }
+    else if (type.flags & tsInternals_1.TYPE_FLAG_INTRINSIC) {
+        return "$p:".concat(type.intrinsicName);
+    }
+    else if (trace) {
+        diagnostics_1.Diagnostics.error(trace, "Could not find UID for type \"".concat(type.checker.typeToString(type), "\""));
+    }
+}
+function getNodeTypeUid(state, node) {
+    var type = state.typeChecker.getTypeAtLocation(node);
+    return getTypeUid(state, type, node);
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@flamework-experimental/transformer",
+  "version": "2.0.0-alpha.0",
+  "description": "An opinionated game framework for Roblox.",
+  "main": "out/index.js",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -w"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rbxts-flamework/transformer.git"
+  },
+  "files": [
+    "out",
+    "index.d.ts",
+    "rojo-schema.json",
+    "flamework-schema.json",
+    "flamework.config.schema.json",
+    "types.d.ts"
+  ],
+  "dependencies": {
+    "@roblox-ts/path-translator": "^1.1.0",
+    "@roblox-ts/rojo-resolver": "^1.1.0",
+    "ajv": "^8.6.3",
+    "chalk": "^4.1.2",
+    "fs-extra": "^10.0.0",
+    "glob": "9.3",
+    "hashids": "^2.2.8",
+    "normalize-package-data": "^3.0.3",
+    "uuid": "^8.3.2"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^9.0.13",
+    "@types/node": "^16.11.1",
+    "@types/normalize-package-data": "^2.4.1",
+    "@types/uuid": "^8.3.1",
+    "@flamework-experimental/transformer-plugin": "2.0.0-alpha.0",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "typescript": "*"
+  },
+  "types": "types.d.ts"
+}

package/rojo-schema.json

@@ -0,0 +1,34 @@
+{
+	"$schema": "http://json-schema.org/draft-07/schema#",
+	"required": ["name", "tree"],
+	"type": "object",
+	"properties": {
+		"name": {
+			"type": "string"
+		},
+		"servePort": {
+			"type": "integer"
+		},
+		"tree": {
+			"$id": "tree",
+			"type": "object",
+			"properties": {
+				"$className": {
+					"type": "string"
+				},
+				"$ignoreUnknownInstances": {
+					"type": "boolean"
+				},
+				"$path": {
+					"type": "string"
+				},
+				"$properties": {
+					"type": "object"
+				}
+			},
+			"patternProperties": {
+				"^[^\\$].*$": { "$ref": "tree" }
+			}
+		}
+	}
+}

package/types.d.ts

@@ -0,0 +1,4 @@
+// Deliberately empty. A game lists the scope in its typeRoots, and TypeScript then treats every
+// package in that directory as a type library to include: this file is what it finds here, so
+// the transformer's own declarations (typescript and all) never enter a place's program.
+export {};