xray16 1.6.3 → 1.6.4

package/README.md

@@ -115,17 +115,17 @@ This avoids temporary result locals for patterns like `return condition ? first
 
 ### inline_constants
 
-Plugin inlining compile-time constant values of `@inline` JSDoc tagged declarations.\
+Plugin that inlines compile-time constants from declarations tagged with `@inline` or `@virtual`.\
 Supported targets are enums, module-level `as const` object literals and module-level scalar constants.\
-Member accesses are replaced with literal values in place, while original tables are still emitted,
-so iteration / reverse mapping / whole-object usages keep working.\
+Values may be literals or expressions that can be folded at build time: arithmetic, string concatenation,
+template literals and references to other constant declarations.\
 Tagged declarations act as an explicit whitelist and produce build errors when they cannot be inlined.
 
-Values may be literals or expressions foldable on build time - arithmetic, string concatenation,
-template literals and references to other constant declarations (enum members, module-level const scalars,
-`as const` object properties, whitelisted namespace constants like `math.pi`).\
-Runtime-dependent expressions (function calls, mutable object properties, values producing NaN / Infinity)
-are rejected with build errors.
+- `@inline` replaces accesses with literal values but still emits the original declaration, so iteration,
+  reverse mapping and whole-object usages keep working. Import bindings that are no longer used at runtime
+  are stripped; if the target module is proven pure, its `require` is dropped too.
+- `@virtual` includes `@inline` behavior and also removes the declaration from emitted output. Every value
+  reference must be computable at build time. Object spreads of virtual objects are expanded to table literals.
 
 ```typescript
 /**
@@ -137,19 +137,16 @@ export const medkits = {
 } as const;
 
 /**
- * @inline
+ * @virtual
  */
 export const TIMEOUT: number = 60 * 1000;
 
-/**
- * @inline
- */
-export const PI_DEGREE: number = math.pi / 180;
-
 // Build time: `medkits.medkit_army` access is emitted as plain "medkit_army" string literal.
-// Build time: `TIMEOUT` reference is emitted as 60000, `PI_DEGREE` as 0.017453292519943295.
+// Build time: `TIMEOUT` reference is emitted as 60000 and the declaration is erased from output.
 ```
 
+See [src/plugins/inline_constants/README.md](src/plugins/inline_constants/README.md) for full documentation.
+
 ### inject_tracy_zones
 
 Plugin designed to work specifically with [tracy profiler](https://github.com/wolfpld/tracy).\

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xray16",
-  "version": "1.6.3",
+  "version": "1.6.4",
   "author": "Neloreck",
   "repository": "https://github.com/xray-forge/xray-16-types",
   "homepage": "https://xray-forge.github.io/xray-16-types/index.html",

package/plugins/inline_constants/plugin.d.ts

@@ -1,14 +1,21 @@
 import { type Plugin } from "typescript-to-lua";
 /**
- * Plugin that inlines compile-time constant values of `@inline` JSDoc tagged declarations.
+ * Plugin that inlines compile-time constants from declarations tagged with `@inline` or `@virtual`.
  *
  * Supported targets are enums, module-level `as const` object literals and module-level scalar constants.
- * Values may be literals or expressions foldable on build time - arithmetic, string concatenation,
+ * Values may be literals or expressions that can be folded at build time: arithmetic, string concatenation,
  * template literals and references to other constant declarations (enum members, const scalars,
  * `as const` object properties, whitelisted constants like 'math.pi').
- * Tagged declarations act as an explicit whitelist - member accesses are replaced with literal values in place,
- * while original tables are still emitted, so iteration / reverse mapping / whole-object usages keep working.
- * Tagged declarations that cannot be inlined produce build errors instead of silently emitting property lookups.
+ *
+ * `@inline` replaces member accesses with literal values while still emitting the original declaration,
+ * so iteration, reverse mapping and whole-object usages keep working. Import bindings with no remaining
+ * runtime usages are stripped; requires of provably pure modules are dropped with them.
+ *
+ * `@virtual` includes `@inline` behavior and also erases the declaration from emitted output. Every
+ * value reference must be computable at build time. Object spreads are expanded to table literals.
+ * Modules containing `@virtual` declarations are validated to be side-effect free.
+ *
+ * Tagged declarations act as an explicit whitelist and produce build errors when they cannot be inlined.
  */
 declare const plugin: Plugin;
 export default plugin;

package/plugins/inline_constants/plugin.js

@@ -3,22 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ts = require("typescript");
 const transformation_1 = require("./transformation");
 /**
- * Plugin that inlines compile-time constant values of `@inline` JSDoc tagged declarations.
+ * Plugin that inlines compile-time constants from declarations tagged with `@inline` or `@virtual`.
  *
  * Supported targets are enums, module-level `as const` object literals and module-level scalar constants.
- * Values may be literals or expressions foldable on build time - arithmetic, string concatenation,
+ * Values may be literals or expressions that can be folded at build time: arithmetic, string concatenation,
  * template literals and references to other constant declarations (enum members, const scalars,
  * `as const` object properties, whitelisted constants like 'math.pi').
- * Tagged declarations act as an explicit whitelist - member accesses are replaced with literal values in place,
- * while original tables are still emitted, so iteration / reverse mapping / whole-object usages keep working.
- * Tagged declarations that cannot be inlined produce build errors instead of silently emitting property lookups.
+ *
+ * `@inline` replaces member accesses with literal values while still emitting the original declaration,
+ * so iteration, reverse mapping and whole-object usages keep working. Import bindings with no remaining
+ * runtime usages are stripped; requires of provably pure modules are dropped with them.
+ *
+ * `@virtual` includes `@inline` behavior and also erases the declaration from emitted output. Every
+ * value reference must be computable at build time. Object spreads are expanded to table literals.
+ * Modules containing `@virtual` declarations are validated to be side-effect free.
+ *
+ * Tagged declarations act as an explicit whitelist and produce build errors when they cannot be inlined.
  */
 const plugin = {
     beforeTransform(program) {
         // Force binder to assign node parents before any 'getJSDocTags' call,
         // otherwise empty results are computed for parent-less nodes and cached on them forever.
         program.getTypeChecker();
-        const diagnostics = (0, transformation_1.validateTopLevelTags)(program);
+        const diagnostics = [...(0, transformation_1.validateTopLevelTags)(program), ...(0, transformation_1.collectVirtualDiagnostics)(program)];
         if (diagnostics.length > 0) {
             return diagnostics;
         }
@@ -27,15 +34,22 @@ const plugin = {
         [ts.SyntaxKind.PropertyAccessExpression]: transformation_1.transformAccessExpression,
         [ts.SyntaxKind.ElementAccessExpression]: transformation_1.transformAccessExpression,
         [ts.SyntaxKind.Identifier]: transformation_1.transformIdentifierExpression,
+        [ts.SyntaxKind.ImportDeclaration]: transformation_1.transformImportDeclaration,
         [ts.SyntaxKind.VariableStatement]: (statement, context) => {
             if ((0, transformation_1.hasInlineTag)(statement)) {
                 (0, transformation_1.validateVariableStatement)(statement, context);
+                if ((0, transformation_1.hasVirtualTag)(statement)) {
+                    return [];
+                }
             }
             return context.superTransformStatements(statement);
         },
         [ts.SyntaxKind.EnumDeclaration]: (declaration, context) => {
             if ((0, transformation_1.hasInlineTag)(declaration)) {
                 (0, transformation_1.validateEnumDeclaration)(declaration, context);
+                if ((0, transformation_1.hasVirtualTag)(declaration)) {
+                    return [];
+                }
             }
             return context.superTransformStatements(declaration);
         },

package/plugins/inline_constants/transformation/ast.d.ts

@@ -1,20 +1,28 @@
 import * as ts from "typescript";
 /**
- * Check whether node is annotated with `@inline` JSDoc tag.
+ * Check whether a node is whitelisted for inlining.
+ * Both `@inline` and `@virtual` enable inlining; `@virtual` adds erasure rules elsewhere.
  *
  * @param node - Node to check tags for.
- * @returns Whether the node has `@inline` JSDoc tag.
+ * @returns Whether the node is whitelisted for inlining.
  */
 export declare function hasInlineTag(node: ts.Node): boolean;
 /**
- * Find variable statement containing provided declaration node, if any.
+ * Check whether a node has the `@virtual` JSDoc tag.
+ *
+ * @param node - Node to check tags for.
+ * @returns Whether the node has `@virtual` JSDoc tag.
+ */
+export declare function hasVirtualTag(node: ts.Node): boolean;
+/**
+ * Find the variable statement that contains the provided declaration node.
  *
  * @param node - Declaration node to walk up from.
  * @returns Containing variable statement or null.
  */
 export declare function getContainingVariableStatement(node: ts.Node): ts.VariableStatement | null;
 /**
- * Unwrap initializer expression from as/satisfies/parenthesized wrappers.
+ * Unwrap an initializer expression from `as`, `satisfies`, and parenthesized wrappers.
  *
  * @param expression - Initializer expression to unwrap.
  * @returns Unwrapped expression or null.
@@ -24,18 +32,18 @@ export declare function unwrapInitializer(expression?: ts.Expression): ts.Expres
  * Check whether variable statement is a module-level `const` declaration.
  *
  * @param statement - Variable statement to check.
- * @returns Whether statement is module-level const.
+ * @returns Whether the statement is a module-level const.
  */
 export declare function isModuleLevelConst(statement: ts.VariableStatement): boolean;
 /**
- * Check whether expression is wrapped with `as const` assertion, possibly through parens/satisfies wrappers.
+ * Check whether an expression is wrapped in an `as const` assertion, possibly through parens/satisfies wrappers.
  *
  * @param expression - Expression to check.
- * @returns Whether expression has `as const` assertion.
+ * @returns Whether the expression has an `as const` assertion.
  */
 export declare function hasAsConstAssertion(expression?: ts.Expression): boolean;
 /**
- * Check whether property is declared inside an `as const` object literal assigned to a module-level const.
+ * Check whether a property is declared inside an `as const` object literal assigned to a module-level const.
  * Such properties are readonly and cannot be legally reassigned, so their values are stable at runtime.
  *
  * @param declaration - Property declaration to check.
@@ -43,18 +51,19 @@ export declare function hasAsConstAssertion(expression?: ts.Expression): boolean
  */
 export declare function isReadonlyModuleConstProperty(declaration: ts.PropertyAssignment | ts.ShorthandPropertyAssignment): boolean;
 /**
- * Check whether identifier node is used in a value position where it can be replaced with a literal.
+ * Check whether an identifier is used in a value position where it can be replaced with a literal.
  *
  * @param node - Identifier node to check.
- * @returns Whether identifier is a replace-able value usage.
+ * @returns Whether the identifier is a replaceable value usage.
  */
 export declare function isValueUsagePosition(node: ts.Identifier): boolean;
 /**
- * Resolve member symbol for property/element access expression.
- * Element access with literal key is resolved through object type when direct symbol resolution fails.
+ * Get global access path for a runtime-constant engine member declaration.
+ * Qualifying declarations are `static readonly` class members declared inside ambient `declare module "xray16"` -
+ * such values are registered once by the engine and never change at runtime.
+ * The path uses the declared class name, so import aliases do not affect emitted references.
  *
- * @param checker - Program type checker.
- * @param node - Access expression to resolve symbol for.
- * @returns Resolved member symbol or null.
+ * @param declaration - Declaration to check.
+ * @returns Global access path like ['stalker_ids', 'action_dying'], or null when not a constant engine member.
  */
-export declare function resolveMemberSymbol(checker: ts.TypeChecker, node: ts.PropertyAccessExpression | ts.ElementAccessExpression): ts.Symbol | null;
+export declare function getEngineConstantPath(declaration: ts.Declaration): Array<string> | null;

package/plugins/inline_constants/transformation/ast.js

@@ -1,26 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasInlineTag = hasInlineTag;
+exports.hasVirtualTag = hasVirtualTag;
 exports.getContainingVariableStatement = getContainingVariableStatement;
 exports.unwrapInitializer = unwrapInitializer;
 exports.isModuleLevelConst = isModuleLevelConst;
 exports.hasAsConstAssertion = hasAsConstAssertion;
 exports.isReadonlyModuleConstProperty = isReadonlyModuleConstProperty;
 exports.isValueUsagePosition = isValueUsagePosition;
-exports.resolveMemberSymbol = resolveMemberSymbol;
+exports.getEngineConstantPath = getEngineConstantPath;
 const ts = require("typescript");
 const constants_1 = require("./constants");
 /**
- * Check whether node is annotated with `@inline` JSDoc tag.
+ * Check whether a node has the provided JSDoc tag.
  *
  * @param node - Node to check tags for.
- * @returns Whether the node has `@inline` JSDoc tag.
+ * @param tag - Tag name to look for.
+ * @returns Whether the node has the JSDoc tag.
+ */
+function hasJsDocTag(node, tag) {
+    return ts.getJSDocTags(node).some((it) => it.tagName.text === tag);
+}
+/**
+ * Check whether a node is whitelisted for inlining.
+ * Both `@inline` and `@virtual` enable inlining; `@virtual` adds erasure rules elsewhere.
+ *
+ * @param node - Node to check tags for.
+ * @returns Whether the node is whitelisted for inlining.
  */
 function hasInlineTag(node) {
-    return ts.getJSDocTags(node).some((it) => it.tagName.text === constants_1.INLINE_TAG);
+    return hasJsDocTag(node, constants_1.INLINE_TAG) || hasJsDocTag(node, constants_1.VIRTUAL_TAG);
 }
 /**
- * Find variable statement containing provided declaration node, if any.
+ * Check whether a node has the `@virtual` JSDoc tag.
+ *
+ * @param node - Node to check tags for.
+ * @returns Whether the node has `@virtual` JSDoc tag.
+ */
+function hasVirtualTag(node) {
+    return hasJsDocTag(node, constants_1.VIRTUAL_TAG);
+}
+/**
+ * Find the variable statement that contains the provided declaration node.
  *
  * @param node - Declaration node to walk up from.
  * @returns Containing variable statement or null.
@@ -36,7 +57,7 @@ function getContainingVariableStatement(node) {
     return null;
 }
 /**
- * Unwrap initializer expression from as/satisfies/parenthesized wrappers.
+ * Unwrap an initializer expression from `as`, `satisfies`, and parenthesized wrappers.
  *
  * @param expression - Initializer expression to unwrap.
  * @returns Unwrapped expression or null.
@@ -56,16 +77,16 @@ function unwrapInitializer(expression) {
  * Check whether variable statement is a module-level `const` declaration.
  *
  * @param statement - Variable statement to check.
- * @returns Whether statement is module-level const.
+ * @returns Whether the statement is a module-level const.
  */
 function isModuleLevelConst(statement) {
     return ts.isSourceFile(statement.parent) && (statement.declarationList.flags & ts.NodeFlags.Const) !== 0;
 }
 /**
- * Check whether expression is wrapped with `as const` assertion, possibly through parens/satisfies wrappers.
+ * Check whether an expression is wrapped in an `as const` assertion, possibly through parens/satisfies wrappers.
  *
  * @param expression - Expression to check.
- * @returns Whether expression has `as const` assertion.
+ * @returns Whether the expression has an `as const` assertion.
  */
 function hasAsConstAssertion(expression) {
     let current = expression;
@@ -85,7 +106,7 @@ function hasAsConstAssertion(expression) {
     return false;
 }
 /**
- * Check whether property is declared inside an `as const` object literal assigned to a module-level const.
+ * Check whether a property is declared inside an `as const` object literal assigned to a module-level const.
  * Such properties are readonly and cannot be legally reassigned, so their values are stable at runtime.
  *
  * @param declaration - Property declaration to check.
@@ -116,10 +137,10 @@ function isReadonlyModuleConstProperty(declaration) {
     return statement !== null && isModuleLevelConst(statement);
 }
 /**
- * Check whether identifier node is used in a value position where it can be replaced with a literal.
+ * Check whether an identifier is used in a value position where it can be replaced with a literal.
  *
  * @param node - Identifier node to check.
- * @returns Whether identifier is a replace-able value usage.
+ * @returns Whether the identifier is a replaceable value usage.
  */
 function isValueUsagePosition(node) {
     const parent = node.parent;
@@ -165,21 +186,34 @@ function isValueUsagePosition(node) {
     return true;
 }
 /**
- * Resolve member symbol for property/element access expression.
- * Element access with literal key is resolved through object type when direct symbol resolution fails.
+ * Get global access path for a runtime-constant engine member declaration.
+ * Qualifying declarations are `static readonly` class members declared inside ambient `declare module "xray16"` -
+ * such values are registered once by the engine and never change at runtime.
+ * The path uses the declared class name, so import aliases do not affect emitted references.
  *
- * @param checker - Program type checker.
- * @param node - Access expression to resolve symbol for.
- * @returns Resolved member symbol or null.
+ * @param declaration - Declaration to check.
+ * @returns Global access path like ['stalker_ids', 'action_dying'], or null when not a constant engine member.
  */
-function resolveMemberSymbol(checker, node) {
-    const symbol = checker.getSymbolAtLocation(node);
-    if (symbol !== undefined) {
-        return symbol;
+function getEngineConstantPath(declaration) {
+    if (!ts.isPropertyDeclaration(declaration) || !ts.isIdentifier(declaration.name)) {
+        return null;
+    }
+    const modifiers = ts.getModifiers(declaration) ?? [];
+    const isStaticReadonly = modifiers.some((it) => it.kind === ts.SyntaxKind.StaticKeyword) &&
+        modifiers.some((it) => it.kind === ts.SyntaxKind.ReadonlyKeyword);
+    if (!isStaticReadonly) {
+        return null;
+    }
+    const classDeclaration = declaration.parent;
+    if (!ts.isClassDeclaration(classDeclaration) || classDeclaration.name === undefined) {
+        return null;
     }
-    if (ts.isElementAccessExpression(node) &&
-        (ts.isStringLiteralLike(node.argumentExpression) || ts.isNumericLiteral(node.argumentExpression))) {
-        return checker.getTypeAtLocation(node.expression).getProperty(node.argumentExpression.text) ?? null;
+    let current = classDeclaration.parent;
+    while (current !== undefined && !ts.isSourceFile(current)) {
+        if (ts.isModuleDeclaration(current) && ts.isStringLiteral(current.name) && current.name.text === "xray16") {
+            return [classDeclaration.name.text, declaration.name.text];
+        }
+        current = current.parent;
     }
     return null;
 }

package/plugins/inline_constants/transformation/constants.d.ts

@@ -3,12 +3,70 @@
  */
 export declare const INLINE_TAG: string;
 /**
- * Value types that can be inlined as lua literals.
+ * JSDoc tag marking declarations for compile-time inlining and erasure from emitted output.
+ * Includes `@inline` behavior and requires every value reference to be erasable.
+ */
+export declare const VIRTUAL_TAG: string;
+/**
+ * Value types that can be inlined as Lua literals.
  */
 export type TInlineValue = string | number | boolean;
 /**
- * Numeric namespace constants that are identical IEEE 754 doubles in build environment and LuaJIT runtime.
- * Covers both TS 'Math' and lua 'math' namespaces, function calls are intentionally not supported
- * since libm implementations may differ between build machine and game runtime.
+ * Reference to a runtime-constant engine value like 'stalker_ids.action_dying'.
+ * Emitted as a global access expression instead of a baked literal, so values stay correct
+ * even when engine builds diverge from the literal types declared in typings.
+ */
+export interface IEngineReference {
+    kind: "engine-ref";
+    path: Array<string>;
+    isNumeric: boolean;
+}
+/**
+ * Binary numeric expression mixing engine references with other folded values.
+ */
+export interface IFoldedBinary {
+    kind: "binary";
+    operator: TFoldedBinaryOperator;
+    left: TFoldedValue;
+    right: TFoldedValue;
+}
+/**
+ * Numeric negation of a folded expression.
+ */
+export interface IFoldedNegation {
+    kind: "negate";
+    operand: TFoldedValue;
+}
+/**
+ * Operators allowed in folded expression trees - restricted to those where emitted Lua matches
+ * tstl lowering exactly. '%', bitwise operators and string concatenation are rejected for trees.
+ */
+export type TFoldedBinaryOperator = "+" | "-" | "*" | "/" | "**";
+/**
+ * Expression parts of folded values that cannot be computed to plain literals at build time.
+ */
+export type TFoldedExpression = IEngineReference | IFoldedBinary | IFoldedNegation;
+/**
+ * Result of build-time folding - either a plain literal or an expression tree with engine references.
+ */
+export type TFoldedValue = TInlineValue | TFoldedExpression;
+/**
+ * Check whether folded value is an expression tree rather than a plain literal.
+ *
+ * @param value - Folded value to check.
+ * @returns Whether value is an expression tree.
+ */
+export declare function isFoldedExpression(value: TFoldedValue): value is TFoldedExpression;
+/**
+ * Check whether folded value is numeric - a number literal or a numeric expression tree.
+ *
+ * @param value - Folded value to check.
+ * @returns Whether value is numeric.
+ */
+export declare function isNumericFoldedValue(value: TFoldedValue): boolean;
+/**
+ * Numeric namespace constants with identical IEEE 754 double values in the build environment and LuaJIT runtime.
+ * Covers both TS 'Math' and Lua 'math' namespaces. Function calls are intentionally not supported because
+ * libm implementations may differ between build machine and game runtime.
  */
 export declare const FOLDABLE_NAMESPACE_CONSTANTS: Record<string, Record<string, number>>;

package/plugins/inline_constants/transformation/constants.js

@@ -1,14 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FOLDABLE_NAMESPACE_CONSTANTS = exports.INLINE_TAG = void 0;
+exports.FOLDABLE_NAMESPACE_CONSTANTS = exports.VIRTUAL_TAG = exports.INLINE_TAG = void 0;
+exports.isFoldedExpression = isFoldedExpression;
+exports.isNumericFoldedValue = isNumericFoldedValue;
 /**
  * JSDoc tag marking declarations as whitelisted for compile-time inlining.
  */
 exports.INLINE_TAG = "inline";
 /**
- * Numeric namespace constants that are identical IEEE 754 doubles in build environment and LuaJIT runtime.
- * Covers both TS 'Math' and lua 'math' namespaces, function calls are intentionally not supported
- * since libm implementations may differ between build machine and game runtime.
+ * JSDoc tag marking declarations for compile-time inlining and erasure from emitted output.
+ * Includes `@inline` behavior and requires every value reference to be erasable.
+ */
+exports.VIRTUAL_TAG = "virtual";
+/**
+ * Check whether folded value is an expression tree rather than a plain literal.
+ *
+ * @param value - Folded value to check.
+ * @returns Whether value is an expression tree.
+ */
+function isFoldedExpression(value) {
+    return typeof value === "object";
+}
+/**
+ * Check whether folded value is numeric - a number literal or a numeric expression tree.
+ *
+ * @param value - Folded value to check.
+ * @returns Whether value is numeric.
+ */
+function isNumericFoldedValue(value) {
+    if (typeof value === "number") {
+        return true;
+    }
+    if (typeof value === "object") {
+        return value.kind === "engine-ref" ? value.isNumeric : true;
+    }
+    return false;
+}
+/**
+ * Numeric namespace constants with identical IEEE 754 double values in the build environment and LuaJIT runtime.
+ * Covers both TS 'Math' and Lua 'math' namespaces. Function calls are intentionally not supported because
+ * libm implementations may differ between build machine and game runtime.
  */
 exports.FOLDABLE_NAMESPACE_CONSTANTS = {
     Math: {

package/plugins/inline_constants/transformation/errors.d.ts

@@ -1,6 +1,12 @@
 export declare const createUnsupportedDeclarationError: ((node: import("typescript").Node, ...args: any[]) => import("typescript").Diagnostic) & {
     code: number;
 };
+export declare const createVirtualValueReferenceError: ((node: import("typescript").Node, name: string) => import("typescript").Diagnostic) & {
+    code: number;
+};
+export declare const createImpureVirtualModuleError: ((node: import("typescript").Node, ...args: any[]) => import("typescript").Diagnostic) & {
+    code: number;
+};
 export declare const createNotModuleLevelError: ((node: import("typescript").Node, ...args: any[]) => import("typescript").Diagnostic) & {
     code: number;
 };

package/plugins/inline_constants/transformation/errors.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNotConstantEnumMemberError = exports.createForeignPropertyError = exports.createNotLiteralPropertyError = exports.createNotLiteralConstantError = exports.createNotAsConstObjectError = exports.createNotConstError = exports.createNotModuleLevelError = exports.createUnsupportedDeclarationError = void 0;
+exports.createNotConstantEnumMemberError = exports.createForeignPropertyError = exports.createNotLiteralPropertyError = exports.createNotLiteralConstantError = exports.createNotAsConstObjectError = exports.createNotConstError = exports.createNotModuleLevelError = exports.createImpureVirtualModuleError = exports.createVirtualValueReferenceError = exports.createUnsupportedDeclarationError = void 0;
 const diagnostics_1 = require("../../utils/diagnostics");
 const constants_1 = require("./constants");
-exports.createUnsupportedDeclarationError = (0, diagnostics_1.createErrorDiagnosticFactory)(`'@${constants_1.INLINE_TAG}' is supported only for enums and module-level 'const' declarations.`);
+exports.createUnsupportedDeclarationError = (0, diagnostics_1.createErrorDiagnosticFactory)(`'@${constants_1.INLINE_TAG}' and '@${constants_1.VIRTUAL_TAG}' are supported only for enums and module-level 'const' declarations.`);
+exports.createVirtualValueReferenceError = (0, diagnostics_1.createErrorDiagnosticFactory)((name) => `'@${constants_1.VIRTUAL_TAG}' declaration '${name}' is referenced as a value and cannot be erased, ` +
+    `demote it to '@${constants_1.INLINE_TAG}' or make the reference computable on build time.`);
+exports.createImpureVirtualModuleError = (0, diagnostics_1.createErrorDiagnosticFactory)(`Modules with '@${constants_1.VIRTUAL_TAG}' declarations may contain only type-only imports, ` +
+    `'@${constants_1.INLINE_TAG}'/'@${constants_1.VIRTUAL_TAG}' constants, constant enums, type aliases and interfaces.`);
 exports.createNotModuleLevelError = (0, diagnostics_1.createErrorDiagnosticFactory)(`'@${constants_1.INLINE_TAG}' declarations must be module-level statements.`);
 exports.createNotConstError = (0, diagnostics_1.createErrorDiagnosticFactory)(`'@${constants_1.INLINE_TAG}' declarations must use 'const' keyword.`);
 exports.createNotAsConstObjectError = (0, diagnostics_1.createErrorDiagnosticFactory)((name) => `'@${constants_1.INLINE_TAG}' object '${name}' must use 'as const' assertion.`);