plgg-bundle 0.0.2 → 0.0.3

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,108 @@
+// 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 version-stamped 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 {
+  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",
+    ),
+  );
+  const dest = join(
+    tmpdir(),
+    `plgg-relocate-${pkg.name}-${pkg.version}`,
+  );
+  const ready = join(
+    dest,
+    ".plgg-relocate-ready",
+  );
+
+  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"),
+    );
+    // The tool's own deps (typescript; plgg for plgg-test) live in the
+    // node_modules that CONTAINS this package (npm hoists there). Symlink it so
+    // resolution from the relocated copy finds them.
+    try {
+      symlinkSync(
+        dirname(pkgRoot),
+        join(dest, "node_modules"),
+        "dir",
+      );
+    } catch {
+      // A pre-existing symlink from a concurrent run is fine.
+    }
+    writeFileSync(ready, "");
+  }
+
+  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.3",
   "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.4"
   }
 }

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.ts

@@ -1,5 +1,5 @@
-import { readFileSync } from "node:fs";
-import { relative } from "node:path";
+import { readFileSync } from "plgg-bundle/vendors/nodeFs";
+import { relative } from "plgg-bundle/vendors/nodePath";
 import { type External } from "plgg-bundle/domain/model/BundleConfig";
 import { resolveSpecifier } from "plgg-bundle/domain/usecase/resolveSpecifier";
 import { isExternal } from "plgg-bundle/domain/usecase/isExternal";

package/src/domain/usecase/deriveExternal.ts

@@ -1,5 +1,5 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { readFileSync } from "plgg-bundle/vendors/nodeFs";
+import { join } from "plgg-bundle/vendors/nodePath";
 import { type External } from "plgg-bundle/domain/model/BundleConfig";
 
 /**

package/src/domain/usecase/discoverWorkspace.ts

@@ -3,8 +3,8 @@ import {
   readFileSync,
   existsSync,
   statSync,
-} from "node:fs";
-import { join, dirname } from "node:path";
+} from "plgg-bundle/vendors/nodeFs";
+import { join, dirname } from "plgg-bundle/vendors/nodePath";
 
 /**
  * A workspace sibling the app bundler can INLINE from

package/src/domain/usecase/emitDts.ts

@@ -1,16 +1,16 @@
-import { spawnSync } from "node:child_process";
+import { spawnSync } from "plgg-bundle/vendors/nodeProc";
 import {
   join,
   dirname,
   basename,
   relative,
-} from "node:path";
+} from "plgg-bundle/vendors/nodePath";
 import {
   existsSync,
   writeFileSync,
   rmSync,
-} from "node:fs";
-import { createRequire } from "node:module";
+} from "plgg-bundle/vendors/nodeFs";
+import { createRequire } from "plgg-bundle/vendors/nodeProc";
 import { rewriteDtsAliases } from "plgg-bundle/domain/usecase/rewriteDtsAliases";
 
 /**

package/src/domain/usecase/resolveSpecifier.ts

@@ -1,9 +1,9 @@
-import { existsSync, statSync } from "node:fs";
+import { existsSync, statSync } from "plgg-bundle/vendors/nodeFs";
 import {
   dirname,
   resolve,
   join,
-} from "node:path";
+} from "plgg-bundle/vendors/nodePath";
 
 /**
  * Resolve a bare import specifier to an absolute source

package/src/domain/usecase/resolveWorkspaceSpecifier.ts

@@ -1,4 +1,4 @@
-import { basename, join } from "node:path";
+import { basename, join } from "plgg-bundle/vendors/nodePath";
 import {
   resolveSpecifier,
   isRelative,

package/src/domain/usecase/rewriteDtsAliases.ts

@@ -3,12 +3,12 @@ import {
   statSync,
   readFileSync,
   writeFileSync,
-} from "node:fs";
+} from "plgg-bundle/vendors/nodeFs";
 import {
   join,
   dirname,
   relative,
-} from "node:path";
+} from "plgg-bundle/vendors/nodePath";
 
 /**
  * Rewrite the package self-alias (`<prefix>/<sub>`) in

package/src/vendors/nodeFs.ts

@@ -0,0 +1,22 @@
+/**
+ * The filesystem anti-corruption layer for plgg-bundle — the
+ * ONLY place the bundler's build usecases reach `node:fs`, kept
+ * under `vendors/` so the domain speaks these named operations,
+ * not the driver. Re-exported (not re-wrapped) to preserve the
+ * exact node types; plgg-bundle's throw-at-the-boundary error
+ * model (see BundleConfig) means a failed fs call surfaces as a
+ * thrown Error the entrypoint catches — the seam is the import
+ * chokepoint, so the vendor-boundary gate holds unexempted.
+ */
+export {
+  writeFileSync,
+  mkdirSync,
+  rmSync,
+  renameSync,
+  existsSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  watch,
+  type FSWatcher,
+} from "node:fs";

package/src/vendors/nodeHttp.ts

@@ -0,0 +1,14 @@
+/**
+ * The HTTP anti-corruption layer for plgg-bundle's DEV server —
+ * the ONLY place the node:http ⇄ Web-standard bridge reaches
+ * `node:http`. Confined here so the dev orchestration stays
+ * `node:`-free (the vendor-boundary gate); a plgg-free
+ * reimplementation of `serve` (the toolchain must not import a
+ * library it builds).
+ */
+export {
+  createServer,
+  type IncomingMessage,
+  type ServerResponse,
+  type Server,
+} from "node:http";

package/src/vendors/nodePath.ts

@@ -0,0 +1,15 @@
+/**
+ * The path anti-corruption layer for plgg-bundle — the ONLY
+ * place the build usecases reach `node:path`. Re-exported to
+ * preserve exact node types; confining the import here is what
+ * keeps the domain free of `node:` specifiers (the
+ * vendor-boundary gate).
+ */
+export {
+  join,
+  dirname,
+  relative,
+  basename,
+  resolve,
+  isAbsolute,
+} from "node:path";

package/src/vendors/nodeProc.ts

@@ -0,0 +1,12 @@
+/**
+ * The process/module anti-corruption layer for plgg-bundle —
+ * the ONLY place the `.d.ts` emitter reaches `node:child_process`
+ * (to spawn the target's own `tsc`) and `node:module` (to
+ * resolve it against the target's node_modules). Confined here so
+ * the domain stays `node:`-free.
+ */
+export { spawnSync } from "node:child_process";
+export {
+  createRequire,
+  register,
+} from "node:module";

package/src/vendors/nodeUrl.ts

@@ -0,0 +1,6 @@
+/**
+ * The URL anti-corruption layer for plgg-bundle's dev server —
+ * the ONLY place `node:url` is reached (turning a filesystem
+ * path into a `file://` URL for the module runner).
+ */
+export { pathToFileURL } from "node:url";