ts-ag 1.1.26 → 1.2.0

package/dist/scripts/check-llrt-worker.mjs

@@ -0,0 +1,642 @@
+#!/usr/bin/env node
+import { t as isDirectExecution } from "../utils-DLairfc9.mjs";
+import { builtinModules } from "node:module";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { parseArgs, styleText } from "node:util";
+import { parse } from "acorn";
+import { ancestor } from "acorn-walk";
+import { glob } from "glob";
+import { unique } from "radash";
+const JS_EXTENSIONS = [
+	".mjs",
+	".js",
+	".cjs"
+];
+const EXPORT_CONDITION_KEYS = new Set([
+	"browser",
+	"default",
+	"deno",
+	"development",
+	"import",
+	"node",
+	"production",
+	"require",
+	"worker"
+]);
+const LABEL = styleText("cyan", "[check-llrt-worker]");
+//#endregion
+//#region src/scripts/check-llrt/options.ts
+function toArray(value) {
+	if (value === void 0) return [];
+	return Array.isArray(value) ? value : [value];
+}
+async function parseCliOptions() {
+	const { values } = parseArgs({
+		args: process.argv.slice(2),
+		options: {
+			"api-url": { type: "string" },
+			filter: {
+				type: "string",
+				short: "f",
+				multiple: true
+			},
+			package: {
+				type: "string",
+				short: "p",
+				multiple: true
+			},
+			verbose: {
+				type: "boolean",
+				short: "v"
+			},
+			workspace: {
+				type: "string",
+				short: "w",
+				multiple: true
+			}
+		}
+	});
+	const apiUrl = values["api-url"] ?? process.env.LLRT_API_URL ?? "https://raw.githubusercontent.com/awslabs/llrt/main/API.md";
+	const { packages, availablePackages } = await selectPackages(toArray(values.package).map((packagePath) => path.resolve(packagePath)), toArray(values.workspace).map((workspacePath) => path.resolve(workspacePath)), toArray(values.filter));
+	return {
+		apiUrl,
+		packages,
+		availablePackages,
+		verbose: values.verbose === true,
+		llrtApiMarkdown: parseLlrtApi(await fetchLlrtApiMarkdown(apiUrl))
+	};
+}
+async function fetchLlrtApiMarkdown(apiUrl) {
+	const apiResponse = await fetch(apiUrl);
+	if (!apiResponse.ok) throw new Error(`Failed to fetch LLRT API docs from ${apiUrl}: ${apiResponse.status}`);
+	return apiResponse.text();
+}
+function parseLlrtApi(markdown) {
+	const support = /* @__PURE__ */ new Map();
+	let currentModule;
+	for (const line of markdown.split("\n")) {
+		const trimmed = line.trim();
+		const moduleMatch = /^##\s+([a-z_]+(?:\/[a-z_-]+)*)$/.exec(trimmed);
+		if (moduleMatch) {
+			currentModule = moduleMatch[1];
+			support.set(currentModule, /* @__PURE__ */ new Set());
+			continue;
+		}
+		if (trimmed.startsWith("## ")) currentModule = void 0;
+		if (!currentModule) continue;
+		const memberMatch = /^\[([^\]]+)\]\(/.exec(trimmed);
+		if (memberMatch) support.get(currentModule)?.add(memberMatch[1]);
+	}
+	return support;
+}
+async function selectPackages(packagePaths, workspacePaths, filters) {
+	const explicitPaths = packagePaths.length > 0 ? packagePaths : workspacePaths.length === 0 ? [process.cwd()] : [];
+	const packageMap = /* @__PURE__ */ new Map();
+	for (const packagePath of explicitPaths) {
+		const pkg = await readPackage(packagePath);
+		packageMap.set(pkg.dir, pkg);
+	}
+	for (const workspacePath of workspacePaths) for (const pkg of await discoverWorkspacePackages(workspacePath)) packageMap.set(pkg.dir, pkg);
+	const availablePackages = [...packageMap.values()].sort((a, b) => a.dir.localeCompare(b.dir));
+	if (filters.length === 0) return {
+		packages: availablePackages,
+		availablePackages
+	};
+	return {
+		packages: availablePackages.filter((pkg) => filters.some((filter) => matchesPackageFilter(pkg, filter))),
+		availablePackages
+	};
+}
+async function readPackage(packagePath) {
+	const resolvedPath = path.resolve(packagePath);
+	const packageJsonPath = resolvedPath.endsWith("package.json") ? resolvedPath : path.join(resolvedPath, "package.json");
+	const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+	const dir = path.dirname(packageJsonPath);
+	return {
+		name: packageJson.name ?? path.basename(dir),
+		dir,
+		packageJsonPath,
+		packageJson
+	};
+}
+async function discoverWorkspacePackages(workspacePath) {
+	const root = path.resolve(workspacePath);
+	const patterns = await readWorkspacePackagePatterns(root);
+	if (patterns.length === 0) {
+		const rootPackageJson = path.join(root, "package.json");
+		return existsSync(rootPackageJson) ? [await readPackage(rootPackageJson)] : [];
+	}
+	const includePatterns = patterns.filter((pattern) => !pattern.startsWith("!"));
+	const excludePatterns = patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => path.posix.join(pattern.slice(1).replace(/\\/g, "/"), "package.json"));
+	const packageJsonPaths = await glob(includePatterns.map((pattern) => path.posix.join(pattern.replace(/\\/g, "/"), "package.json")), {
+		absolute: true,
+		cwd: root,
+		ignore: ["**/node_modules/**", ...excludePatterns],
+		nodir: true
+	});
+	return (await Promise.all(packageJsonPaths.map((packageJsonPath) => readPackage(packageJsonPath)))).sort((a, b) => a.dir.localeCompare(b.dir));
+}
+async function readWorkspacePackagePatterns(root) {
+	const rootPackageJsonPath = path.join(root, "package.json");
+	const pnpmWorkspacePath = path.join(root, "pnpm-workspace.yaml");
+	const patterns = [];
+	if (existsSync(rootPackageJsonPath)) {
+		const rootPackage = JSON.parse(await readFile(rootPackageJsonPath, "utf8"));
+		if (Array.isArray(rootPackage.workspaces)) patterns.push(...rootPackage.workspaces);
+		else if (Array.isArray(rootPackage.workspaces?.packages)) patterns.push(...rootPackage.workspaces.packages);
+	}
+	if (existsSync(pnpmWorkspacePath)) patterns.push(...parsePnpmWorkspacePackages(await readFile(pnpmWorkspacePath, "utf8")));
+	return unique(patterns);
+}
+function parsePnpmWorkspacePackages(yaml) {
+	const patterns = [];
+	let inPackages = false;
+	let packageIndent = -1;
+	for (const line of yaml.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (trimmed.length === 0 || trimmed.startsWith("#")) continue;
+		if (trimmed === "packages:") {
+			inPackages = true;
+			packageIndent = line.search(/\S/);
+			continue;
+		}
+		if (!inPackages) continue;
+		if (line.search(/\S/) <= packageIndent) break;
+		const match = /^-\s+(.+)$/.exec(trimmed);
+		if (match) patterns.push(stripYamlString(match[1]));
+	}
+	return patterns;
+}
+function stripYamlString(value) {
+	const trimmed = value.trim();
+	if (trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith("\"") && trimmed.endsWith("\"")) return trimmed.slice(1, -1);
+	return trimmed;
+}
+function matchesPackageFilter(pkg, filter, root = process.cwd()) {
+	const normalizedFilter = filter.replace(/\\/g, "/");
+	const relativeDir = path.relative(root, pkg.dir).replace(/\\/g, "/");
+	if (/[*?[\]{}]/.test(normalizedFilter)) {
+		const regex = globPatternToRegex(normalizedFilter);
+		return regex.test(pkg.name) || regex.test(relativeDir);
+	}
+	return pkg.name === normalizedFilter || relativeDir === normalizedFilter || relativeDir.startsWith(`${normalizedFilter}/`);
+}
+function globPatternToRegex(pattern) {
+	let source = "";
+	for (let index = 0; index < pattern.length; index++) {
+		const char = pattern[index];
+		const nextChar = pattern[index + 1];
+		if (char === "*" && nextChar === "*") {
+			source += ".*";
+			index++;
+			continue;
+		}
+		if (char === "*") {
+			source += "[^/]*";
+			continue;
+		}
+		if (char === "?") {
+			source += "[^/]";
+			continue;
+		}
+		source += char.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+	}
+	return new RegExp(`^${source}$`);
+}
+//#endregion
+//#region src/scripts/check-llrt/index.ts
+const nodeBuiltinModules = new Set(builtinModules.filter((moduleName) => !moduleName.startsWith("_")).map((moduleName) => moduleName.replace(/^node:/, "")));
+const formatPath = (filePath) => styleText("dim", path.relative(process.cwd(), filePath));
+const logInfo = (message) => console.log(`${LABEL} ${message}`);
+const logWarn = (message) => console.warn(`${LABEL} ${styleText("yellow", message)}`);
+const logError = (message) => console.error(`${LABEL} ${styleText("red", message)}`);
+async function checkLlrtWorker(options) {
+	const llrtSupport = options.llrtApiMarkdown;
+	const { packages, availablePackages } = options;
+	const packageByName = new Map(availablePackages.map((pkg) => [pkg.name, pkg]));
+	const diagnostics = [];
+	const usageByModule = /* @__PURE__ */ new Map();
+	const visitedFiles = /* @__PURE__ */ new Set();
+	const targets = packages.flatMap((pkg) => {
+		const packageTargets = extractWorkerExportTargets(pkg);
+		for (const target of packageTargets) if (!existsSync(target.filePath)) diagnostics.push({
+			packageName: pkg.name,
+			filePath: target.filePath,
+			message: `worker export \`${target.exportKey}\` points to missing built file`
+		});
+		return packageTargets;
+	});
+	const visitFile = async (pkg, filePath) => {
+		const normalizedPath = path.resolve(filePath);
+		const visitKey = `${pkg.name}:${normalizedPath}`;
+		if (visitedFiles.has(visitKey)) return;
+		visitedFiles.add(visitKey);
+		const sourceFile = parseJs(await readFile(normalizedPath, "utf8"));
+		const bindings = /* @__PURE__ */ new Map();
+		const pendingImports = [];
+		collectImports(sourceFile, bindings, pendingImports, diagnostics, pkg.name, normalizedPath, llrtSupport);
+		walkValueReferences(sourceFile, bindings, diagnostics, usageByModule, pkg.name, normalizedPath, llrtSupport);
+		for (const specifier of pendingImports) {
+			const resolved = resolveImportSpecifier(specifier, normalizedPath, packageByName, diagnostics, pkg.name);
+			if (resolved) await visitFile(resolved.pkg, resolved.filePath);
+		}
+	};
+	for (const target of targets) {
+		const pkg = packageByName.get(target.packageName);
+		if (pkg && existsSync(target.filePath)) await visitFile(pkg, target.filePath);
+	}
+	if (options.verbose && packages.length === 0) logWarn("No packages were selected");
+	return {
+		checkedApiUrl: options.apiUrl,
+		diagnostics,
+		packages,
+		targets,
+		usageByModule,
+		visitedFiles: [...visitedFiles].map((key) => key.slice(key.indexOf(":") + 1)).sort()
+	};
+}
+function extractWorkerExportTargets(pkg) {
+	const exportsValue = pkg.packageJson.exports;
+	if (exportsValue === void 0) return [];
+	const entries = isExportMap(exportsValue) ? Object.entries(exportsValue) : [[".", exportsValue]];
+	const targets = [];
+	for (const [exportKey, exportValue] of entries) for (const target of collectWorkerTargets(exportValue, false)) if (isJsFile(target)) targets.push({
+		packageName: pkg.name,
+		exportKey,
+		filePath: path.resolve(pkg.dir, target)
+	});
+	return uniqueTargets(targets);
+}
+function collectWorkerTargets(value, inWorkerBranch) {
+	if (typeof value === "string") return inWorkerBranch ? [value] : [];
+	if (Array.isArray(value)) return value.flatMap((item) => collectWorkerTargets(item, inWorkerBranch));
+	if (!isPlainObject(value)) return [];
+	const targets = [];
+	for (const [key, child] of Object.entries(value)) {
+		if (key === "types") continue;
+		if (key === "worker") targets.push(...collectWorkerTargets(child, true));
+		else if (inWorkerBranch) targets.push(...collectWorkerTargets(child, true));
+	}
+	return targets;
+}
+function resolveImportSpecifier(specifier, containingFile, packageByName, diagnostics, packageName) {
+	if (isRelativeSpecifier(specifier)) {
+		const filePath = resolveJsPath(path.resolve(path.dirname(containingFile), specifier));
+		return filePath ? {
+			pkg: findPackageForFile(filePath, packageByName) ?? packageByName.get(packageName),
+			filePath
+		} : void 0;
+	}
+	const parsedPackageSpecifier = parsePackageSpecifier(specifier);
+	const pkg = packageByName.get(parsedPackageSpecifier.name);
+	if (!pkg) return void 0;
+	const exportKey = parsedPackageSpecifier.subpath ? `.${parsedPackageSpecifier.subpath}` : ".";
+	const target = resolvePackageExportTarget(pkg.packageJson.exports, exportKey, [
+		"worker",
+		"import",
+		"default"
+	]);
+	if (!target) return void 0;
+	const filePath = path.resolve(pkg.dir, target);
+	if (!existsSync(filePath)) {
+		diagnostics.push({
+			packageName,
+			filePath,
+			message: `workspace import \`${specifier}\` resolves to missing built file`
+		});
+		return;
+	}
+	return {
+		pkg,
+		filePath
+	};
+}
+function resolvePackageExportTarget(exportsValue, exportKey, conditions) {
+	if (exportsValue === void 0) return void 0;
+	if (!isExportMap(exportsValue)) return exportKey === "." ? selectConditionalTarget(exportsValue, conditions) : void 0;
+	return selectConditionalTarget(exportsValue[exportKey], conditions);
+}
+function selectConditionalTarget(value, conditions) {
+	if (typeof value === "string") return isJsFile(value) ? value : void 0;
+	if (Array.isArray(value)) {
+		for (const item of value) {
+			const target = selectConditionalTarget(item, conditions);
+			if (target) return target;
+		}
+		return;
+	}
+	if (!isPlainObject(value)) return void 0;
+	for (const condition of conditions) {
+		const target = selectConditionalTarget(value[condition], conditions);
+		if (target) return target;
+	}
+}
+function collectImports(sourceFile, bindings, pendingImports, diagnostics, packageName, filePath, support) {
+	ancestor(sourceFile, {
+		ImportDeclaration(node) {
+			const specifier = getLiteralString(node.source);
+			if (!specifier) return;
+			if (isBuiltinModule(specifier)) collectBuiltinImportSpecifiers(node.specifiers ?? [], specifier, bindings, diagnostics, packageName, filePath, support);
+			else pendingImports.push(specifier);
+		},
+		ExportNamedDeclaration(node) {
+			const specifier = getLiteralString(node.source);
+			if (!specifier) return;
+			if (isBuiltinModule(specifier)) {
+				validateBuiltinModule(specifier, diagnostics, packageName, filePath, support);
+				for (const spec of node.specifiers ?? []) {
+					const importedName = getExportedImportName(spec);
+					if (importedName) validatePath(packageName, filePath, normalizeBuiltinName(specifier), importedName, support, diagnostics, "imports");
+				}
+			} else pendingImports.push(specifier);
+		},
+		ExportAllDeclaration(node) {
+			const specifier = getLiteralString(node.source);
+			if (!specifier) return;
+			if (isBuiltinModule(specifier)) {
+				const moduleName = normalizeBuiltinName(specifier);
+				validateBuiltinModule(specifier, diagnostics, packageName, filePath, support);
+				diagnostics.push({
+					packageName,
+					filePath,
+					message: `re-exports entire builtin module \`${moduleName}\`, which cannot be validated against LLRT's partial API surface`
+				});
+			} else pendingImports.push(specifier);
+		},
+		ImportExpression(node) {
+			const specifier = getLiteralString(node.source);
+			if (!specifier) return;
+			if (isBuiltinModule(specifier)) validateBuiltinModule(specifier, diagnostics, packageName, filePath, support);
+			else pendingImports.push(specifier);
+		},
+		CallExpression(node, ancestors) {
+			if (!isRequireCall(node)) return;
+			const parent = ancestors.at(-2);
+			if (parent?.type === "VariableDeclarator" && parent.init === node) return;
+			const specifier = getLiteralString(node.arguments?.[0]);
+			if (!specifier) return;
+			if (isBuiltinModule(specifier)) validateBuiltinModule(specifier, diagnostics, packageName, filePath, support);
+			else pendingImports.push(specifier);
+		},
+		VariableDeclarator(node) {
+			if (!isRequireCall(node.init)) return;
+			const specifier = getLiteralString(node.init.arguments?.[0]);
+			if (!specifier) return;
+			if (isBuiltinModule(specifier)) collectRequireBinding(node.id, specifier, bindings, diagnostics, packageName, filePath, support);
+		}
+	});
+}
+function collectRequireBinding(pattern, specifier, bindings, diagnostics, packageName, filePath, support) {
+	const moduleName = normalizeBuiltinName(specifier);
+	if (!validateBuiltinModule(specifier, diagnostics, packageName, filePath, support)) return;
+	if (pattern.type === "Identifier") {
+		bindings.set(pattern.name, {
+			moduleName,
+			importedPath: "",
+			kind: "default"
+		});
+		return;
+	}
+	if (pattern.type !== "ObjectPattern") return;
+	for (const property of pattern.properties ?? []) {
+		if (property.type !== "Property") continue;
+		const importedName = getPropertyName(property.key);
+		const localName = property.value?.type === "Identifier" ? property.value.name : void 0;
+		if (!importedName || !localName) continue;
+		validatePath(packageName, filePath, moduleName, importedName, support, diagnostics, "imports");
+		bindings.set(localName, {
+			moduleName,
+			importedPath: importedName,
+			kind: "named"
+		});
+	}
+}
+function collectBuiltinImportSpecifiers(specifiers, specifier, bindings, diagnostics, packageName, filePath, support) {
+	const moduleName = normalizeBuiltinName(specifier);
+	const supportedMembers = support.get(moduleName);
+	if (!validateBuiltinModule(specifier, diagnostics, packageName, filePath, support)) return;
+	for (const spec of specifiers) {
+		if (spec.type === "ImportDefaultSpecifier" || spec.type === "ImportNamespaceSpecifier") {
+			bindings.set(spec.local.name, {
+				moduleName,
+				importedPath: "",
+				kind: spec.type === "ImportDefaultSpecifier" ? "default" : "namespace"
+			});
+			continue;
+		}
+		if (spec.type !== "ImportSpecifier") continue;
+		const importedName = getModuleExportName(spec.imported);
+		const localName = spec.local?.name;
+		if (!importedName || !localName) continue;
+		validatePath(packageName, filePath, moduleName, importedName, support, diagnostics, "imports");
+		bindings.set(localName, {
+			moduleName,
+			importedPath: importedName,
+			kind: "named"
+		});
+	}
+	if (specifiers.length === 0 && supportedMembers) return;
+}
+function walkValueReferences(sourceFile, bindings, diagnostics, usageByModule, packageName, filePath, support) {
+	const visitedIdentifiers = /* @__PURE__ */ new Set();
+	ancestor(sourceFile, { Identifier(node, ancestors) {
+		const binding = bindings.get(node.name);
+		if (!binding || !isValueReference(node, ancestors) || visitedIdentifiers.has(node.start)) return;
+		visitedIdentifiers.add(node.start);
+		const usedPath = getUsedPath(node, ancestors, binding);
+		if (!usedPath) {
+			diagnostics.push({
+				packageName,
+				filePath,
+				message: `uses \`${node.name}\` from \`${binding.moduleName}\` in a way this check cannot validate statically`
+			});
+			return;
+		}
+		const usedPaths = usageByModule.get(binding.moduleName) ?? /* @__PURE__ */ new Set();
+		usedPaths.add(usedPath);
+		usageByModule.set(binding.moduleName, usedPaths);
+		validatePath(packageName, filePath, binding.moduleName, usedPath, support, diagnostics, "uses");
+	} });
+}
+function getUsedPath(identifier, ancestors, binding) {
+	let current = identifier;
+	const segments = [];
+	for (let index = ancestors.length - 2; index >= 0; index--) {
+		const parent = ancestors[index];
+		if (parent.type !== "MemberExpression" || parent.object !== current || parent.computed) break;
+		const propertyName = getPropertyName(parent.property);
+		if (!propertyName) break;
+		segments.push(propertyName);
+		current = parent;
+	}
+	return (binding.importedPath ? [binding.importedPath, ...segments] : segments).join(".") || void 0;
+}
+function validateBuiltinModule(specifier, diagnostics, packageName, filePath, support) {
+	const moduleName = normalizeBuiltinName(specifier);
+	if (support.has(moduleName)) return true;
+	diagnostics.push({
+		packageName,
+		filePath,
+		message: `imports unsupported builtin module \`${moduleName}\``
+	});
+	return false;
+}
+function validatePath(packageName, filePath, moduleName, usedPath, support, diagnostics, verb) {
+	const supportedMembers = support.get(moduleName) ?? /* @__PURE__ */ new Set();
+	let prefix = usedPath;
+	while (prefix) {
+		if (supportedMembers.has(prefix)) return;
+		const dotIndex = prefix.lastIndexOf(".");
+		if (dotIndex === -1) break;
+		prefix = prefix.slice(0, dotIndex);
+	}
+	diagnostics.push({
+		packageName,
+		filePath,
+		message: `${verb} \`${usedPath}\` from \`${moduleName}\`, but LLRT API.md does not list it`
+	});
+}
+function parseJs(sourceText) {
+	try {
+		return parse(sourceText, {
+			allowHashBang: true,
+			ecmaVersion: "latest",
+			sourceType: "module"
+		});
+	} catch {
+		return parse(sourceText, {
+			allowHashBang: true,
+			ecmaVersion: "latest",
+			sourceType: "script"
+		});
+	}
+}
+function isValueReference(identifier, ancestors) {
+	const parent = ancestors.at(-2);
+	if (!parent) return false;
+	if (parent.type === "ImportSpecifier" || parent.type === "ImportDefaultSpecifier" || parent.type === "ImportNamespaceSpecifier") return false;
+	if (parent.type === "ExportSpecifier") return false;
+	if (parent.type === "MemberExpression" && parent.property === identifier && !parent.computed) return false;
+	if (parent.type === "Property" && parent.key === identifier && !parent.computed) return false;
+	if (parent.type === "VariableDeclarator" && parent.id === identifier) return false;
+	if (parent.type === "FunctionDeclaration" && parent.id === identifier) return false;
+	if (parent.type === "FunctionExpression" && parent.id === identifier) return false;
+	if (parent.type === "ClassDeclaration" && parent.id === identifier) return false;
+	if (parent.type === "ClassExpression" && parent.id === identifier) return false;
+	if (parent.type === "LabeledStatement") return false;
+	return true;
+}
+function resolveJsPath(basePath) {
+	if (existsSync(basePath) && isJsFile(basePath)) return basePath;
+	for (const extension of JS_EXTENSIONS) {
+		const filePath = `${basePath}${extension}`;
+		if (existsSync(filePath)) return filePath;
+	}
+	for (const extension of JS_EXTENSIONS) {
+		const filePath = path.join(basePath, `index${extension}`);
+		if (existsSync(filePath)) return filePath;
+	}
+}
+function findPackageForFile(filePath, packageByName) {
+	return [...packageByName.values()].sort((a, b) => b.dir.length - a.dir.length).find((pkg) => isWithinDir(filePath, pkg.dir));
+}
+function parsePackageSpecifier(specifier) {
+	if (specifier.startsWith("@")) {
+		const [scope, name, ...subpath] = specifier.split("/");
+		return {
+			name: `${scope}/${name}`,
+			subpath: subpath.length > 0 ? `/${subpath.join("/")}` : ""
+		};
+	}
+	const [name, ...subpath] = specifier.split("/");
+	return {
+		name,
+		subpath: subpath.length > 0 ? `/${subpath.join("/")}` : ""
+	};
+}
+function getExportedImportName(specifier) {
+	return getModuleExportName(specifier.local ?? specifier.exported);
+}
+function getModuleExportName(node) {
+	if (!node) return void 0;
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+}
+function getPropertyName(node) {
+	if (!node) return void 0;
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "PrivateIdentifier") return void 0;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+}
+function getLiteralString(node) {
+	if (!node) return void 0;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+}
+function isRequireCall(node) {
+	return node?.callee?.type === "Identifier" && node.callee.name === "require";
+}
+function isBuiltinModule(specifier) {
+	return nodeBuiltinModules.has(normalizeBuiltinName(specifier));
+}
+function normalizeBuiltinName(specifier) {
+	return specifier.replace(/^node:/, "");
+}
+function isRelativeSpecifier(specifier) {
+	return specifier.startsWith("./") || specifier.startsWith("../") || specifier === "." || specifier === "..";
+}
+function isJsFile(filePath) {
+	return JS_EXTENSIONS.some((extension) => filePath.endsWith(extension));
+}
+function isExportMap(value) {
+	if (!isPlainObject(value)) return false;
+	const keys = Object.keys(value);
+	return keys.some((key) => key.startsWith(".")) || !keys.some((key) => EXPORT_CONDITION_KEYS.has(key));
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isWithinDir(filePath, dirPath) {
+	const relPath = path.relative(dirPath, filePath);
+	return relPath === "" || !relPath.startsWith("..") && !path.isAbsolute(relPath);
+}
+function uniqueTargets(targets) {
+	const seen = /* @__PURE__ */ new Set();
+	return targets.filter((target) => {
+		const key = `${target.packageName}:${target.exportKey}:${target.filePath}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+function compareDiagnostics(left, right) {
+	const packageCompare = left.packageName.localeCompare(right.packageName);
+	if (packageCompare !== 0) return packageCompare;
+	const pathCompare = left.filePath.localeCompare(right.filePath);
+	if (pathCompare !== 0) return pathCompare;
+	return left.message.localeCompare(right.message);
+}
+async function main() {
+	const options = await parseCliOptions();
+	const result = await checkLlrtWorker(options);
+	if (result.diagnostics.length > 0) {
+		logError("LLRT worker compatibility check failed.");
+		console.error(`${LABEL} Checked: ${result.checkedApiUrl}`);
+		for (const diagnostic of result.diagnostics.sort(compareDiagnostics)) console.error(`${LABEL} - ${diagnostic.packageName} ${formatPath(diagnostic.filePath)}: ${diagnostic.message}`);
+		process.exit(1);
+	}
+	logInfo(`${styleText("green", "passed")} LLRT worker compatibility check`);
+	logInfo(`Checked: ${result.checkedApiUrl}`);
+	logInfo(`Checked ${result.targets.length} worker export(s) in ${result.packages.length} package(s)`);
+	logInfo(`${result.packages.map((p) => p.name).join(", ")}`);
+	if (options.verbose) logInfo(`Visited ${result.visitedFiles.length} file(s)`);
+	for (const [moduleName, usedPaths] of [...result.usageByModule.entries()].sort((a, b) => a[0].localeCompare(b[0]))) logInfo(`${moduleName}: ${[...usedPaths].sort().join(", ")}`);
+}
+if (isDirectExecution(import.meta.url)) main().catch((error) => {
+	logError("Unhandled error in check-llrt-worker script");
+	console.error(error);
+	process.exit(1);
+});
+//#endregion
+export { checkLlrtWorker, extractWorkerExportTargets, main };

package/dist/scripts/ts-alias.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
-import { t as colorText } from "../cli-CoTTeqrl.mjs";
-import { dirname, isAbsolute, relative, resolve } from "path";
-import { parseArgs } from "util";
+import { t as colorText } from "../cli-DAs6KeZ2.mjs";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { parseArgs } from "node:util";
 import console from "console";
 import { existsSync } from "fs";
 import { fileURLToPath } from "url";
@@ -267,5 +267,3 @@ if (isDirectExecution()) main().catch((error) => {
 });
 //#endregion
 export { createRegenerator, discoverAliasTargets, isAliasOutputFile, isWithinDir, main, processAliasTarget, resolveOutDir, resolveTsConfigPath, syncWatcherPaths, unique };
-
-//# sourceMappingURL=ts-alias.mjs.map