plgg-bundle 0.0.1 → 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,18 +1,15 @@
 {
   "name": "plgg-bundle",
-  "version": "0.0.1",
+  "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": [
-    "dist",
     "src",
     "bin"
   ],
   "bin": {
     "plgg-bundle": "bin/plgg-bundle.mjs"
   },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
     "tsc": "tsc --noEmit",
@@ -26,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";

package/dist/Dev/fixtures/devPoc.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=devPoc.spec.d.ts.map

package/dist/Dev/fixtures/devPoc.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"devPoc.spec.d.ts","sourceRoot":"","sources":["../../../src/Dev/fixtures/devPoc.spec.ts"],"names":[],"mappings":""}

package/dist/Dev/fixtures/devPoc.spec.js

@@ -1,145 +0,0 @@
-import { test, check, all, toBe, } from "plgg-test";
-import { spawn } from "node:child_process";
-import { mkdtempSync, writeFileSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-// The end-to-end hot-reload PoC (ticket 041500). It runs
-// the REAL toolchain — `node bin/plgg-bundle.mjs dev` on a
-// throwaway fixture app — then edits a *deep* source module
-// mid-run and proves the served output changes with NO
-// process restart, and that the SSE reload channel opens.
-// This is the fidelity oracle for the whole chain: bin +
-// loader-hook version propagation + module-runner re-import
-// + node:http serve + fs.watch + SSE.
-/** This spec's dir → the package's bin/plgg-bundle.mjs. */
-const BIN = join(fileURLToPath(import.meta.url), "..", "..", "..", "..", "bin", "plgg-bundle.mjs");
-/** A dev entry that renders a deep child's message as HTML. */
-const ENTRY_SRC = [
-    `import { message } from "./child.ts";`,
-    `export default () =>`,
-    `  (_request) =>`,
-    `    Promise.resolve(`,
-    `      new Response(`,
-    '        `<html><body>${message()}</body></html>`,',
-    `        { headers: { "content-type": "text/html" } },`,
-    `      ),`,
-    `    );`,
-].join("\n");
-/** The deep child module the edit targets. */
-const childSrc = (word) => `export const message = () => "${word}";\n`;
-/** A minimal dev-only bundle config for the fixture app. */
-const configSrc = (root) => `export default ${JSON.stringify({
-    root,
-    rootDir: ".",
-    outDir: "dist",
-    fileNamePattern: "[name].[format].js",
-    entries: [],
-    formats: ["es"],
-    alias: { prefix: "fixture", srcRoot: "." },
-    dev: {
-        entry: "entry.ts",
-        // Port 0 → ephemeral; the real port is read from
-        // the server's ready line.
-        port: 0,
-        watch: [root],
-        allowedHosts: [],
-    },
-}, null, 2)};\n`;
-/** Lay down the fixture app in a fresh temp dir. */
-const writeFixture = () => {
-    const dir = mkdtempSync(join(tmpdir(), "plgg-dev-poc-"));
-    writeFileSync(join(dir, "child.ts"), childSrc("ALPHA"));
-    writeFileSync(join(dir, "entry.ts"), ENTRY_SRC);
-    writeFileSync(join(dir, "bundle.config.ts"), configSrc(dir));
-    return dir;
-};
-/** Sleep (test-only pacing for the watch/reload loop). */
-const wait = (ms) => new Promise((r) => setTimeout(r, ms));
-/**
- * Spawn `plgg-bundle dev` on the fixture and resolve the
- * served URL once the ready line is printed.
- */
-const startDev = (dir) => new Promise((resolve, reject) => {
-    const proc = spawn(process.execPath, [BIN, "dev", "bundle.config.ts"], { cwd: dir });
-    let out = "";
-    const onData = (chunk) => {
-        out += chunk.toString();
-        const m = out.match(/http:\/\/localhost:\d+\//);
-        if (m) {
-            proc.stdout?.off("data", onData);
-            resolve({ proc, url: m[0] });
-        }
-    };
-    proc.stdout?.on("data", onData);
-    proc.on("error", reject);
-    setTimeout(() => reject(new Error(`dev server did not start; output:\n${out}`)), 8000);
-});
-/** Fetch a URL's body text. */
-const body = (url) => fetch(url).then((r) => r.text());
-/**
- * Poll `body(url)` until it contains `needle`, or throw on
- * timeout. Proves the served output actually changed after
- * the edit (not a fixed sleep guess).
- */
-const pollFor = async (url, needle) => {
-    const deadline = 6000;
-    const step = 60;
-    for (let waited = 0; waited < deadline;) {
-        if ((await body(url)).includes(needle)) {
-            return true;
-        }
-        await wait(step);
-        waited += step;
-    }
-    return false;
-};
-test("plgg-bundle dev hot-reloads a deep source edit with no restart", async () => {
-    const dir = writeFixture();
-    const { proc, url } = await startDev(dir);
-    try {
-        const first = await body(url);
-        // Rewrite the DEEP child (not the entry) mid-run.
-        writeFileSync(join(dir, "child.ts"), childSrc("BETA"));
-        const reloaded = await pollFor(url, "BETA");
-        const stillAlive = proc.exitCode === null;
-        return all([
-            // Initial render came from the child module.
-            check(first.includes("ALPHA"), toBe(true)),
-            // The dev server injected its live-reload client.
-            check(first.includes("EventSource"), toBe(true)),
-            // The deep edit re-evaluated and is now served …
-            check(reloaded, toBe(true)),
-            // … by the SAME process (no restart).
-            check(stillAlive, toBe(true)),
-        ]);
-    }
-    finally {
-        proc.kill();
-    }
-});
-test("plgg-bundle dev opens an SSE reload channel", async () => {
-    const dir = writeFixture();
-    const { proc, url } = await startDev(dir);
-    try {
-        const res = await fetch(`${url}__plgg_reload`);
-        const contentType = res.headers.get("content-type") ?? "";
-        // Read the opener frame, then release the stream.
-        const reader = res.body?.getReader();
-        const firstChunk = reader
-            ? await reader.read()
-            : { value: undefined };
-        await reader?.cancel();
-        const text = firstChunk.value
-            ? new TextDecoder().decode(firstChunk.value)
-            : "";
-        return all([
-            check(contentType.includes("text/event-stream"), toBe(true)),
-            check(text.includes("connected"), toBe(true)),
-        ]);
-    }
-    finally {
-        proc.kill();
-    }
-});
-//# sourceMappingURL=devPoc.spec.js.map