biome-plugin-suitescript 0.0.0-stage → 0.1.1

package/dist/lib/biome-modules.js

@@ -0,0 +1,94 @@
+import { pairs, parseDefine } from "./define.js";
+const unquote = (text) => text.replace(/^['"]|['"]$/g, "");
+function moduleItems(moduleNode) {
+    return (moduleNode
+        .children()
+        .find((c) => c.kind === "JS_MODULE_ITEM_LIST")
+        ?.children() ?? []);
+}
+/** Dependencies declared by a node: a define() call or an `import` statement. */
+export function dependencies(node) {
+    if (node.kind === "JS_CALL_EXPRESSION") {
+        const def = parseDefine(node);
+        return def ? pairs(def) : [];
+    }
+    if (node.kind !== "JS_IMPORT")
+        return [];
+    const clause = node.children()[0];
+    const source = clause?.children().find((c) => c.kind === "JS_MODULE_SOURCE");
+    if (!clause || !source)
+        return [];
+    const isBinding = clause.kind === "JS_IMPORT_DEFAULT_CLAUSE" ||
+        clause.kind === "JS_IMPORT_NAMESPACE_CLAUSE";
+    const param = isBinding
+        ? clause
+            .children()[0]
+            ?.children()
+            .find((c) => c.kind === "JS_IDENTIFIER_BINDING")
+        : undefined;
+    return [{ name: source.text.slice(1, -1), nameNode: source, param }];
+}
+/** Whether an ES module imports at least one `N/` module (so it is SuiteScript). */
+export function importsNetSuite(moduleNode) {
+    return moduleItems(moduleNode).some((item) => dependencies(item).some((d) => d.name === "N" || d.name?.startsWith("N/")));
+}
+function memberName(member) {
+    const name = member.children()[0]?.text;
+    return name === undefined ? undefined : unquote(name);
+}
+/** Property names of an object literal; `opaque` when a spread hides some. */
+export function objectNames(object) {
+    const members = object.children()[0]?.children() ?? [];
+    const names = [];
+    let opaque = false;
+    for (const m of members) {
+        if (m.kind === "JS_SPREAD") {
+            opaque = true;
+        }
+        else {
+            const name = memberName(m);
+            if (name)
+                names.push(name);
+        }
+    }
+    return { names, opaque };
+}
+/** Names exported by an ES module: `export const x`, `export function x`, `export { a as b }`. */
+export function esExportNames(moduleNode) {
+    const names = [];
+    for (const item of moduleItems(moduleNode)) {
+        if (item.kind !== "JS_EXPORT")
+            continue;
+        const clause = item.children().find((c) => c.kind !== "JS_DECORATOR_LIST");
+        if (!clause)
+            continue;
+        if (clause.kind === "JS_FUNCTION_DECLARATION") {
+            const id = clause
+                .children()
+                .find((c) => c.kind === "JS_IDENTIFIER_BINDING");
+            if (id)
+                names.push(id.text);
+        }
+        else if (clause.kind === "JS_VARIABLE_DECLARATION_CLAUSE") {
+            const declarators = clause.children()[0]?.children()[0]?.children() ?? [];
+            for (const d of declarators) {
+                const id = d.children().find((c) => c.kind === "JS_IDENTIFIER_BINDING");
+                if (id)
+                    names.push(id.text);
+            }
+        }
+        else if (clause.kind === "JS_EXPORT_NAMED_CLAUSE") {
+            for (const specifier of clause.children()[0]?.children() ?? []) {
+                const exported = specifier
+                    .children()
+                    .find((c) => c.kind === "JS_LITERAL_EXPORT_NAME");
+                const name = exported
+                    ? unquote(exported.text)
+                    : specifier.children()[0]?.text;
+                if (name)
+                    names.push(name);
+            }
+        }
+    }
+    return names;
+}

package/dist/lib/define.js

@@ -0,0 +1,72 @@
+const FUNCTION_KINDS = [
+    "JS_FUNCTION_EXPRESSION",
+    "JS_ARROW_FUNCTION_EXPRESSION",
+];
+/** Strips the quotes from a string literal expression node. */
+export function stringValue(node) {
+    if (node?.kind !== "JS_STRING_LITERAL_EXPRESSION")
+        return undefined;
+    return node.text.slice(1, -1);
+}
+/**
+ * Parses an AMD `define([...], function (...) {})` call.
+ *
+ * Returns undefined unless `call` is `define(...)` with a dependency array
+ * followed by a function callback (the optional leading module id is allowed).
+ */
+export function parseDefine(call) {
+    if (call.callee?.text !== "define")
+        return undefined;
+    const args = call.arguments?.children()[0]?.children() ?? [];
+    if (args.length < 2 || args.length > 3)
+        return undefined;
+    const deps = args[args.length - 2];
+    const callback = args[args.length - 1];
+    if (!deps || !callback)
+        return undefined;
+    if (deps.kind !== "JS_ARRAY_EXPRESSION")
+        return undefined;
+    if (!FUNCTION_KINDS.includes(callback.kind))
+        return undefined;
+    const elements = deps.children()[0]?.children() ?? [];
+    const callbackChildren = callback.children();
+    let params = [];
+    const parameters = callbackChildren.find((c) => c.kind === "JS_PARAMETERS");
+    if (parameters) {
+        params = (parameters.children()[0]?.children() ?? []).map((p) => p.kind === "JS_FORMAL_PARAMETER"
+            ? p.children().find((c) => c.kind === "JS_IDENTIFIER_BINDING")
+            : undefined);
+    }
+    else if (callback.kind === "JS_ARROW_FUNCTION_EXPRESSION") {
+        // `x => ...` has a bare identifier binding instead of a parameter list.
+        const single = callbackChildren.find((c) => c.kind === "JS_IDENTIFIER_BINDING");
+        if (single)
+            params = [single];
+    }
+    const body = callbackChildren.find((c) => c.kind === "JS_FUNCTION_BODY" ||
+        (c.kind.endsWith("_EXPRESSION") && c !== parameters));
+    return {
+        body,
+        call,
+        callback,
+        deps,
+        elements,
+        id: args.length === 3 ? args[0] : undefined,
+        params,
+    };
+}
+/** Pairs each dependency string with its callback parameter, by position. */
+export function pairs(def) {
+    const length = Math.max(def.elements.length, def.params.length);
+    const out = [];
+    for (let i = 0; i < length; i++) {
+        const element = def.elements[i];
+        const isString = element?.kind === "JS_STRING_LITERAL_EXPRESSION";
+        out.push({
+            name: stringValue(element),
+            nameNode: isString ? element : undefined,
+            param: def.params[i],
+        });
+    }
+    return out;
+}

package/dist/lib/entry-points.js

@@ -0,0 +1,67 @@
+import { objectNames } from "./biome-modules.js";
+function unwrap(node) {
+    let current = node;
+    while (current?.kind === "JS_PARENTHESIZED_EXPRESSION")
+        current = current.children()[0];
+    return current;
+}
+/**
+ * Names returned by a define() callback, or undefined when they cannot be
+ * determined statically (spreads, calls, conditionals).
+ */
+export function amdReturnedNames(def) {
+    if (!def.body)
+        return undefined;
+    let statements = [];
+    let returned;
+    if (def.body.kind === "JS_FUNCTION_BODY") {
+        statements =
+            def.body
+                .children()
+                .find((c) => c.kind === "JS_STATEMENT_LIST")
+                ?.children() ?? [];
+        returned = unwrap(statements.find((s) => s.kind === "JS_RETURN_STATEMENT")?.children()[0]);
+    }
+    else {
+        returned = unwrap(def.body);
+    }
+    if (returned?.kind === "JS_OBJECT_EXPRESSION") {
+        const { names, opaque } = objectNames(returned);
+        return opaque ? undefined : names;
+    }
+    if (returned?.kind !== "JS_IDENTIFIER_EXPRESSION")
+        return returned ? undefined : [];
+    // `const o = {...}; o.pageInit = ...; return o;`
+    const variable = returned.text;
+    const names = [];
+    for (const s of statements) {
+        if (s.kind === "JS_VARIABLE_STATEMENT") {
+            const declarators = s.children()[0]?.children()[0]?.children() ?? [];
+            for (const d of declarators) {
+                const id = d.children().find((c) => c.kind === "JS_IDENTIFIER_BINDING");
+                const initializer = d
+                    .children()
+                    .find((c) => c.kind === "JS_INITIALIZER_CLAUSE");
+                const init = unwrap(initializer?.children()[0]);
+                if (id?.text === variable && init?.kind === "JS_OBJECT_EXPRESSION") {
+                    const { names: found, opaque } = objectNames(init);
+                    if (opaque)
+                        return undefined;
+                    names.push(...found);
+                }
+            }
+        }
+        else if (s.kind === "JS_EXPRESSION_STATEMENT") {
+            const assign = s.children()[0];
+            const target = assign?.kind === "JS_ASSIGNMENT_EXPRESSION"
+                ? assign.children()[0]
+                : undefined;
+            if (target?.kind === "JS_STATIC_MEMBER_ASSIGNMENT") {
+                const [object, property] = target.children();
+                if (object?.text === variable && property)
+                    names.push(property.text);
+            }
+        }
+    }
+    return names;
+}

package/dist/lib/inference.js

@@ -0,0 +1,92 @@
+// Pure logic shared by the Biome rules and the CLI. No imports from Biome or Node.
+import { SCRIPT_TYPES } from "./script-types.js";
+export const ALL_ENTRY_POINTS = new Set(SCRIPT_TYPES.flatMap((t) => t.entryPoints));
+// Names that commonly appear in ordinary library modules. A module that only
+// returns these is not treated as a script, so libraries are never flagged.
+export const GENERIC_ENTRY_POINTS = new Set([
+    "get",
+    "post",
+    "put",
+    "delete",
+    "map",
+    "reduce",
+    "run",
+    "render",
+]);
+export function typeByName(name) {
+    return SCRIPT_TYPES.find((t) => t.name.toLowerCase() === name.toLowerCase());
+}
+/** Extra requirements on top of "returns at least one entry point of the type". */
+function missingRequired(type, names) {
+    if (type.name === "MapReduceScript") {
+        const missing = [];
+        if (!names.includes("getInputData"))
+            missing.push("getInputData");
+        if (!names.includes("map") && !names.includes("reduce"))
+            missing.push("map or reduce");
+        return missing;
+    }
+    return [];
+}
+/**
+ * Infers the script type from the entry points a module returns.
+ *
+ * Returns undefined for libraries (nothing distinctive returned). Otherwise
+ * `types` are the script types that could own every known entry point; empty
+ * `types` means the entry points are mixed.
+ */
+export function inferScriptType(returnedNames) {
+    const known = [...new Set(returnedNames)].filter((n) => ALL_ENTRY_POINTS.has(n));
+    if (!known.some((n) => !GENERIC_ENTRY_POINTS.has(n)))
+        return undefined;
+    const types = SCRIPT_TYPES.filter((t) => known.every((n) => t.entryPoints.includes(n)));
+    return { known, types };
+}
+/** Problems with an inferred script type, as messages. Empty when valid. */
+export function inferredProblems(returnedNames) {
+    const inferred = inferScriptType(returnedNames);
+    if (!inferred)
+        return [];
+    if (inferred.types.length === 0) {
+        return [
+            `Entry points ${inferred.known.join(", ")} do not belong to a single script type.`,
+        ];
+    }
+    const names = [...new Set(returnedNames)];
+    const failures = inferred.types.map((type) => ({
+        missing: missingRequired(type, names),
+        type,
+    }));
+    if (failures.some((f) => f.missing.length === 0))
+        return [];
+    const first = failures[0];
+    return first
+        ? [
+            `${first.type.name} requires entry point ${first.missing.join(" and ")}.`,
+        ]
+        : [];
+}
+/** Problems with a script type declared by `@NScriptType`, given what is returned. */
+export function declaredProblems(typeName, returnedNames) {
+    const type = typeByName(typeName);
+    if (!type || type.entryPoints.length === 0)
+        return [];
+    const names = [...new Set(returnedNames)];
+    const foreign = names.filter((n) => ALL_ENTRY_POINTS.has(n) &&
+        !type.entryPoints.includes(n) &&
+        !GENERIC_ENTRY_POINTS.has(n));
+    const problems = [];
+    if (foreign.length) {
+        problems.push(`@NScriptType ${type.name} does not support returned entry point${foreign.length > 1 ? "s" : ""} ${foreign.join(", ")}.`);
+    }
+    if (!names.some((n) => type.entryPoints.includes(n))) {
+        if (!foreign.length)
+            problems.push(`Return at least one valid ${type.name} entry point.`);
+    }
+    else {
+        const missing = missingRequired(type, names);
+        if (missing.length)
+            problems.push(`${type.name} requires entry point ${missing.join(" and ")}.`);
+    }
+    return problems;
+}

package/dist/lib/log.js

@@ -0,0 +1,43 @@
+import { dependencies } from "./biome-modules.js";
+const LOG_MEMBERS = ["debug", "audit", "error", "emergency"];
+/** Name the N/log module is bound to (define() or import), else `log`. */
+function logIdentifier(call) {
+    for (const ancestor of call.ancestors()) {
+        const scopes = ancestor.kind === "JS_MODULE"
+            ? (ancestor
+                .children()
+                .find((c) => c.kind === "JS_MODULE_ITEM_LIST")
+                ?.children() ?? [])
+            : [ancestor];
+        for (const scope of scopes) {
+            const found = dependencies(scope).find((d) => d.name === "N/log" && d.param);
+            if (found?.param)
+                return found.param.text;
+        }
+    }
+    return "log";
+}
+/** Matches `log.<debug|audit|error|emergency>(...)` calls that pass arguments. */
+export function logCall(call) {
+    const callee = call.callee;
+    if (callee?.kind !== "JS_STATIC_MEMBER_EXPRESSION")
+        return undefined;
+    const [object, member] = callee.children();
+    if (!object || !member || !LOG_MEMBERS.includes(member.text))
+        return undefined;
+    if (object.text !== logIdentifier(call))
+        return undefined;
+    const args = call.arguments?.children()[0]?.children() ?? [];
+    const firstArg = args[0];
+    if (!firstArg)
+        return undefined;
+    return { args, firstArg, prop: member.text };
+}
+/** Whether an object literal argument defines `key`. */
+export function hasProperty(objectNode, key) {
+    const members = objectNode.children()[0]?.children() ?? [];
+    return members.some((m) => {
+        const name = m.children()[0]?.text;
+        return name === key || name === `"${key}"` || name === `'${key}'`;
+    });
+}

package/dist/lib/modules.js

@@ -0,0 +1,61 @@
+// Valid SuiteScript 2.x modules and their conventional identifiers.
+// Generated by scripts/sync-modules.ts from @hitc/netsuite-types.
+export const MODULES = {
+    "N/action": "action",
+    "N/auth": "auth",
+    "N/cache": "cache",
+    "N/certificateControl": "certificateControl",
+    "N/commerce/recordView": "recordView",
+    "N/compress": "compress",
+    "N/config": "config",
+    "N/crypto": "crypto",
+    "N/crypto/certificate": "certificate",
+    "N/crypto/random": "random",
+    "N/currency": "currency",
+    "N/currentRecord": "currentRecord",
+    "N/dataset": "dataset",
+    "N/datasetLink": "datasetLink",
+    "N/documentCapture": "documentCapture",
+    "N/email": "email",
+    "N/encode": "encode",
+    "N/error": "error",
+    "N/file": "file",
+    "N/format": "format",
+    "N/format/i18n": "i18n",
+    "N/http": "http",
+    "N/https": "https",
+    "N/https/clientCertificate": "clientCertificate",
+    "N/keyControl": "keyControl",
+    "N/llm": "llm",
+    "N/log": "log",
+    "N/machineTranslation": "machineTranslation",
+    "N/manufacturing/productionCharges": "productionCharges",
+    "N/pgp": "pgp",
+    "N/piremoval": "piremoval",
+    "N/plugin": "plugin",
+    "N/portlet": "portlet",
+    "N/query": "query",
+    "N/record": "record",
+    "N/recordContext": "recordContext",
+    "N/redirect": "redirect",
+    "N/render": "render",
+    "N/runtime": "runtime",
+    "N/scriptTypes/restlet": "restlet",
+    "N/search": "search",
+    "N/sftp": "sftp",
+    "N/sso": "sso",
+    "N/suiteAppInfo": "suiteAppInfo",
+    "N/task": "task",
+    "N/task/accounting/recognition": "recognition",
+    "N/transaction": "transaction",
+    "N/translation": "translation",
+    "N/types": "types",
+    "N/ui/dialog": "dialog",
+    "N/ui/message": "message",
+    "N/ui/serverWidget": "serverWidget",
+    "N/url": "url",
+    "N/util": "util",
+    "N/workbook": "workbook",
+    "N/workflow": "workflow",
+    "N/xml": "xml",
+};

package/dist/lib/script-types.js

@@ -0,0 +1,105 @@
+export const SCRIPT_TYPES = [
+    {
+        entryPoints: [
+            "getRequiredConfigurationFields",
+            "downloadPreviousDayBankStatementFile",
+        ],
+        name: "BankConnectivityPlugin",
+    },
+    {
+        entryPoints: [
+            "afterInstall",
+            "afterUpdate",
+            "beforeInstall",
+            "beforeUninstall",
+            "beforeUpdate",
+        ],
+        name: "BundleInstallationScript",
+    },
+    {
+        entryPoints: [
+            "fieldChanged",
+            "lineInit",
+            "pageInit",
+            "postSourcing",
+            "saveRecord",
+            "sublistChanged",
+            "validateDelete",
+            "validateField",
+            "validateInsert",
+            "validateLine",
+            "localizationContextEnter",
+            "localizationContextExit",
+        ],
+        name: "ClientScript",
+    },
+    {
+        entryPoints: ["customizeGlImpact"],
+        name: "CustomGLPlugin",
+    },
+    {
+        entryPoints: ["createDataset"],
+        name: "DatasetBuilderPlugin",
+    },
+    {
+        entryPoints: [
+            "getConfigurationIFrameUrl",
+            "getAccounts",
+            "getTransactionData",
+        ],
+        name: "FiConnectivityPlugin",
+    },
+    {
+        entryPoints: [
+            "parseData",
+            "getStandardTransactionCodes",
+            "getExpenseCodes",
+            "getConfigurationPageUrl",
+        ],
+        name: "FiParserPlugin",
+    },
+    {
+        entryPoints: ["getInputData", "map", "reduce", "summarize"],
+        name: "MapReduceScript",
+    },
+    {
+        entryPoints: ["each"],
+        name: "MassUpdateScript",
+    },
+    {
+        entryPoints: [],
+        name: "PluginTypeImpl",
+    },
+    {
+        entryPoints: ["render"],
+        name: "Portlet",
+    },
+    {
+        entryPoints: ["delete", "get", "post", "put"],
+        name: "Restlet",
+    },
+    {
+        entryPoints: ["execute"],
+        name: "ScheduledScript",
+    },
+    {
+        entryPoints: ["run"],
+        name: "SDFInstallationScript",
+    },
+    {
+        entryPoints: ["onRequest"],
+        name: "Suitelet",
+    },
+    {
+        entryPoints: ["afterSubmit", "beforeLoad", "beforeSubmit"],
+        name: "UserEventScript",
+    },
+    {
+        entryPoints: ["createWorkbook"],
+        name: "WorkbookBbuilderPlugin",
+    },
+    {
+        entryPoints: ["onAction"],
+        name: "WorkflowActionScript",
+    },
+];

package/dist/rules/entryPoints.js

@@ -0,0 +1,33 @@
+import { ast, defineRule, registerDiagnostic, } from "@biomejs/runtime/plugin";
+import { esExportNames, importsNetSuite } from "../lib/biome-modules.js";
+import { parseDefine } from "../lib/define.js";
+import { amdReturnedNames } from "../lib/entry-points.js";
+import { inferredProblems } from "../lib/inference.js";
+// Infers the script type from the entry points a module returns and checks
+// they belong to one type and that its required entry points are present.
+// Modules that return no distinctive entry point (libraries) are ignored.
+export const entryPoints = defineRule({
+    query: ast("JS_CALL_EXPRESSION", "JS_MODULE"),
+    run(node) {
+        let names;
+        let reportOn = node;
+        if (node.kind === "JS_CALL_EXPRESSION") {
+            const def = parseDefine(node);
+            if (!def)
+                return;
+            names = amdReturnedNames(def);
+        }
+        else {
+            if (!importsNetSuite(node))
+                return;
+            names = esExportNames(node);
+            reportOn =
+                node.children().find((c) => c.kind === "JS_MODULE_ITEM_LIST") ?? node;
+        }
+        if (!names)
+            return;
+        for (const message of inferredProblems(names)) {
+            registerDiagnostic(reportOn, "error", message);
+        }
+    },
+});

package/dist/rules/logRequireDetails.js

@@ -0,0 +1,16 @@
+import { ast, defineRule, registerDiagnostic } from "@biomejs/runtime/plugin";
+import { hasProperty, logCall } from "../lib/log.js";
+export const logRequireDetails = defineRule({
+    query: ast("JS_CALL_EXPRESSION"),
+    run(node) {
+        const info = logCall(node);
+        if (!info)
+            return;
+        const { firstArg, args, prop } = info;
+        const isObject = firstArg.kind === "JS_OBJECT_EXPRESSION";
+        if ((isObject && !hasProperty(firstArg, "details")) ||
+            (!isObject && args.length === 1)) {
+            registerDiagnostic(node, "warning", `Log details are required with 'log.${prop}'.`);
+        }
+    },
+});

package/dist/rules/logRequireTitle.js

@@ -0,0 +1,15 @@
+import { ast, defineRule, registerDiagnostic } from "@biomejs/runtime/plugin";
+import { hasProperty, logCall } from "../lib/log.js";
+export const logRequireTitle = defineRule({
+    query: ast("JS_CALL_EXPRESSION"),
+    run(node) {
+        const info = logCall(node);
+        if (!info)
+            return;
+        const { firstArg, prop } = info;
+        if (firstArg.kind === "JS_OBJECT_EXPRESSION" &&
+            !hasProperty(firstArg, "title")) {
+            registerDiagnostic(node, "warning", `A log title is required with 'log.${prop}'.`);
+        }
+    },
+});

package/dist/rules/moduleVars.js

@@ -0,0 +1,16 @@
+import { ast, defineRule, registerDiagnostic } from "@biomejs/runtime/plugin";
+import { dependencies } from "../lib/biome-modules.js";
+import { MODULES } from "../lib/modules.js";
+// Conventional identifiers: N/record -> record, N/ui/serverWidget -> serverWidget.
+// Use `biome-plugin-suitescript generate module-vars` for a custom mapping.
+export const moduleVars = defineRule({
+    query: ast("JS_CALL_EXPRESSION", "JS_IMPORT"),
+    run(node) {
+        for (const { name, param } of dependencies(node)) {
+            const expected = name && Object.hasOwn(MODULES, name) ? MODULES[name] : undefined;
+            if (expected && param && param.text !== expected) {
+                registerDiagnostic(param, "warning", `Identifier for ${name} should be '${expected}'.`);
+            }
+        }
+    },
+});

package/dist/rules/noAmdName.grit

@@ -0,0 +1,9 @@
+engine biome(1.0)
+language js(typescript, jsx)
+
+// Anonymous AMD modules only: NetSuite/bundlers assign the module ID.
+`define($id, $deps, $cb)` as $call where {
+  $id <: JsStringLiteralExpression(),
+  register_diagnostic(span=$id, message="No AMD module name should be provided.", severity="error", fix_kind="safe"),
+  $call => `define($deps, $cb)`
+}

package/dist/rules/noExtraModules.js

@@ -0,0 +1,23 @@
+import { ast, defineRule, registerDiagnostic } from "@biomejs/runtime/plugin";
+import { parseDefine } from "../lib/define.js";
+export const noExtraModules = defineRule({
+    query: ast("JS_CALL_EXPRESSION"),
+    run(node) {
+        const def = parseDefine(node);
+        if (!def)
+            return;
+        const names = def.elements;
+        const params = def.params;
+        if (names.length > params.length) {
+            for (const extra of names.slice(params.length)) {
+                registerDiagnostic(extra, "error", `Excess module name ${extra.text}.`);
+            }
+        }
+        else if (params.length > names.length) {
+            for (const extra of params.slice(names.length)) {
+                if (extra)
+                    registerDiagnostic(extra, "error", `Excess module identifier '${extra.text}'.`);
+            }
+        }
+    },
+});

package/dist/rules/noInvalidModules.js

@@ -0,0 +1,14 @@
+import { ast, defineRule, registerDiagnostic } from "@biomejs/runtime/plugin";
+import { dependencies } from "../lib/biome-modules.js";
+import { MODULES } from "../lib/modules.js";
+// Unknown `N/...` modules are almost always typos; custom modules are fine.
+export const noInvalidModules = defineRule({
+    query: ast("JS_CALL_EXPRESSION", "JS_IMPORT"),
+    run(node) {
+        for (const { nameNode, name } of dependencies(node)) {
+            if (nameNode && name?.startsWith("N/") && !Object.hasOwn(MODULES, name)) {
+                registerDiagnostic(nameNode, "error", `Invalid NetSuite module '${name}'.`);
+            }
+        }
+    },
+});