plgg-bundle 0.0.2 → 0.0.5

package/bin/hook.d.mts

@@ -0,0 +1,20 @@
+// Hand-written types for the JS loader hook (the hook must
+// stay a plain `.mjs` — it runs as Node's ESM resolver
+// before any type-stripping is active — so it carries no
+// inferable types). Declared here so a `.ts` spec can drive
+// `resolve` type-safely under `allowJs: false`.
+
+/** A resolved module, as returned to Node's loader chain. */
+export type Resolved = {
+  url: string;
+  shortCircuit?: boolean;
+};
+
+export const resolve: (
+  specifier: string,
+  context: { parentURL?: string | undefined },
+  nextResolve: (
+    specifier: string,
+    context: { parentURL?: string | undefined },
+  ) => Promise<Resolved>,
+) => Promise<Resolved>;

package/bin/hook.mjs

@@ -19,7 +19,7 @@
 //
 // Everything else (typescript, node:*) falls through to
 // Node's default resolution.
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { dirname, join } from "node:path";
 
@@ -27,13 +27,22 @@ const here = dirname(fileURLToPath(import.meta.url));
 const srcRoot = join(here, "..", "src");
 const prefix = "plgg-bundle/";
 
+// Resolve to a FILE, never a directory: a bare-directory
+// self-alias (e.g. `plgg-bundle/foo`) must land on its
+// `index.ts`, not the directory itself — Node would `read`
+// the directory and throw EISDIR. So the raw `base` matches
+// only when it is a real file; a directory falls through to
+// `base/index.ts`.
+const isFile = (c) =>
+  existsSync(c) && statSync(c).isFile();
+
 const pick = (base) => {
   const candidates = [
     base,
     `${base}.ts`,
     join(base, "index.ts"),
   ];
-  return candidates.find((c) => existsSync(c));
+  return candidates.find(isFile);
 };
 
 // The `?v=<n>` dev version carried by an importer URL, or

package/bin/plgg-bundle.mjs

@@ -7,6 +7,15 @@
 import { register } from "node:module";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
+import { relocateOutOfNodeModules } from "./relocate.mjs";
+
+// Node 24 refuses to strip types from `.ts` under `node_modules`. When this
+// tool is installed from the registry, relocate a copy OUTSIDE `node_modules`
+// and re-exec there; a no-op on a monorepo `file:` link.
+relocateOutOfNodeModules(
+  import.meta.url,
+  "plgg-bundle.mjs",
+);
 
 register("./hook.mjs", import.meta.url);
 

package/bin/relocate.mjs

@@ -0,0 +1,117 @@
+// Shared launcher preamble for the run-from-source plgg CLIs.
+//
+// These tools run their `src/**/*.ts` entry directly and rely on Node stripping
+// types on load. Node refuses to strip types for `.ts` files under
+// `node_modules`, so a registry-installed tool cannot run in place. This helper
+// copies the package to a per-(version, install-location) dir OUTSIDE
+// `node_modules` (with the tool's own deps reachable via a `node_modules`
+// symlink) and re-execs the copy there. On a monorepo `file:` link the package
+// realpath is already outside `node_modules`, so it is a no-op.
+//
+// Plain `.mjs`, Node built-ins only — it runs at process entry, before any
+// resolver hook is registered.
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import {
+  dirname,
+  join,
+  sep,
+} from "node:path";
+import { fileURLToPath } from "node:url";
+
+const isUnderNodeModules = (p) =>
+  p.split(sep).includes("node_modules");
+
+// Relocate the calling launcher's package out of node_modules and re-exec, or
+// return (no-op) when already outside it. Exits the process on re-exec.
+export const relocateOutOfNodeModules = (
+  launcherUrl,
+  launcherBinName,
+) => {
+  const binDir = dirname(
+    fileURLToPath(launcherUrl),
+  );
+  const pkgRoot = realpathSync(
+    join(binDir, ".."),
+  );
+  if (!isUnderNodeModules(pkgRoot)) {
+    return;
+  }
+
+  const pkg = JSON.parse(
+    readFileSync(
+      join(pkgRoot, "package.json"),
+      "utf8",
+    ),
+  );
+  // The node_modules that CONTAINS this package holds its deps (npm hoists
+  // there). Key the relocation dir by that location too — two installs of the
+  // same version from different trees (e.g. a publish smoke's scratch install
+  // and a real consumer) must NOT share a copy, or one inherits the other's
+  // stale (possibly deleted) deps symlink.
+  const depsNodeModules = dirname(pkgRoot);
+  const tag = createHash("sha1")
+    .update(depsNodeModules)
+    .digest("hex")
+    .slice(0, 12);
+  const dest = join(
+    tmpdir(),
+    `plgg-relocate-${pkg.name}-${pkg.version}-${tag}`,
+  );
+  const ready = join(
+    dest,
+    ".plgg-relocate-ready",
+  );
+  const link = join(dest, "node_modules");
+
+  if (!existsSync(ready)) {
+    rmSync(dest, {
+      recursive: true,
+      force: true,
+    });
+    mkdirSync(dest, { recursive: true });
+    for (const dir of ["src", "bin"]) {
+      const from = join(pkgRoot, dir);
+      if (existsSync(from)) {
+        cpSync(from, join(dest, dir), {
+          recursive: true,
+        });
+      }
+    }
+    cpSync(
+      join(pkgRoot, "package.json"),
+      join(dest, "package.json"),
+    );
+    writeFileSync(ready, depsNodeModules + "\n");
+  }
+  // (Re)create the deps symlink every run so it always points at the CURRENT
+  // node_modules: a cached copy from a prior run may hold a symlink to a tree
+  // that has since been removed (a publish smoke's scratch install) or moved.
+  rmSync(link, { force: true });
+  try {
+    symlinkSync(depsNodeModules, link, "dir");
+  } catch {
+    // A concurrent run created it first; its target is identical.
+  }
+
+  const child = spawnSync(
+    process.execPath,
+    [
+      join(dest, "bin", launcherBinName),
+      ...process.argv.slice(2),
+    ],
+    { stdio: "inherit" },
+  );
+  process.exit(child.status ?? 1);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plgg-bundle",
-  "version": "0.0.2",
+  "version": "0.0.5",
   "description": "In-house minimal library bundler for the plgg monorepo (ESM+CJS dual output, per-file .d.ts tree), zero new dependencies — reuses the project's own TypeScript, no native binding.",
   "type": "module",
   "files": [
@@ -23,6 +23,6 @@
   },
   "devDependencies": {
     "@types/node": "^25.6.0",
-    "plgg-test": "^0.0.2"
+    "plgg-test": "^0.0.5"
   }
 }

package/src/Dev/fixtures/aliasDir/index.ts

@@ -0,0 +1,6 @@
+// Fixture: a directory whose only module is `index.ts`, so a
+// bare-directory self-alias (`plgg-bundle/Dev/fixtures/aliasDir`)
+// has an index to resolve to. Exercised by
+// ../../usecase/selfAliasResolve.spec.ts to guard the loader
+// hook against resolving to the directory itself (EISDIR).
+export const marker = "aliasDir/index.ts";

package/src/Dev/node/devServer.ts

@@ -2,11 +2,11 @@ import {
   resolve,
   isAbsolute,
   join,
-} from "node:path";
-import { existsSync } from "node:fs";
-import { pathToFileURL } from "node:url";
-import { register } from "node:module";
-import { type Server } from "node:http";
+} from "plgg-bundle/vendors/nodePath";
+import { existsSync } from "plgg-bundle/vendors/nodeFs";
+import { pathToFileURL } from "plgg-bundle/vendors/nodeUrl";
+import { register } from "plgg-bundle/vendors/nodeProc";
+import { type Server } from "plgg-bundle/vendors/nodeHttp";
 import { type Fetch } from "plgg-bundle/Dev/model/Fetch";
 import { type ModuleGraph } from "plgg-bundle/Dev/model/ModuleGraph";
 import {

package/src/Dev/node/httpAdapter.ts

@@ -3,7 +3,7 @@ import {
   type IncomingMessage,
   type ServerResponse,
   type Server,
-} from "node:http";
+} from "plgg-bundle/vendors/nodeHttp";
 import { type Fetch } from "plgg-bundle/Dev/model/Fetch";
 
 // The node:http ⇄ Web-standard bridge for the dev server.

package/src/Dev/node/scanGraph.ts

@@ -2,12 +2,12 @@ import {
   readdirSync,
   readFileSync,
   statSync,
-} from "node:fs";
+} from "plgg-bundle/vendors/nodeFs";
 import {
   resolve,
   dirname,
   join,
-} from "node:path";
+} from "plgg-bundle/vendors/nodePath";
 import { parseImports } from "plgg-bundle/Dev/usecase/parseImports";
 import { buildGraph } from "plgg-bundle/Dev/usecase/buildGraph";
 import { type ModuleGraph } from "plgg-bundle/Dev/model/ModuleGraph";

package/src/Dev/node/watch.ts

@@ -1,4 +1,4 @@
-import { watch, type FSWatcher } from "node:fs";
+import { watch, type FSWatcher } from "plgg-bundle/vendors/nodeFs";
 
 // The fs.watch seam: a debounced, recursive watcher over
 // several source roots. One save can emit multiple events,

package/src/Dev/usecase/selfAliasResolve.spec.ts

@@ -0,0 +1,68 @@
+import {
+  test,
+  check,
+  all,
+  toBe,
+} from "plgg-test";
+import {
+  resolve,
+  type Resolved,
+} from "../../../bin/hook.mjs";
+
+// The loader hook's `resolve` rewrites `plgg-bundle/<sub>`
+// self-alias specifiers to on-disk `src/<sub>` files. These
+// drive it directly (the alias branch short-circuits before
+// `nextResolve`, so a stub suffices).
+
+const ctx = { parentURL: undefined };
+const fallthrough = async (): Promise<Resolved> => ({
+  url: "file:///fallthrough",
+});
+
+test(
+  "bare-directory self-alias resolves to its index.ts, not the directory (EISDIR guard)",
+  async () => {
+    const r = await resolve(
+      "plgg-bundle/Dev/fixtures/aliasDir",
+      ctx,
+      fallthrough,
+    );
+    return all([
+      check(
+        r.url.endsWith("/aliasDir/index.ts"),
+        toBe(true),
+      ),
+      check(r.shortCircuit ?? false, toBe(true)),
+    ]);
+  },
+);
+
+test(
+  "file self-alias still resolves to the .ts file (no regression)",
+  async () => {
+    const r = await resolve(
+      "plgg-bundle/index",
+      ctx,
+      fallthrough,
+    );
+    return check(
+      r.url.endsWith("/src/index.ts"),
+      toBe(true),
+    );
+  },
+);
+
+test(
+  "a self-alias with no matching file falls through to nextResolve",
+  async () => {
+    const r = await resolve(
+      "plgg-bundle/does/not/exist",
+      ctx,
+      fallthrough,
+    );
+    return check(
+      r.url,
+      toBe("file:///fallthrough"),
+    );
+  },
+);

package/src/domain/usecase/build.ts

@@ -4,8 +4,8 @@ import {
   rmSync,
   renameSync,
   existsSync,
-} from "node:fs";
-import { join, dirname } from "node:path";
+} from "plgg-bundle/vendors/nodeFs";
+import { join, dirname } from "plgg-bundle/vendors/nodePath";
 import {
   type BundleConfig,
   type Entry,

package/src/domain/usecase/collectModules.spec.ts

@@ -0,0 +1,283 @@
+import {
+  test,
+  check,
+  all,
+  toBe,
+} from "plgg-test";
+import {
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { collectModules } from "plgg-bundle/domain/usecase/collectModules";
+
+test("collectModules records external specifiers without walking them", () => {
+  const root = mkdtempSync(
+    join(tmpdir(), "plgg-bundle-collect-ext-"),
+  );
+  try {
+    const entry = join(root, "src", "main.ts");
+    mkdirSync(join(root, "src"), { recursive: true });
+    writeFileSync(
+      entry,
+      'import { readFileSync } from "node:fs";\nexport const read = readFileSync;\n',
+    );
+    const graph = collectModules({
+      entryFile: entry,
+      root,
+      aliasPrefix: "app",
+      aliasSrcRoot: join(root, "src"),
+      external: /^node:/,
+    });
+    return all([
+      check(graph.modules.length, toBe(1)),
+      check(
+        graph.modules[0]?.externals[0],
+        toBe("node:fs"),
+      ),
+    ]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("collectModules throws on an unresolvable non-external specifier", () => {
+  const root = mkdtempSync(
+    join(tmpdir(), "plgg-bundle-collect-missing-"),
+  );
+  try {
+    const entry = join(root, "src", "main.ts");
+    mkdirSync(join(root, "src"), { recursive: true });
+    writeFileSync(
+      entry,
+      'import "missing";\n',
+    );
+    return check(
+      rejects(() =>
+        collectModules({
+          entryFile: entry,
+          root,
+          aliasPrefix: "app",
+          aliasSrcRoot: join(root, "src"),
+          external: /^node:/,
+        }),
+      ),
+      toBe(true),
+    );
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("collectModules inlines an installed prebundled dist entry without resolving its internal registry requires", () => {
+  const root = mkdtempSync(
+    join(tmpdir(), "plgg-bundle-collect-"),
+  );
+  try {
+    const entry = join(root, "src", "main.ts");
+    const dep = join(
+      root,
+      "node_modules",
+      "dep",
+      "dist",
+      "index.es.js",
+    );
+    const plgg = join(
+      root,
+      "node_modules",
+      "plgg",
+      "dist",
+      "index.es.js",
+    );
+    mkdirSync(join(root, "src"), { recursive: true });
+    mkdirSync(join(root, "node_modules", "dep", "dist"), {
+      recursive: true,
+    });
+    mkdirSync(join(root, "node_modules", "plgg", "dist"), {
+      recursive: true,
+    });
+    writeFileSync(
+      entry,
+      'import dep from "dep";\nexport const value = dep.value;\n',
+    );
+    writeFileSync(
+      dep,
+      [
+        'import * as __ext0 from "plgg";',
+        'const __externals = { "plgg": __ext0 };',
+        "const __modules = {",
+        '"src/index.ts": function (module, exports, require) {',
+        '  exports.value = require("src/internal.ts").value;',
+        "},",
+        '"src/internal.ts": function (module, exports, require) {',
+        "  exports.value = __externals.plgg.external;",
+        "}",
+        "};",
+        'const __entry = __modules["src/index.ts"];',
+        "export default { value: __entry };",
+      ].join("\n"),
+    );
+    writeFileSync(
+      plgg,
+      "export const external = 1;\n",
+    );
+
+    const graph = collectModules({
+      entryFile: entry,
+      root,
+      aliasPrefix: "app",
+      aliasSrcRoot: join(root, "src"),
+      external: /^node:/,
+      resolve: (specifier, _fromFile) =>
+        specifier === "dep"
+          ? dep
+          : specifier === "plgg"
+            ? plgg
+            : undefined,
+    });
+    const depModule = graph.modules.find(
+      (m) =>
+        m.id ===
+        "node_modules/dep/dist/index.es.js",
+    );
+    return all([
+      check(graph.modules.length, toBe(3)),
+      check(
+        depModule?.code.includes(
+          'require("src/internal.ts")',
+        ),
+        toBe(true),
+      ),
+      check(
+        depModule?.code.includes(
+          'require("node_modules/plgg/dist/index.es.js")',
+        ),
+        toBe(true),
+      ),
+    ]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("collectModules resolves node_modules source files without dist-registry filtering", () => {
+  const root = mkdtempSync(
+    join(tmpdir(), "plgg-bundle-collect-src-"),
+  );
+  try {
+    const entry = join(root, "src", "main.ts");
+    const dep = join(
+      root,
+      "node_modules",
+      "dep",
+      "src",
+      "index.ts",
+    );
+    const internal = join(
+      root,
+      "node_modules",
+      "dep",
+      "src",
+      "internal.ts",
+    );
+    writeImportFixture(entry, dep, internal);
+    const graph = collectModules({
+      entryFile: entry,
+      root,
+      aliasPrefix: "app",
+      aliasSrcRoot: join(root, "src"),
+      external: /^node:/,
+      resolve: importFixtureResolver(dep, internal),
+    });
+    return check(graph.modules.length, toBe(3));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("collectModules resolves non-js dist source files without dist-registry filtering", () => {
+  const root = mkdtempSync(
+    join(tmpdir(), "plgg-bundle-collect-mjs-"),
+  );
+  try {
+    const entry = join(root, "src", "main.ts");
+    const dep = join(
+      root,
+      "node_modules",
+      "dep",
+      "dist",
+      "index.ts",
+    );
+    const internal = join(
+      root,
+      "node_modules",
+      "dep",
+      "dist",
+      "internal.ts",
+    );
+    writeImportFixture(entry, dep, internal);
+    const graph = collectModules({
+      entryFile: entry,
+      root,
+      aliasPrefix: "app",
+      aliasSrcRoot: join(root, "src"),
+      external: /^node:/,
+      resolve: importFixtureResolver(dep, internal),
+    });
+    return check(graph.modules.length, toBe(3));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+const writeImportFixture = (
+  entry: string,
+  dep: string,
+  internal: string,
+): void => {
+  mkdirSync(join(entry, ".."), { recursive: true });
+  mkdirSync(join(dep, ".."), { recursive: true });
+  mkdirSync(join(internal, ".."), { recursive: true });
+  writeFileSync(
+    entry,
+    'import { value } from "dep";\nexport const out = value;\n',
+  );
+  writeFileSync(
+    dep,
+    'import { value } from "src/internal.ts";\nexport { value };\n',
+  );
+  writeFileSync(
+    internal,
+    "export const value = 1;\n",
+  );
+};
+
+const importFixtureResolver =
+  (
+    dep: string,
+    internal: string,
+  ): ((
+    specifier: string,
+    fromFile: string,
+  ) => string | undefined) =>
+  (specifier, _fromFile) =>
+    specifier === "dep"
+      ? dep
+      : specifier === "src/internal.ts"
+        ? internal
+        : undefined;
+
+const rejects = (f: () => unknown): boolean => {
+  try {
+    f();
+    return false;
+  } catch (e) {
+    return (
+      e instanceof Error &&
+      e.message.startsWith("ResolveError")
+    );
+  }
+};