plgg-bundle 0.0.1

package/dist/entrypoints/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/entrypoints/cli.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export * from "plgg-bundle/domain/model/BundleConfig";
+export * from "plgg-bundle/domain/usecase/asBundleConfig";
+export * from "plgg-bundle/domain/usecase/build";
+export * from "plgg-bundle/domain/usecase/collectModules";
+export * from "plgg-bundle/domain/usecase/deriveExternal";
+export * from "plgg-bundle/domain/usecase/emitBundle";
+export * from "plgg-bundle/domain/usecase/emitDts";
+export * from "plgg-bundle/domain/usecase/isExternal";
+export * from "plgg-bundle/domain/usecase/resolveSpecifier";
+export * from "plgg-bundle/domain/usecase/rewriteDtsAliases";
+export * from "plgg-bundle/Dev/model/Fetch";
+export * from "plgg-bundle/Dev/model/ModuleGraph";
+export * from "plgg-bundle/Dev/model/Protocol";
+export * from "plgg-bundle/Dev/usecase/parseImports";
+export * from "plgg-bundle/Dev/usecase/buildGraph";
+export * from "plgg-bundle/Dev/usecase/invalidate";
+export * from "plgg-bundle/Dev/usecase/reloadDecision";
+export * from "plgg-bundle/Dev/usecase/decorateDevHtml";
+export * from "plgg-bundle/Dev/usecase/allowedHost";
+export * from "plgg-bundle/Dev/node/devServer";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,cAAc,uCAAuC,CAAC;AACtD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,kCAAkC,CAAC;AACjD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,2CAA2C,CAAC;AAC1D,cAAc,uCAAuC,CAAC;AACtD,cAAc,oCAAoC,CAAC;AACnD,cAAc,uCAAuC,CAAC;AACtD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,8CAA8C,CAAC;AAK7D,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC;AACrD,cAAc,oCAAoC,CAAC;AACnD,cAAc,oCAAoC,CAAC;AACnD,cAAc,wCAAwC,CAAC;AACvD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qCAAqC,CAAC;AACpD,cAAc,gCAAgC,CAAC"}

package/dist/index.js

@@ -0,0 +1,28 @@
+// Public API of the in-house bundler. The CLI
+// (`bin/plgg-bundle.mjs` → `src/entrypoints/cli.ts`) is
+// the usual entry; these exports let other tooling
+// drive the bundler programmatically.
+export * from "plgg-bundle/domain/model/BundleConfig";
+export * from "plgg-bundle/domain/usecase/asBundleConfig";
+export * from "plgg-bundle/domain/usecase/build";
+export * from "plgg-bundle/domain/usecase/collectModules";
+export * from "plgg-bundle/domain/usecase/deriveExternal";
+export * from "plgg-bundle/domain/usecase/emitBundle";
+export * from "plgg-bundle/domain/usecase/emitDts";
+export * from "plgg-bundle/domain/usecase/isExternal";
+export * from "plgg-bundle/domain/usecase/resolveSpecifier";
+export * from "plgg-bundle/domain/usecase/rewriteDtsAliases";
+// Dev server (the `plgg-bundle dev` toolchain half): the
+// app⇄server contract, the pure hot-reload core, and the
+// node-adapter entry point.
+export * from "plgg-bundle/Dev/model/Fetch";
+export * from "plgg-bundle/Dev/model/ModuleGraph";
+export * from "plgg-bundle/Dev/model/Protocol";
+export * from "plgg-bundle/Dev/usecase/parseImports";
+export * from "plgg-bundle/Dev/usecase/buildGraph";
+export * from "plgg-bundle/Dev/usecase/invalidate";
+export * from "plgg-bundle/Dev/usecase/reloadDecision";
+export * from "plgg-bundle/Dev/usecase/decorateDevHtml";
+export * from "plgg-bundle/Dev/usecase/allowedHost";
+export * from "plgg-bundle/Dev/node/devServer";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,wDAAwD;AACxD,mDAAmD;AACnD,sCAAsC;AACtC,cAAc,uCAAuC,CAAC;AACtD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,kCAAkC,CAAC;AACjD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,2CAA2C,CAAC;AAC1D,cAAc,uCAAuC,CAAC;AACtD,cAAc,oCAAoC,CAAC;AACnD,cAAc,uCAAuC,CAAC;AACtD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,8CAA8C,CAAC;AAE7D,yDAAyD;AACzD,yDAAyD;AACzD,4BAA4B;AAC5B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC;AACrD,cAAc,oCAAoC,CAAC;AACnD,cAAc,oCAAoC,CAAC;AACnD,cAAc,wCAAwC,CAAC;AACvD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qCAAqC,CAAC;AACpD,cAAc,gCAAgC,CAAC"}

package/dist/vendors/runner.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Run a self-contained CJS bundle in an isolated VM
+ * context and return its `module.exports` enumerable
+ * keys (minus `__esModule`), sorted. This is how the
+ * ESM emitter learns the exact public surface, since
+ * ESM cannot declare exports dynamically. Re-throws
+ * with context on failure.
+ *
+ * `resolveBase` is the TARGET package's root: the
+ * bundle's external `require("plgg")` / `require("node:*")`
+ * must resolve against the target package's own
+ * node_modules (not the bundler's), so the require is
+ * rooted there. Upstream dists exist in build order, so
+ * the externals resolve.
+ *
+ * Isolated in `src/vendors/` because executing generated
+ * code is an effectful boundary, not domain logic.
+ */
+export declare const readExportNames: (cjsCode: string, resolveBase: string) => ReadonlyArray<string>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/vendors/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/vendors/runner.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,eAAe,GAC1B,SAAS,MAAM,EACf,aAAa,MAAM,KAClB,aAAa,CAAC,MAAM,CAYtB,CAAC"}

package/dist/vendors/runner.js

@@ -0,0 +1,60 @@
+import vm from "node:vm";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+/**
+ * Run a self-contained CJS bundle in an isolated VM
+ * context and return its `module.exports` enumerable
+ * keys (minus `__esModule`), sorted. This is how the
+ * ESM emitter learns the exact public surface, since
+ * ESM cannot declare exports dynamically. Re-throws
+ * with context on failure.
+ *
+ * `resolveBase` is the TARGET package's root: the
+ * bundle's external `require("plgg")` / `require("node:*")`
+ * must resolve against the target package's own
+ * node_modules (not the bundler's), so the require is
+ * rooted there. Upstream dists exist in build order, so
+ * the externals resolve.
+ *
+ * Isolated in `src/vendors/` because executing generated
+ * code is an effectful boundary, not domain logic.
+ */
+export const readExportNames = (cjsCode, resolveBase) => {
+    try {
+        return keysOf(evalCjs(cjsCode, resolveBase));
+    }
+    catch (cause) {
+        throw new Error(`EvalError: failed to read export surface: ${cause instanceof Error
+            ? cause.message
+            : String(cause)}`);
+    }
+};
+/**
+ * Evaluate CJS source in a fresh context with a `require`
+ * rooted at the target package, an empty
+ * `module`/`exports`, and `console`, returning the
+ * populated `module.exports`.
+ */
+const evalCjs = (code, resolveBase) => {
+    const moduleObj = {
+        exports: {},
+    };
+    const context = vm.createContext({
+        module: moduleObj,
+        exports: moduleObj.exports,
+        require: createRequire(pathToFileURL(join(resolveBase, "package.json"))),
+        console,
+    });
+    vm.runInContext(code, context);
+    return moduleObj.exports;
+};
+/**
+ * Enumerable own keys of the exports object, dropping
+ * the `__esModule` interop marker, sorted for a stable
+ * named-export list.
+ */
+const keysOf = (exportsObj) => Object.keys(exportsObj)
+    .filter((k) => k !== "__esModule")
+    .sort();
+//# sourceMappingURL=runner.js.map

package/dist/vendors/runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.js","sourceRoot":"","sources":["../../src/vendors/runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,OAAe,EACf,WAAmB,EACI,EAAE;IACzB,IAAI,CAAC;QACH,OAAO,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC;IAC/C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,6CACE,KAAK,YAAY,KAAK;YACpB,CAAC,CAAC,KAAK,CAAC,OAAO;YACf,CAAC,CAAC,MAAM,CAAC,KAAK,CAClB,EAAE,CACH,CAAC;IACJ,CAAC;AACH,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,OAAO,GAAG,CACd,IAAY,EACZ,WAAmB,EACX,EAAE;IACV,MAAM,SAAS,GAAwB;QACrC,OAAO,EAAE,EAAE;KACZ,CAAC;IACF,MAAM,OAAO,GAAG,EAAE,CAAC,aAAa,CAAC;QAC/B,MAAM,EAAE,SAAS;QACjB,OAAO,EAAE,SAAS,CAAC,OAAO;QAC1B,OAAO,EAAE,aAAa,CACpB,aAAa,CACX,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,CAClC,CACF;QACD,OAAO;KACR,CAAC,CAAC;IACH,EAAE,CAAC,YAAY,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,SAAS,CAAC,OAAO,CAAC;AAC3B,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,GAAG,CACb,UAAkB,EACK,EAAE,CACzB,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC;KACpB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,YAAY,CAAC;KACjC,IAAI,EAAE,CAAC"}

package/dist/vendors/runner.spec.d.ts

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

package/dist/vendors/runner.spec.d.ts.map

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

package/dist/vendors/runner.spec.js

@@ -0,0 +1,20 @@
+import { test, check, all, toBe, } from "plgg-test";
+import { join } from "node:path";
+import { readExportNames } from "plgg-bundle/vendors/runner";
+// Root createRequire at plgg-bundle's own package so a
+// bundle's external require resolves against real
+// node_modules / node builtins (gap #2: externals-aware
+// export-surface discovery).
+const resolveBase = join(import.meta.dirname, "..", "..");
+test("readExportNames reads a self-contained CJS bundle's keys", () => check(readExportNames("exports.a = 1; exports.b = 2;", resolveBase).join(","), toBe("a,b")));
+test("readExportNames resolves an EXTERNAL require during discovery (gap #2)", () => 
+// The bundle keeps `require("node:path")` as an
+// external; discovery must run it via host require
+// (rooted at the target package) without throwing,
+// and still enumerate the entry's own exports.
+all([
+    check(readExportNames('const p = require("node:path"); exports.sep = p.sep; exports.x = 1;', resolveBase).join(","), toBe("sep,x")),
+    // __esModule is filtered out of the surface.
+    check(readExportNames('Object.defineProperty(exports, "__esModule", { value: true }); exports.only = 1;', resolveBase).join(","), toBe("only")),
+]));
+//# sourceMappingURL=runner.spec.js.map

package/dist/vendors/runner.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.spec.js","sourceRoot":"","sources":["../../src/vendors/runner.spec.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,KAAK,EACL,GAAG,EACH,IAAI,GACL,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,uDAAuD;AACvD,kDAAkD;AAClD,wDAAwD;AACxD,6BAA6B;AAC7B,MAAM,WAAW,GAAG,IAAI,CACtB,MAAM,CAAC,IAAI,CAAC,OAAO,EACnB,IAAI,EACJ,IAAI,CACL,CAAC;AAEF,IAAI,CAAC,0DAA0D,EAAE,GAAG,EAAE,CACpE,KAAK,CACH,eAAe,CACb,+BAA+B,EAC/B,WAAW,CACZ,CAAC,IAAI,CAAC,GAAG,CAAC,EACX,IAAI,CAAC,KAAK,CAAC,CACZ,CAAC,CAAC;AAEL,IAAI,CAAC,wEAAwE,EAAE,GAAG,EAAE;AAClF,gDAAgD;AAChD,mDAAmD;AACnD,mDAAmD;AACnD,+CAA+C;AAC/C,GAAG,CAAC;IACF,KAAK,CACH,eAAe,CACb,qEAAqE,EACrE,WAAW,CACZ,CAAC,IAAI,CAAC,GAAG,CAAC,EACX,IAAI,CAAC,OAAO,CAAC,CACd;IACD,6CAA6C;IAC7C,KAAK,CACH,eAAe,CACb,kFAAkF,EAClF,WAAW,CACZ,CAAC,IAAI,CAAC,GAAG,CAAC,EACX,IAAI,CAAC,MAAM,CAAC,CACb;CACF,CAAC,CAAC,CAAC"}

package/dist/vendors/transpiler.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Anti-corruption layer over the TypeScript compiler's
+ * single-file transpile. Translation + delegation only:
+ * TS source in, plain CommonJS JavaScript out; a thrown
+ * compiler error is re-thrown with file context. No
+ * bundling logic lives here — the graph walk and emit
+ * are the in-house domain.
+ *
+ * CommonJS is the target because the in-house
+ * module-registry runtime (domain/usecase/emitBundle)
+ * wraps each module body as `(module, exports, require)
+ * => {...}`; TS lowers `export`/`import`/`export *` to
+ * the `exports.x = ` / `require(...)` forms the runtime
+ * rewrites and links. `removeComments` is the free size
+ * trim that stands in for a (rejected) minifier
+ * dependency.
+ */
+export declare const transpileToCjs: (file: string, source: string) => string;
+//# sourceMappingURL=transpiler.d.ts.map

package/dist/vendors/transpiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transpiler.d.ts","sourceRoot":"","sources":["../../src/vendors/transpiler.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc,GACzB,MAAM,MAAM,EACZ,QAAQ,MAAM,KACb,MAkBF,CAAC"}

package/dist/vendors/transpiler.js

@@ -0,0 +1,42 @@
+import ts from "typescript";
+/**
+ * Anti-corruption layer over the TypeScript compiler's
+ * single-file transpile. Translation + delegation only:
+ * TS source in, plain CommonJS JavaScript out; a thrown
+ * compiler error is re-thrown with file context. No
+ * bundling logic lives here — the graph walk and emit
+ * are the in-house domain.
+ *
+ * CommonJS is the target because the in-house
+ * module-registry runtime (domain/usecase/emitBundle)
+ * wraps each module body as `(module, exports, require)
+ * => {...}`; TS lowers `export`/`import`/`export *` to
+ * the `exports.x = ` / `require(...)` forms the runtime
+ * rewrites and links. `removeComments` is the free size
+ * trim that stands in for a (rejected) minifier
+ * dependency.
+ */
+export const transpileToCjs = (file, source) => {
+    try {
+        return ts.transpileModule(source, {
+            fileName: file,
+            compilerOptions: {
+                module: ts.ModuleKind.CommonJS,
+                target: ts.ScriptTarget.ES2021,
+                esModuleInterop: false,
+                isolatedModules: true,
+                verbatimModuleSyntax: false,
+                removeComments: true,
+            },
+        }).outputText;
+    }
+    catch (cause) {
+        throw new Error(`TranspileError: ${file}: ${messageOf(cause)}`);
+    }
+};
+/**
+ * The message of an unknown thrown value, without
+ * assuming it is an `Error`.
+ */
+const messageOf = (e) => e instanceof Error ? e.message : String(e);
+//# sourceMappingURL=transpiler.js.map

package/dist/vendors/transpiler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transpiler.js","sourceRoot":"","sources":["../../src/vendors/transpiler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,IAAY,EACZ,MAAc,EACN,EAAE;IACV,IAAI,CAAC;QACH,OAAO,EAAE,CAAC,eAAe,CAAC,MAAM,EAAE;YAChC,QAAQ,EAAE,IAAI;YACd,eAAe,EAAE;gBACf,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,QAAQ;gBAC9B,MAAM,EAAE,EAAE,CAAC,YAAY,CAAC,MAAM;gBAC9B,eAAe,EAAE,KAAK;gBACtB,eAAe,EAAE,IAAI;gBACrB,oBAAoB,EAAE,KAAK;gBAC3B,cAAc,EAAE,IAAI;aACrB;SACF,CAAC,CAAC,UAAU,CAAC;IAChB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,mBAAmB,IAAI,KAAK,SAAS,CAAC,KAAK,CAAC,EAAE,CAC/C,CAAC;IACJ,CAAC;AACH,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,SAAS,GAAG,CAAC,CAAU,EAAU,EAAE,CACvC,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "plgg-bundle",
+  "version": "0.0.1",
+  "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",
+    "test": "tsc --noEmit && plgg-test src",
+    "coverage": "tsc --noEmit && plgg-test src --coverage"
+  },
+  "author": "qmu",
+  "license": "MIT",
+  "dependencies": {
+    "typescript": "^6.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "plgg-test": "^0.0.2"
+  }
+}

package/src/Dev/fixtures/devPoc.spec.ts

@@ -0,0 +1,235 @@
+import {
+  test,
+  check,
+  all,
+  toBe,
+} from "plgg-test";
+import { spawn } from "node:child_process";
+import type { ChildProcess } 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: string): string =>
+  `export const message = () => "${word}";\n`;
+
+/** A minimal dev-only bundle config for the fixture app. */
+const configSrc = (root: string): string =>
+  `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 = (): string => {
+  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: number): Promise<void> =>
+  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: string,
+): Promise<{
+  proc: ChildProcess;
+  url: string;
+}> =>
+  new Promise((resolve, reject) => {
+    const proc = spawn(
+      process.execPath,
+      [BIN, "dev", "bundle.config.ts"],
+      { cwd: dir },
+    );
+    let out = "";
+    const onData = (chunk: Buffer): void => {
+      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: string): Promise<string> =>
+  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: string,
+  needle: string,
+): Promise<boolean> => {
+  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();
+  }
+});

package/src/Dev/model/Fetch.ts

@@ -0,0 +1,31 @@
+// Plain-TS build tool: plgg-bundle is a foundation
+// bundler and must not depend on the libraries it builds
+// (plgg / plgg-server). So the dev server speaks the
+// Web-standard request/response contract directly rather
+// than plgg-server's branded `Fetch`. See the package
+// README and the ticket's hard constraints.
+
+/**
+ * The Web-standard request handler an app hands the dev
+ * server: `Request => Promise<Response>`. This is the same
+ * shape plgg-server's `toFetch` produces, reproduced here
+ * as a bare structural type so the toolchain never imports
+ * a plgg package.
+ */
+export type Fetch = (
+  request: Request,
+) => Promise<Response>;
+
+/**
+ * The app⇄dev-server contract. An app's **dev entry**
+ * module default-exports a factory that builds its
+ * {@link Fetch}. The dev server calls it once on start and
+ * again after every hot-reload — a cache-busted re-import
+ * of the entry re-runs the factory over freshly
+ * re-evaluated source, which is how a code edit takes
+ * effect with no process restart. The factory may be
+ * async (config load, route discovery).
+ */
+export type FetchFactory = () =>
+  | Fetch
+  | Promise<Fetch>;

package/src/Dev/model/ModuleGraph.ts

@@ -0,0 +1,30 @@
+/**
+ * The dev server's view of the app's local module graph:
+ * a map from each source file (absolute path) to the
+ * absolute paths of the local files it imports. Only
+ * workspace-local edges are recorded — `node:*` and
+ * `node_modules` specifiers are not part of the watched
+ * graph (they do not change during a dev session).
+ *
+ * Built fresh from disk on each change by the node adapter
+ * (scan → resolve), then consumed by the pure
+ * {@link transitiveImporters} / reload-decision logic. The
+ * graph is what lets the server ignore a save to a file
+ * the app does not import, and report exactly which
+ * modules a change invalidates.
+ */
+export type ModuleGraph = ReadonlyMap<
+  string,
+  ReadonlyArray<string>
+>;
+
+/**
+ * One resolved import edge: `from` imports `to` (both
+ * absolute paths). The adapter produces these by scanning
+ * a file's import specifiers and resolving the local ones;
+ * {@link buildGraph} folds them into a {@link ModuleGraph}.
+ */
+export type Edge = Readonly<{
+  from: string;
+  to: string;
+}>;

package/src/Dev/model/Protocol.ts

@@ -0,0 +1,35 @@
+// The dev-only live-reload wire protocol: the SSE route
+// the injected client script connects to, and the frames
+// pushed over it. Kept as pure constants/string builders
+// (no `node:*`, no sockets) so the transport shape is
+// unit-testable and the node adapter only owns the socket
+// registry. Mirrors plggpress's hand-rolled SSE reload,
+// reproduced here plgg-free in the toolchain.
+
+/** The dev-only Server-Sent-Events live-reload route. */
+export const RELOAD_PATH = "/__plgg_reload";
+
+/**
+ * The SSE opener frame. A comment line keeps the stream
+ * from idling before the first reload is pushed.
+ */
+export const SSE_PRELUDE = ": connected\n\n";
+
+/**
+ * A default-event SSE frame the injected client's
+ * `onmessage` handler reacts to by reloading the page.
+ */
+export const RELOAD_FRAME = "data: reload\n\n";
+
+/**
+ * The dev-only live-reload client: a constant `<script>`
+ * opening an `EventSource` to {@link RELOAD_PATH} that
+ * reloads the page on every pushed frame. This literal is
+ * string-appended onto rendered HTML output ONLY (see
+ * `decorateDevHtml`) — it never enters a typed render
+ * tree, so a production build can never emit it.
+ */
+export const LIVE_RELOAD_SCRIPT =
+  "<script>new EventSource('" +
+  RELOAD_PATH +
+  "').onmessage=()=>location.reload();</script>";