@ttsc/playground 0.19.2 → 0.20.0

package/src/npm/installPlaygroundDependencies.ts

@@ -1,10 +1,12 @@
 import type { IPlaygroundDependencyInstallOptions } from "../structures/IPlaygroundDependencyInstallOptions";
 import type { IPlaygroundDependencyInstallResult } from "../structures/IPlaygroundDependencyInstallResult";
 import type { IPlaygroundDependencyProgressPhase } from "../structures/IPlaygroundDependencyProgressPhase";
+import type { IPlaygroundInstalledDependency } from "../structures/IPlaygroundInstalledDependency";
 import { BUILT_IN_PLAYGROUND_PACKAGES } from "./BUILT_IN_PLAYGROUND_PACKAGES";
 import {
   DECLARATION_FILE_REGEXP,
   type IQueueItem,
+  type IVersionRequest,
   downloadTarball,
   enqueuePackageDependencies,
   fetchNpmMetadata,
@@ -23,9 +25,11 @@ const DEFAULT_MAX_PACKAGES = 48;
  * extra-libs registry, and the in-page execute sandbox `require`.
  *
  * Transitive dependencies are followed via the resolved `package.json`'s
- * `dependencies` and (non-optional) `peerDependencies` fields. The walk is
- * bounded by `maxPackages` to keep a single keystroke from exhausting the tab's
- * network/memory budget.
+ * required, optional, and peer dependency fields. Passing a prior call's
+ * `resolvedDependencies` validates new edges against the exact mounted graph
+ * and reuses compatible packages without downloading their tarballs again. The
+ * walk is bounded by `maxPackages` to keep a single keystroke from exhausting
+ * the tab's network/memory budget.
  */
 export async function installPlaygroundDependencies(
   packageNames: Iterable<string>,
@@ -40,12 +44,40 @@ export async function installPlaygroundDependencies(
   const ignored = new Set(
     options.ignoredPackages ?? BUILT_IN_PLAYGROUND_PACKAGES,
   );
-  const installed = new Set(options.installedPackages ?? []);
+  const installedNames = new Set(options.installedPackages ?? []);
+  const installedDependencies = new Map<
+    string,
+    IPlaygroundInstalledDependency
+  >();
+  for (const dependency of options.installedDependencies ?? []) {
+    const previous = installedDependencies.get(dependency.name);
+    if (
+      previous !== undefined &&
+      (previous.registryName !== dependency.registryName ||
+        previous.version !== dependency.version)
+    ) {
+      throw new Error(
+        `Conflicting mounted identities for ${dependency.name}: ${previous.registryName}@${previous.version} and ${dependency.registryName}@${dependency.version}.`,
+      );
+    }
+    if (previous !== undefined) {
+      previous.requests.push(
+        ...dependency.requests.map((request) => ({ ...request })),
+      );
+      continue;
+    }
+    installedDependencies.set(dependency.name, {
+      ...dependency,
+      requests: dependency.requests.map((request) => ({ ...request })),
+    });
+  }
   const maxPackages = options.maxPackages ?? DEFAULT_MAX_PACKAGES;
   const queue: IQueueItem[] = [];
-  const queued = new Set<string>();
-  const done = new Set<string>();
+  const queued = new Map<string, IQueueItem>();
+  const done = new Map<string, string>();
+  const metadataByName = new Map<string, Parameters<typeof selectVersion>[0]>();
   const result: IPlaygroundDependencyInstallResult = {
+    resolvedDependencies: [],
     packages: [],
     compilerFiles: {},
     editorLibs: {},
@@ -53,11 +85,77 @@ export async function installPlaygroundDependencies(
   };
 
   const enqueue = (item: IQueueItem): void => {
-    if (ignored.has(item.name) || installed.has(item.name)) return;
-    if (queued.has(item.name) || done.has(item.name)) return;
-    queued.add(item.name);
-    queue.push(item);
-    report("queued", item, `Queued ${item.name}`);
+    const normalized = normalizeRegistryRequest(item);
+    if (ignored.has(normalized.name)) return;
+    const known = queued.get(normalized.name);
+    if (known) {
+      if (known.registryName !== normalized.registryName) {
+        if (normalized.optional) return;
+        const completed = done.get(normalized.name);
+        if (known.optional && (completed === undefined || completed === "")) {
+          known.registryName = normalized.registryName;
+          known.range = normalized.range;
+          known.requester = normalized.requester;
+          known.requests = [toVersionRequest(normalized)];
+          known.optional = false;
+          metadataByName.delete(normalized.name);
+          if (completed === "") {
+            done.delete(normalized.name);
+            queue.push(known);
+          }
+          return;
+        }
+        throw registryIdentityConflict(
+          normalized.name,
+          known.registryName!,
+          normalized,
+        );
+      }
+      known.requests ??= [toVersionRequest(known)];
+      known.requests.push(toVersionRequest(normalized));
+      known.optional = known.requests.every((request) => request.optional);
+      const completed = done.get(normalized.name);
+      const metadata = metadataByName.get(normalized.name);
+      if (completed !== undefined && completed.length !== 0 && metadata) {
+        // A dependency can discover an additional range after this package has
+        // already been installed. Pin the installed version into the combined
+        // solve so a compatible late constraint is accepted, but a range that
+        // rejects the mounted version fails instead of being silently lost.
+        try {
+          selectQueuedVersion(metadata, known, [completed]);
+        } catch (error) {
+          const mounted = installedDependencies.get(normalized.name);
+          if (mounted) throw mountedVersionConflict(mounted, error);
+          throw error;
+        }
+      } else if (completed !== undefined && !known.optional) {
+        // An optional 404 may later be reached through a required edge. Retry
+        // that edge so the required dependency cannot remain silently absent.
+        done.delete(normalized.name);
+        queue.push(known);
+      }
+      return;
+    }
+    const mounted = installedDependencies.get(normalized.name);
+    if (mounted && mounted.registryName !== normalized.registryName) {
+      if (normalized.optional) return;
+      throw registryIdentityConflict(
+        normalized.name,
+        mounted.registryName,
+        normalized,
+      );
+    }
+    if (installedNames.has(normalized.name) && mounted === undefined) return;
+    normalized.requests = [
+      ...(mounted?.requests.map((request) => ({ ...request })) ?? []),
+      toVersionRequest(normalized),
+    ];
+    normalized.optional = normalized.requests.every(
+      (request) => request.optional,
+    );
+    queued.set(normalized.name, normalized);
+    queue.push(normalized);
+    report("queued", normalized, `Queued ${normalized.name}`);
   };
 
   const report = (
@@ -77,7 +175,7 @@ export async function installPlaygroundDependencies(
   };
 
   for (const name of packageNames) {
-    enqueue({ name, range: "latest", optional: false });
+    enqueue({ name, range: "*", optional: false, requester: "source" });
   }
 
   for (let index = 0; index < queue.length; index++) {
@@ -88,29 +186,72 @@ export async function installPlaygroundDependencies(
     }
 
     const item = queue[index]!;
-    if (installed.has(item.name) || done.has(item.name)) continue;
+    if (done.has(item.name)) continue;
     throwIfAborted(options.signal);
 
     report("resolve", item, `Resolving ${item.name}`);
     const metadata = await fetchNpmMetadata(
       fetchImpl,
-      item.name,
+      item.registryName ?? item.name,
       item.optional,
       options.signal,
     );
     throwIfAborted(options.signal);
     if (!metadata) {
-      done.add(item.name);
-      report("skip", item, `Skipped optional ${item.name}`);
+      const mounted = installedDependencies.get(item.name);
+      if (mounted) {
+        // A missing registry entry gives us no way to validate a new optional
+        // range or tag. Preserve the already-published optional requests and
+        // omit the new edge instead of claiming the mounted version satisfies
+        // a constraint we never checked.
+        item.requests = mounted.requests.map((request) => ({ ...request }));
+        item.optional = item.requests.every((request) => request.optional);
+      }
+      done.set(item.name, mounted?.version ?? "");
+      report(
+        mounted ? "done" : "skip",
+        item,
+        mounted
+          ? `Reused mounted ${item.name}@${mounted.version}`
+          : `Skipped optional ${item.name}`,
+        mounted?.version,
+      );
       continue;
     }
 
-    const version = selectVersion(metadata, item.range);
+    metadataByName.set(item.name, metadata);
+    const mounted = installedDependencies.get(item.name);
+    let version: string | null;
+    try {
+      version = selectQueuedVersion(
+        metadata,
+        item,
+        mounted ? [mounted.version] : [],
+      );
+    } catch (error) {
+      if (mounted) throw mountedVersionConflict(mounted, error);
+      throw error;
+    }
+    if (version === null) {
+      done.set(item.name, mounted?.version ?? "");
+      report("skip", item, `Skipped optional ${item.name}`);
+      continue;
+    }
+    if (mounted) {
+      done.set(item.name, mounted.version);
+      report(
+        "done",
+        item,
+        `Reused mounted ${item.name}@${mounted.version}`,
+        mounted.version,
+      );
+      continue;
+    }
     const versionMetadata = metadata.versions[version];
     const tarball = versionMetadata?.dist?.tarball;
     if (!versionMetadata || !tarball) {
       if (item.optional) {
-        done.add(item.name);
+        done.set(item.name, "");
         report("skip", item, `Skipped optional ${item.name}`);
         continue;
       }
@@ -127,37 +268,155 @@ export async function installPlaygroundDependencies(
       ...versionMetadata,
       ...unpacked.packageJson,
     };
-    const mounted = mountPackageFiles(item.name, unpacked.files);
+    const mountedFiles = mountPackageFiles(item.name, unpacked.files);
 
-    Object.assign(result.compilerFiles, mounted.compilerFiles);
-    Object.assign(result.editorLibs, mounted.editorLibs);
-    Object.assign(result.runtimeFiles, mounted.runtimeFiles);
+    Object.assign(result.compilerFiles, mountedFiles.compilerFiles);
+    Object.assign(result.editorLibs, mountedFiles.editorLibs);
+    Object.assign(result.runtimeFiles, mountedFiles.runtimeFiles);
 
-    const declarationCount = Object.keys(mounted.editorLibs).filter((key) =>
-      DECLARATION_FILE_REGEXP.test(key),
+    const declarationCount = Object.keys(mountedFiles.editorLibs).filter(
+      (key) => DECLARATION_FILE_REGEXP.test(key),
     ).length;
     result.packages.push({
       name: item.name,
+      registryName: item.registryName ?? item.name,
       version,
       tarball,
-      fileCount: Object.keys(mounted.compilerFiles).length,
+      fileCount: Object.keys(mountedFiles.compilerFiles).length,
       declarationCount,
     });
 
-    done.add(item.name);
-    installed.add(item.name);
+    done.set(item.name, version);
+    installedNames.add(item.name);
     report("done", item, `Installed ${item.name}@${version}`, version);
 
-    enqueuePackageDependencies(packageJson, enqueue);
+    enqueuePackageDependencies(packageJson, enqueue, item.name);
     if (declarationCount === 0 && !item.name.startsWith("@types/")) {
       enqueue({
         name: toTypesPackageName(item.name),
-        range: "latest",
+        range: "*",
         optional: true,
+        requester: item.name,
       });
     }
   }
 
+  const resolved = new Map(installedDependencies);
+  for (const [name, version] of done) {
+    if (version.length === 0) continue;
+    const item = queued.get(name)!;
+    resolved.set(name, {
+      name,
+      registryName: item.registryName ?? name,
+      version,
+      requests: (item.requests ?? [toVersionRequest(item)]).map((request) => ({
+        ...request,
+      })),
+    });
+  }
+  result.resolvedDependencies = [...resolved.values()].map((dependency) => ({
+    ...dependency,
+    requests: dependency.requests.map((request) => ({ ...request })),
+  }));
   report("done", null, "Dependency install complete");
   return result;
 }
+
+function normalizeRegistryRequest(item: IQueueItem): IQueueItem {
+  if (!item.range.startsWith("npm:"))
+    return { ...item, registryName: item.name };
+  const match = /^npm:((?:@[^/]+\/)?[^@/]+)(?:@(.+))?$/.exec(item.range);
+  if (!match) {
+    throw new Error(
+      `Unsupported npm alias ${JSON.stringify(item.range)} for ${item.name}.`,
+    );
+  }
+  return {
+    ...item,
+    registryName: match[1]!,
+    range: match[2] || "*",
+  };
+}
+
+function toVersionRequest(item: IQueueItem): IVersionRequest {
+  return {
+    optional: item.optional,
+    range: item.range,
+    requester: item.requester,
+  };
+}
+
+function selectQueuedVersion(
+  metadata: Parameters<typeof selectVersion>[0],
+  item: IQueueItem,
+  extraRanges: readonly string[] = [],
+): string | null {
+  const requests = item.requests ?? [toVersionRequest(item)];
+  const required = requests.filter((request) => !request.optional);
+  const optional = requests.filter((request) => request.optional);
+  const accepted = [...required];
+  let selected: string | null = null;
+
+  if (required.length !== 0) {
+    try {
+      selected = selectVersion(metadata, [
+        ...required.map((request) => request.range),
+        ...extraRanges,
+      ]);
+    } catch (error) {
+      throw requestedVersionError(error, required);
+    }
+  }
+
+  for (const request of optional) {
+    try {
+      const candidate = selectVersion(metadata, [
+        ...accepted.map((acceptedRequest) => acceptedRequest.range),
+        request.range,
+        ...extraRanges,
+      ]);
+      accepted.push(request);
+      selected = candidate;
+    } catch {
+      // Optional ranges refine the selected version only when they are
+      // compatible with every required edge and the mounted-version pin.
+    }
+  }
+  item.requests = accepted;
+  item.optional = accepted.every((request) => request.optional);
+  return selected;
+}
+
+function requestedVersionError(
+  error: unknown,
+  requests: readonly IVersionRequest[],
+): Error {
+  const message = error instanceof Error ? error.message : String(error);
+  const requestedBy = requests
+    .map(
+      ({ requester, range }) =>
+        `${requester} requests ${JSON.stringify(range)}`,
+    )
+    .join("; ");
+  return new Error(`${message} Requested by ${requestedBy}.`);
+}
+
+function mountedVersionConflict(
+  mounted: IPlaygroundInstalledDependency,
+  error: unknown,
+): Error {
+  const message = error instanceof Error ? error.message : String(error);
+  return new Error(
+    `Mounted ${mounted.name}@${mounted.version} from ${mounted.registryName} is incompatible with the active dependency graph. ${message}`,
+  );
+}
+
+function registryIdentityConflict(
+  name: string,
+  registryName: string,
+  incoming: IQueueItem,
+): Error {
+  return new Error(
+    `Conflicting registry identities for ${name}: mounted or queued from ${registryName}, but ${incoming.requester} requests ${JSON.stringify(incoming.range)} from ${incoming.registryName}.`,
+  );
+}

package/src/npm/internal/npmRegistry.ts

@@ -1,3 +1,5 @@
+import { maxSatisfying, satisfies, valid, validRange } from "semver";
+
 // Internal npm-registry helpers used by `installPlaygroundDependencies`.
 // Grouped in one file because every helper is privately coupled to the tar
 // + version-resolve + tarball-extract flow; splitting them per the public
@@ -7,6 +9,7 @@ interface IPackageJson {
   name?: string;
   version?: string;
   dependencies?: Record<string, string>;
+  optionalDependencies?: Record<string, string>;
   peerDependencies?: Record<string, string>;
   peerDependenciesMeta?: Record<string, { optional?: boolean }>;
 }
@@ -15,6 +18,7 @@ export interface INpmVersionMetadata {
   name: string;
   version: string;
   dependencies?: Record<string, string>;
+  optionalDependencies?: Record<string, string>;
   peerDependencies?: Record<string, string>;
   peerDependenciesMeta?: Record<string, { optional?: boolean }>;
   dist?: {
@@ -37,6 +41,15 @@ export interface IQueueItem {
   name: string;
   range: string;
   optional: boolean;
+  requester: string;
+  registryName?: string;
+  requests?: IVersionRequest[];
+}
+
+export interface IVersionRequest {
+  optional: boolean;
+  range: string;
+  requester: string;
 }
 
 export type FetchLike = (
@@ -79,19 +92,43 @@ export async function fetchNpmMetadata(
   return (await response.json()) as INpmMetadata;
 }
 
-export function selectVersion(metadata: INpmMetadata, range: string): string {
+export function selectVersion(
+  metadata: INpmMetadata,
+  ranges: readonly string[] | string,
+): string {
   const versions = metadata.versions;
-  if (versions[range]) return range;
-  const tag = metadata["dist-tags"]?.[range];
-  if (tag && versions[tag]) return tag;
-  const normalized = range.replace(/^[~^<>= ]+/, "").trim();
-  if (normalized && versions[normalized]) return normalized;
-  const latest = metadata["dist-tags"]?.latest;
-  if (latest && versions[latest]) return latest;
-  const all = Object.keys(versions).sort(compareVersionDesc);
-  const fallback = all[0];
-  if (!fallback) throw new Error(`No versions found for ${metadata.name}.`);
-  return fallback;
+  const requested = Array.isArray(ranges) ? ranges : [ranges];
+  const semverRanges = requested.filter((range) => validRange(range) !== null);
+  const tags = requested.filter((range) => validRange(range) === null);
+  const taggedVersions = new Set<string>();
+  for (const tag of tags) {
+    const version = metadata["dist-tags"]?.[tag];
+    if (!version || !versions[version]) {
+      throw new Error(
+        `No npm dist-tag ${JSON.stringify(tag)} exists for ${metadata.name}.`,
+      );
+    }
+    taggedVersions.add(version);
+  }
+  if (taggedVersions.size > 1) {
+    throw new Error(
+      `Conflicting npm tags for ${metadata.name}: ${requested.join(", ")}.`,
+    );
+  }
+
+  const candidates = Object.keys(versions).filter(
+    (version) =>
+      valid(version) !== null &&
+      semverRanges.every((range) => satisfies(version, range)) &&
+      (taggedVersions.size === 0 || taggedVersions.has(version)),
+  );
+  const selected = maxSatisfying(candidates, "*");
+  if (selected) return selected;
+  throw new Error(
+    `No version of ${metadata.name} satisfies ${requested
+      .map((range) => JSON.stringify(range))
+      .join(", ")}.`,
+  );
 }
 
 export async function downloadTarball(
@@ -136,7 +173,7 @@ export async function unpackNpmTarball(
       continue;
     }
     if (type === "x") {
-      paxPath = parsePaxPath(decoder.decode(body));
+      paxPath = parsePaxPath(body);
       continue;
     }
     if (type !== "0" && type !== "\0") {
@@ -209,13 +246,21 @@ export function mountPackageFiles(
 export function enqueuePackageDependencies(
   packageJson: {
     dependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
     peerDependencies?: Record<string, string>;
     peerDependenciesMeta?: Record<string, { optional?: boolean }>;
   },
   enqueue: (item: IQueueItem) => void,
+  requester: string,
 ): void {
+  const optionalDependencies = packageJson.optionalDependencies ?? {};
   for (const [name, range] of Object.entries(packageJson.dependencies ?? {})) {
-    if (isRegistryRange(range)) enqueue({ name, range, optional: false });
+    if (!(name in optionalDependencies) && isRegistryRange(range))
+      enqueue({ name, range, optional: false, requester });
+  }
+  for (const [name, range] of Object.entries(optionalDependencies)) {
+    if (isRegistryRange(range))
+      enqueue({ name, range, optional: true, requester });
   }
   for (const [name, range] of Object.entries(
     packageJson.peerDependencies ?? {},
@@ -228,12 +273,26 @@ export function enqueuePackageDependencies(
     // silent skip that leaves the wasm-side compile reporting a generic
     // "Cannot find module" with no breadcrumb back to the dep installer.
     if (!optional && isRegistryRange(range))
-      enqueue({ name, range, optional: false });
+      enqueue({ name, range, optional: false, requester });
   }
 }
 
 function isRegistryRange(range: string): boolean {
-  return !/^(file:|link:|workspace:|portal:|git\+|github:|https?:)/.test(range);
+  const spec = range.trim();
+  // Match npm-package-arg's file classification before its registry fallback:
+  // dot/home/root/drive paths and tar archive names are source specs even
+  // though their characters could also form a URI-safe dist-tag.
+  if (
+    /^(?:\.|~[\\/]|[\\/]|[a-zA-Z]:)/.test(spec) ||
+    /\.(?:tgz|tar\.gz|tar)$/i.test(spec)
+  )
+    return false;
+  if (spec.startsWith("npm:")) return true;
+  if (validRange(spec) !== null) return true;
+  // npm accepts a dist-tag only when it is a non-empty URI-component-safe
+  // token. Git, hosted, URL, and local-path specs all require punctuation that
+  // encodeURIComponent escapes, so they cannot fall through as fake tags.
+  return spec.length > 0 && encodeURIComponent(spec) === spec;
 }
 
 export function toTypesPackageName(packageName: string): string {
@@ -256,19 +315,32 @@ function parseOctal(bytes: Uint8Array): number {
   return text ? Number.parseInt(text, 8) : 0;
 }
 
-function parsePaxPath(text: string): string | null {
-  let rest = text;
-  while (rest.length > 0) {
-    const space = rest.indexOf(" ");
-    if (space < 0) return null;
-    const length = Number(rest.slice(0, space));
-    if (!Number.isFinite(length) || length <= space) return null;
-    const record = rest.slice(space + 1, length - 1);
+function parsePaxPath(bytes: Uint8Array): string | null {
+  const decoder = new TextDecoder();
+  let offset = 0;
+  let path: string | null = null;
+  while (offset < bytes.length) {
+    let space = offset;
+    while (space < bytes.length && bytes[space] !== 0x20) space++;
+    if (space === bytes.length) throw new Error("Invalid PAX header length.");
+    const lengthText = decoder.decode(bytes.subarray(offset, space));
+    if (!/^[1-9][0-9]*$/.test(lengthText))
+      throw new Error("Invalid PAX header length.");
+    const length = Number(lengthText);
+    const end = offset + length;
+    if (
+      !Number.isSafeInteger(length) ||
+      length <= space - offset + 1 ||
+      end > bytes.length ||
+      bytes[end - 1] !== 0x0a
+    )
+      throw new Error("Invalid PAX header record.");
+    const record = decoder.decode(bytes.subarray(space + 1, end - 1));
     const eq = record.indexOf("=");
-    if (eq > 0 && record.slice(0, eq) === "path") return record.slice(eq + 1);
-    rest = rest.slice(length);
+    if (eq > 0 && record.slice(0, eq) === "path") path = record.slice(eq + 1);
+    offset = end;
   }
-  return null;
+  return path;
 }
 
 function stripTarRoot(path: string): string {
@@ -279,14 +351,3 @@ function stripTarRoot(path: string): string {
   const slash = normalized.indexOf("/");
   return slash < 0 ? normalized : normalized.slice(slash + 1);
 }
-
-function compareVersionDesc(a: string, b: string): number {
-  const pa = a.split(/[.-]/).map((part) => Number.parseInt(part, 10));
-  const pb = b.split(/[.-]/).map((part) => Number.parseInt(part, 10));
-  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-    const av = Number.isFinite(pa[i]) ? pa[i]! : 0;
-    const bv = Number.isFinite(pb[i]) ? pb[i]! : 0;
-    if (av !== bv) return bv - av;
-  }
-  return b.localeCompare(a);
-}

package/src/npm/packageNameFromSpecifier.ts

@@ -1,15 +1,22 @@
 const BUILTIN_MODULES = new Set([
   "assert",
+  "async_hooks",
   "buffer",
   "child_process",
+  "cluster",
   "console",
   "constants",
   "crypto",
+  "dgram",
+  "diagnostics_channel",
   "dns",
+  "domain",
   "events",
   "fs",
   "http",
+  "http2",
   "https",
+  "inspector",
   "module",
   "net",
   "os",
@@ -19,14 +26,19 @@ const BUILTIN_MODULES = new Set([
   "punycode",
   "querystring",
   "readline",
+  "repl",
   "stream",
   "string_decoder",
+  "sys",
   "timers",
   "tls",
+  "trace_events",
   "tty",
   "url",
   "util",
+  "v8",
   "vm",
+  "wasi",
   "worker_threads",
   "zlib",
 ]);
@@ -38,6 +50,10 @@ const BUILTIN_MODULES = new Set([
  * built-in modules — the caller doesn't install those from npm.
  */
 export function packageNameFromSpecifier(specifier: string): string | null {
+  const nodePrefixed = specifier.startsWith("node:");
+  const bare = nodePrefixed ? specifier.slice("node:".length) : specifier;
+  const first = bare.split("/")[0];
+  if (first && BUILTIN_MODULES.has(first)) return null;
   if (
     specifier.startsWith("#") ||
     specifier.startsWith(".") ||
@@ -45,9 +61,6 @@ export function packageNameFromSpecifier(specifier: string): string | null {
     /^[a-z][a-z0-9+.-]*:/i.test(specifier)
   )
     return null;
-  const bare = specifier.startsWith("node:") ? specifier.slice(5) : specifier;
-  const first = bare.split("/")[0];
-  if (first && BUILTIN_MODULES.has(first)) return null;
   if (bare.startsWith("@")) {
     const firstSlash = bare.indexOf("/");
     if (firstSlash < 0) return null;