@tsonic/frontend 0.0.74 → 0.0.75

package/dist/validation/static-safety-arrow-rules.d.ts

@@ -0,0 +1,11 @@
+import * as ts from "typescript";
+import type { DiagnosticsCollector } from "../types/diagnostic.js";
+/**
+ * TSN7430: Arrow function escape hatch validation.
+ *
+ * Arrow functions can infer types from context when a deterministic expected
+ * callable type exists. Without contextual typing, only "simple arrows" are
+ * allowed to rely on inference.
+ */
+export declare const validateArrowEscapeHatch: (node: ts.ArrowFunction, sourceFile: ts.SourceFile, collector: DiagnosticsCollector) => DiagnosticsCollector;
+//# sourceMappingURL=static-safety-arrow-rules.d.ts.map

package/dist/validation/static-safety-arrow-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-safety-arrow-rules.d.ts","sourceRoot":"","sources":["../../src/validation/static-safety-arrow-rules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AA2CnE;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GACnC,MAAM,EAAE,CAAC,aAAa,EACtB,YAAY,EAAE,CAAC,UAAU,EACzB,WAAW,oBAAoB,KAC9B,oBAsCF,CAAC"}

package/dist/validation/static-safety-arrow-rules.js

@@ -0,0 +1,54 @@
+import * as ts from "typescript";
+import { addDiagnostic, createDiagnostic } from "../types/diagnostic.js";
+import { getNodeLocation } from "./helpers.js";
+import { lambdaHasExpectedTypeContext } from "./contextual-type-analysis.js";
+const isSimpleArrow = (node) => {
+    for (const param of node.parameters) {
+        if (!ts.isIdentifier(param.name)) {
+            return {
+                isSimple: false,
+                reason: "Arrow functions with destructuring patterns require explicit type annotations.",
+            };
+        }
+    }
+    for (const param of node.parameters) {
+        if (param.initializer !== undefined) {
+            return {
+                isSimple: false,
+                reason: "Arrow functions with default parameter values require explicit type annotations.",
+            };
+        }
+    }
+    for (const param of node.parameters) {
+        if (param.dotDotDotToken !== undefined) {
+            return {
+                isSimple: false,
+                reason: "Arrow functions with rest parameters require explicit type annotations.",
+            };
+        }
+    }
+    return { isSimple: true };
+};
+/**
+ * TSN7430: Arrow function escape hatch validation.
+ *
+ * Arrow functions can infer types from context when a deterministic expected
+ * callable type exists. Without contextual typing, only "simple arrows" are
+ * allowed to rely on inference.
+ */
+export const validateArrowEscapeHatch = (node, sourceFile, collector) => {
+    const hasExplicitReturnType = node.type !== undefined;
+    const allParamsExplicitlyTyped = node.parameters.every((param) => param.type !== undefined);
+    if (hasExplicitReturnType && allParamsExplicitlyTyped) {
+        return collector;
+    }
+    if (lambdaHasExpectedTypeContext(node)) {
+        return collector;
+    }
+    const simpleArrowResult = isSimpleArrow(node);
+    if (simpleArrowResult.isSimple) {
+        return addDiagnostic(collector, createDiagnostic("TSN7430", "error", "Arrow function requires explicit types. No contextual type available for inference.", getNodeLocation(sourceFile, node), "Add explicit type annotations: (x: Type, y: Type): ReturnType => expression"));
+    }
+    return addDiagnostic(collector, createDiagnostic("TSN7430", "error", `Arrow function requires explicit types. ${simpleArrowResult.reason}`, getNodeLocation(sourceFile, node), "Only expression-bodied arrows with simple identifier parameters can infer types from context. Add explicit parameter and return type annotations."));
+};
+//# sourceMappingURL=static-safety-arrow-rules.js.map

package/dist/validation/static-safety-arrow-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-safety-arrow-rules.js","sourceRoot":"","sources":["../../src/validation/static-safety-arrow-rules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAC;AAE7E,MAAM,aAAa,GAAG,CACpB,IAAsB,EAGkC,EAAE;IAC1D,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;QACpC,IAAI,CAAC,EAAE,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YACjC,OAAO;gBACL,QAAQ,EAAE,KAAK;gBACf,MAAM,EACJ,gFAAgF;aACnF,CAAC;QACJ,CAAC;IACH,CAAC;IAED,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;QACpC,IAAI,KAAK,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;YACpC,OAAO;gBACL,QAAQ,EAAE,KAAK;gBACf,MAAM,EACJ,kFAAkF;aACrF,CAAC;QACJ,CAAC;IACH,CAAC;IAED,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;QACpC,IAAI,KAAK,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;YACvC,OAAO;gBACL,QAAQ,EAAE,KAAK;gBACf,MAAM,EACJ,yEAAyE;aAC5E,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AAC5B,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CACtC,IAAsB,EACtB,UAAyB,EACzB,SAA+B,EACT,EAAE;IACxB,MAAM,qBAAqB,GAAG,IAAI,CAAC,IAAI,KAAK,SAAS,CAAC;IACtD,MAAM,wBAAwB,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CACpD,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,CACpC,CAAC;IAEF,IAAI,qBAAqB,IAAI,wBAAwB,EAAE,CAAC;QACtD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,4BAA4B,CAAC,IAAI,CAAC,EAAE,CAAC;QACvC,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,iBAAiB,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;IAC9C,IAAI,iBAAiB,CAAC,QAAQ,EAAE,CAAC;QAC/B,OAAO,aAAa,CAClB,SAAS,EACT,gBAAgB,CACd,SAAS,EACT,OAAO,EACP,qFAAqF,EACrF,eAAe,CAAC,UAAU,EAAE,IAAI,CAAC,EACjC,6EAA6E,CAC9E,CACF,CAAC;IACJ,CAAC;IAED,OAAO,aAAa,CAClB,SAAS,EACT,gBAAgB,CACd,SAAS,EACT,OAAO,EACP,2CAA2C,iBAAiB,CAAC,MAAM,EAAE,EACrE,eAAe,CAAC,UAAU,EAAE,IAAI,CAAC,EACjC,mJAAmJ,CACpJ,CACF,CAAC;AACJ,CAAC,CAAC"}

package/dist/validation/static-safety-dictionary-keys.d.ts

@@ -0,0 +1,10 @@
+import * as ts from "typescript";
+/**
+ * Check if a type node represents an allowed dictionary key type.
+ * Allowed: string, number, symbol (matches TypeScript's PropertyKey constraint)
+ *
+ * Note: TypeScript's Record<K, V> only allows K extends keyof any (string | number | symbol).
+ * We support all three PropertyKey primitives.
+ */
+export declare const isAllowedKeyType: (typeNode: ts.TypeNode) => boolean;
+//# sourceMappingURL=static-safety-dictionary-keys.d.ts.map

package/dist/validation/static-safety-dictionary-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-safety-dictionary-keys.d.ts","sourceRoot":"","sources":["../../src/validation/static-safety-dictionary-keys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,UAAU,EAAE,CAAC,QAAQ,KAAG,OA8BxD,CAAC"}

package/dist/validation/static-safety-dictionary-keys.js

@@ -0,0 +1,32 @@
+import * as ts from "typescript";
+/**
+ * Check if a type node represents an allowed dictionary key type.
+ * Allowed: string, number, symbol (matches TypeScript's PropertyKey constraint)
+ *
+ * Note: TypeScript's Record<K, V> only allows K extends keyof any (string | number | symbol).
+ * We support all three PropertyKey primitives.
+ */
+export const isAllowedKeyType = (typeNode) => {
+    if (typeNode.kind === ts.SyntaxKind.StringKeyword ||
+        typeNode.kind === ts.SyntaxKind.NumberKeyword ||
+        typeNode.kind === ts.SyntaxKind.SymbolKeyword) {
+        return true;
+    }
+    if (ts.isLiteralTypeNode(typeNode)) {
+        const literal = typeNode.literal;
+        if (ts.isStringLiteral(literal) ||
+            ts.isNumericLiteral(literal) ||
+            literal.kind === ts.SyntaxKind.NumericLiteral) {
+            return true;
+        }
+    }
+    if (ts.isUnionTypeNode(typeNode)) {
+        return typeNode.types.every((member) => isAllowedKeyType(member));
+    }
+    if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
+        const name = typeNode.typeName.text;
+        return name === "string" || name === "number" || name === "symbol";
+    }
+    return false;
+};
+//# sourceMappingURL=static-safety-dictionary-keys.js.map

package/dist/validation/static-safety-dictionary-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-safety-dictionary-keys.js","sourceRoot":"","sources":["../../src/validation/static-safety-dictionary-keys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,QAAqB,EAAW,EAAE;IACjE,IACE,QAAQ,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa;QAC7C,QAAQ,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa;QAC7C,QAAQ,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,EAC7C,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,EAAE,CAAC,iBAAiB,CAAC,QAAQ,CAAC,EAAE,CAAC;QACnC,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC;QACjC,IACE,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC;YAC3B,EAAE,CAAC,gBAAgB,CAAC,OAAO,CAAC;YAC5B,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc,EAC7C,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED,IAAI,EAAE,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,CAAC;QACjC,OAAO,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC;IACpE,CAAC;IAED,IAAI,EAAE,CAAC,mBAAmB,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC3E,MAAM,IAAI,GAAG,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC;QACpC,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,QAAQ,CAAC;IACrE,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC"}

package/dist/validation/static-safety-rules.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Static Safety Validation Rules
+ *
+ * Contains the main validation visitor and rule implementations for:
+ * - TSN7401: 'any' type usage
+ * - TSN7402: 'unknown' type usage outside erased overload stubs
+ * - TSN7403: Object literal without contextual nominal type
+ * - TSN7405: Untyped function/arrow/lambda parameter
+ * - TSN7413: Dictionary key must be string, number, or symbol
+ * - TSN7419: 'never' cannot be used as a generic type argument
+ * - TSN7430: Arrow function requires explicit types (escape hatch)
+ * - TSN7432: Generic function value restrictions
+ *
+ * This ensures NativeAOT-compatible, predictable-performance output.
+ *
+ * Note: We intentionally do NOT validate JS built-in usage (arr.map, str.length)
+ * or dictionary dot-access patterns. These will fail naturally in C# if used
+ * incorrectly, which is an acceptable failure mode.
+ */
+import * as ts from "typescript";
+import { TsonicProgram } from "../program.js";
+import { DiagnosticsCollector } from "../types/diagnostic.js";
+/**
+ * Validate a source file for static safety violations.
+ */
+export declare const validateStaticSafety: (sourceFile: ts.SourceFile, program: TsonicProgram, collector: DiagnosticsCollector) => DiagnosticsCollector;
+//# sourceMappingURL=static-safety-rules.d.ts.map

package/dist/validation/static-safety-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-safety-rules.d.ts","sourceRoot":"","sources":["../../src/validation/static-safety-rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,EACL,oBAAoB,EAGrB,MAAM,wBAAwB,CAAC;AA2DhC;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,YAAY,EAAE,CAAC,UAAU,EACzB,SAAS,aAAa,EACtB,WAAW,oBAAoB,KAC9B,oBA+VF,CAAC"}

package/dist/validation/static-safety-rules.js

@@ -0,0 +1,231 @@
+/**
+ * Static Safety Validation Rules
+ *
+ * Contains the main validation visitor and rule implementations for:
+ * - TSN7401: 'any' type usage
+ * - TSN7402: 'unknown' type usage outside erased overload stubs
+ * - TSN7403: Object literal without contextual nominal type
+ * - TSN7405: Untyped function/arrow/lambda parameter
+ * - TSN7413: Dictionary key must be string, number, or symbol
+ * - TSN7419: 'never' cannot be used as a generic type argument
+ * - TSN7430: Arrow function requires explicit types (escape hatch)
+ * - TSN7432: Generic function value restrictions
+ *
+ * This ensures NativeAOT-compatible, predictable-performance output.
+ *
+ * Note: We intentionally do NOT validate JS built-in usage (arr.map, str.length)
+ * or dictionary dot-access patterns. These will fail naturally in C# if used
+ * incorrectly, which is an acceptable failure mode.
+ */
+import * as ts from "typescript";
+import { isOverloadStubImplementation } from "../ir/syntax/overload-stubs.js";
+import { addDiagnostic, createDiagnostic, } from "../types/diagnostic.js";
+import { getNodeLocation } from "./helpers.js";
+import { collectWrittenSymbols, collectSupportedGenericFunctionValueSymbols, getSupportedGenericFunctionDeclarationSymbol, getSupportedGenericFunctionValueSymbol, isGenericFunctionDeclarationNode, isGenericFunctionValueNode, } from "../generic-function-values.js";
+import { checkBasicSynthesisEligibility, lambdaHasExpectedTypeContext, objectLiteralHasContextualType, isAllowedGenericFunctionValueIdentifierUse, getReferencedIdentifierSymbol, } from "./contextual-type-analysis.js";
+import { isAllowedKeyType } from "./static-safety-dictionary-keys.js";
+import { validateArrowEscapeHatch } from "./static-safety-arrow-rules.js";
+const nodeIsWithin = (node, container) => !!container && node.pos >= container.pos && node.end <= container.end;
+const isInsideOverloadStubSignatureType = (node) => {
+    for (let current = node.parent; current; current = current.parent) {
+        if (!ts.isFunctionDeclaration(current) &&
+            !ts.isMethodDeclaration(current)) {
+            continue;
+        }
+        if (!isOverloadStubImplementation(current)) {
+            return false;
+        }
+        if (nodeIsWithin(node, current.type)) {
+            return true;
+        }
+        return current.parameters.some((parameter) => nodeIsWithin(node, parameter.type));
+    }
+    return false;
+};
+const getAssertionTargetTypeNode = (node) => {
+    if (ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)) {
+        return node.type;
+    }
+    return undefined;
+};
+/**
+ * Validate a source file for static safety violations.
+ */
+export const validateStaticSafety = (sourceFile, program, collector) => {
+    const writtenSymbols = collectWrittenSymbols(sourceFile, program.checker);
+    const supportedGenericFunctionValueSymbols = collectSupportedGenericFunctionValueSymbols(sourceFile, program.checker, writtenSymbols);
+    const visitor = (node, accCollector) => {
+        let currentCollector = accCollector;
+        const isBroadOverloadStubType = isInsideOverloadStubSignatureType(node);
+        // TSN7401: Check for explicit 'any' type annotations
+        if (node.kind === ts.SyntaxKind.AnyKeyword && !isBroadOverloadStubType) {
+            currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7401", "error", "'any' type is not supported. Provide a concrete type, or use a broad overload stub signature that is erased before emission.", getNodeLocation(sourceFile, node), "Replace 'any' with a specific type, or keep it only on an erased overload stub implementation signature."));
+        }
+        // TSN7402: Check for explicit 'unknown' type annotations
+        if (node.kind === ts.SyntaxKind.UnknownKeyword &&
+            !isBroadOverloadStubType) {
+            currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7402", "error", "'unknown' type is not supported. Provide a concrete type, use JsValue, or keep it only on an erased overload stub implementation signature.", getNodeLocation(sourceFile, node), "Replace 'unknown' with a specific type or JsValue, or keep it only on an erased overload stub implementation signature."));
+        }
+        // TSN7401/TSN7402: Check for broad type assertions
+        const assertionTargetType = getAssertionTargetTypeNode(node);
+        if (assertionTargetType?.kind === ts.SyntaxKind.AnyKeyword) {
+            currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7401", "error", "'any' type assertion is not supported. Use a specific type assertion.", getNodeLocation(sourceFile, node), "Replace this assertion with a specific type like 'as object' or 'as YourType'."));
+        }
+        if (assertionTargetType?.kind === ts.SyntaxKind.UnknownKeyword) {
+            currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7402", "error", "'unknown' type assertion is not supported. Use a specific type assertion or JsValue.", getNodeLocation(sourceFile, node), "Replace this assertion with a specific type or JsValue."));
+        }
+        // TSN7405: Check for untyped function parameters
+        // Covers: function declarations, methods, constructors, arrow functions, function expressions
+        if (ts.isParameter(node) && !node.type) {
+            const parent = node.parent;
+            // For lambdas (arrow functions and function expressions), allow inference from context
+            const isLambda = ts.isArrowFunction(parent) || ts.isFunctionExpression(parent);
+            if (isLambda) {
+                // DETERMINISTIC IR TYPING (INV-0 compliant):
+                // Check if lambda is in a position where expected types provide parameter types.
+                // This replaces the old getContextualType-based inference.
+                const hasExpectedTypeContext = lambdaHasExpectedTypeContext(parent);
+                if (hasExpectedTypeContext) {
+                    // Lambda is in a contextual position - converter will get types from expected type
+                }
+                else {
+                    // No expected type context - emit TSN7405
+                    const paramName = ts.isIdentifier(node.name)
+                        ? node.name.text
+                        : "param";
+                    currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7405", "error", `Parameter '${paramName}' must have an explicit type annotation.`, getNodeLocation(sourceFile, node), "Add a type annotation to this parameter, or use the lambda in a context that provides type inference (e.g., array.sort, array.map)."));
+                }
+            }
+            else {
+                // For non-lambdas (function declarations, methods, constructors, accessors),
+                // always require explicit type annotations
+                const isFunctionLike = ts.isFunctionDeclaration(parent) ||
+                    ts.isMethodDeclaration(parent) ||
+                    ts.isConstructorDeclaration(parent) ||
+                    ts.isGetAccessorDeclaration(parent) ||
+                    ts.isSetAccessorDeclaration(parent);
+                if (isFunctionLike) {
+                    const paramName = ts.isIdentifier(node.name)
+                        ? node.name.text
+                        : "param";
+                    currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7405", "error", `Parameter '${paramName}' must have an explicit type annotation.`, getNodeLocation(sourceFile, node), "Add a type annotation to this parameter."));
+                }
+            }
+        }
+        // TSN7403: Check for object literals without contextual nominal type
+        // Now supports auto-synthesis for eligible object literals (spreads, arrow props)
+        // DETERMINISTIC (INV-0): Uses AST-based contextual type detection, not getContextualType
+        if (ts.isObjectLiteralExpression(node)) {
+            // Check if object literal has a contextual type using deterministic AST analysis
+            const hasContextualType = objectLiteralHasContextualType(node);
+            if (hasContextualType) {
+                // Has contextual type - type checking will validate compatibility during IR conversion
+            }
+            else {
+                // No contextual type - check basic synthesis eligibility
+                // Full eligibility check (including spread type annotations) happens during IR conversion
+                // when we have TypeSystem access.
+                const eligibility = checkBasicSynthesisEligibility(node, program);
+                if (!eligibility.eligible) {
+                    // Not eligible for synthesis - emit diagnostic with specific reason
+                    currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7403", "error", `Object literal cannot be synthesized: ${eligibility.reason}`, getNodeLocation(sourceFile, node), "Use an explicit type annotation, or restructure to use only identifier keys and arrow functions."));
+                }
+                // If eligible, full synthesis check happens during IR conversion
+            }
+        }
+        // Check TypeReferenceNode for utility types and dictionary keys
+        if (ts.isTypeReferenceNode(node)) {
+            const typeName = node.typeName;
+            if (ts.isIdentifier(typeName)) {
+                const name = typeName.text;
+                const hasTypeArgs = node.typeArguments && node.typeArguments.length > 0;
+                // TSN7419: 'never' cannot be used as a generic type argument.
+                //
+                // This is airplane-grade: CLR has no bottom type usable as a generic argument.
+                // Allowing `Foo<never>` would either require inventing a fake CLR type or
+                // emitting invalid C# (void is not a legal generic argument).
+                if (hasTypeArgs &&
+                    node.typeArguments?.some((a) => a.kind === ts.SyntaxKind.NeverKeyword)) {
+                    currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7419", "error", "'never' cannot be used as a generic type argument.", getNodeLocation(sourceFile, node), "Rewrite the type to avoid never. For Result-like types, model explicit variants (Ok<T> | Err<E>) and have helpers return the specific variant type."));
+                }
+                // TSN7413: Record<K, V> where K is not an allowed key type
+                if (name === "Record") {
+                    const typeArgs = node.typeArguments;
+                    const keyTypeNode = typeArgs?.[0];
+                    if (keyTypeNode !== undefined) {
+                        if (!isAllowedKeyType(keyTypeNode)) {
+                            currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7413", "error", "Dictionary key type must be 'string', 'number', or 'symbol'. Other key types are not supported.", getNodeLocation(sourceFile, keyTypeNode), "Use Record<string, V>, Record<number, V>, or Record<symbol, V>."));
+                        }
+                    }
+                }
+            }
+        }
+        // TSN7413: Check for unsupported index signature key types
+        // string, number, and symbol are allowed (matches TypeScript's PropertyKey constraint)
+        if (ts.isIndexSignatureDeclaration(node)) {
+            const keyParam = node.parameters[0];
+            if (keyParam?.type && !isAllowedKeyType(keyParam.type)) {
+                currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7413", "error", "Index signature key type must be 'string', 'number', or 'symbol'. Other key types are not supported.", getNodeLocation(sourceFile, keyParam.type), "Use { [key: string]: V }, { [key: number]: V }, or { [key: symbol]: V }."));
+            }
+        }
+        // TSN7406 retired:
+        // Mapped types are handled by type conversion + specialization.
+        // TSN7407 retired:
+        // Conditional types are handled by utility expansion and type conversion.
+        // TSN7408 retired:
+        // Mixed variadic tuples are now lowered to array types in the converter.
+        // TSN7409 retired:
+        // infer clauses are handled by conditional/type evaluator paths.
+        // TSN7410 retired:
+        // Intersection types are lowered by the type emitter.
+        // TSN7416 retired:
+        // new Array() without explicit type argument is lowered by the emitter.
+        // TSN7417 retired:
+        // Empty arrays are inferred/erased deterministically by array conversion rules.
+        // TSN7432:
+        // Generic function values are supported for deterministic declaration/alias
+        // forms that can be lowered to C# generic method declarations:
+        // - direct generic function value declarations (`const` + never-reassigned `let`)
+        // - direct generic function declarations (`function f<T>(...) { ... }`)
+        // - deterministic alias declarations that point at supported symbols
+        //   (`const` aliases + never-reassigned `let` aliases).
+        // Non-deterministic or non-transpilable value-level usages remain hard errors.
+        if (isGenericFunctionValueNode(node)) {
+            const symbol = getSupportedGenericFunctionValueSymbol(node, program.checker, writtenSymbols);
+            const isSupported = symbol !== undefined &&
+                supportedGenericFunctionValueSymbols.has(symbol);
+            if (!isSupported) {
+                currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7432", "error", "Generic function values are only supported in deterministic declaration/alias forms that can lower to C# generic methods.", getNodeLocation(sourceFile, node), "Use `const f = <T>(...) => ...`, `let f = <T>(...) => ...` with no reassignments, or deterministic aliases like `const g = f`."));
+            }
+        }
+        if (isGenericFunctionDeclarationNode(node)) {
+            const symbol = getSupportedGenericFunctionDeclarationSymbol(node, program.checker);
+            const isSupported = symbol !== undefined &&
+                supportedGenericFunctionValueSymbols.has(symbol);
+            if (!isSupported) {
+                currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7432", "error", "Generic function declarations are only supported when their symbol remains deterministic in value positions and lowers to a C# generic method.", getNodeLocation(sourceFile, node), "Use a direct generic call (e.g., `f<T>(...)`) or deterministic const/never-reassigned let aliases."));
+            }
+        }
+        if (ts.isIdentifier(node)) {
+            const symbol = getReferencedIdentifierSymbol(program.checker, node);
+            if (symbol &&
+                supportedGenericFunctionValueSymbols.has(symbol) &&
+                !isAllowedGenericFunctionValueIdentifierUse(node, program.checker)) {
+                const name = node.text;
+                currentCollector = addDiagnostic(currentCollector, createDiagnostic("TSN7432", "error", `Generic function value '${name}' is only supported in direct call or monomorphic callable-context position where lowering is deterministic.`, getNodeLocation(sourceFile, node), "Call the function directly (e.g., `name<T>(...)`), or use it where a concrete callable type is contextually known (e.g., function argument typed as `(x: number) => number`)."));
+            }
+        }
+        // TSN7430: Arrow function escape hatch validation
+        // Non-simple arrows must have explicit type annotations
+        if (ts.isArrowFunction(node)) {
+            currentCollector = validateArrowEscapeHatch(node, sourceFile, currentCollector);
+        }
+        // Continue visiting children
+        ts.forEachChild(node, (child) => {
+            currentCollector = visitor(child, currentCollector);
+        });
+        return currentCollector;
+    };
+    return visitor(sourceFile, collector);
+};
+//# sourceMappingURL=static-safety-rules.js.map

package/dist/validation/static-safety-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-safety-rules.js","sourceRoot":"","sources":["../../src/validation/static-safety-rules.ts"],"names":[],"mappings":"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"}

package/dist/validation/static-safety.d.ts

@@ -3,6 +3,7 @@
  *
  * Detects patterns that violate static typing requirements:
  * - TSN7401: 'any' type usage
+ * - TSN7402: 'unknown' type usage outside erased overload stubs
  * - TSN7403: Object literal without contextual nominal type
  * - TSN7405: Untyped function/arrow/lambda parameter
  * - TSN7406: Mapped types not supported (retired)
@@ -18,12 +19,8 @@
  * Note: We intentionally do NOT validate JS built-in usage (arr.map, str.length)
  * or dictionary dot-access patterns. These will fail naturally in C# if used
  * incorrectly, which is an acceptable failure mode.
+ *
+ * Facade: re-exports from sub-modules.
  */
-import * as ts from "typescript";
-import { TsonicProgram } from "../program.js";
-import { DiagnosticsCollector } from "../types/diagnostic.js";
-/**
- * Validate a source file for static safety violations.
- */
-export declare const validateStaticSafety: (sourceFile: ts.SourceFile, program: TsonicProgram, collector: DiagnosticsCollector) => DiagnosticsCollector;
+export { validateStaticSafety } from "./static-safety-rules.js";
 //# sourceMappingURL=static-safety.d.ts.map

package/dist/validation/static-safety.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"static-safety.d.ts","sourceRoot":"","sources":["../../src/validation/static-safety.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EACL,oBAAoB,EAGrB,MAAM,wBAAwB,CAAC;AAsehC;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,YAAY,EAAE,CAAC,UAAU,EACzB,SAAS,aAAa,EACtB,WAAW,oBAAoB,KAC9B,oBAkUF,CAAC"}
+{"version":3,"file":"static-safety.d.ts","sourceRoot":"","sources":["../../src/validation/static-safety.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC"}