plgg-bundle 0.0.1

package/README.md

@@ -0,0 +1,68 @@
+# plgg-bundle
+
+> **UNSTABLE** - Experimental study work. Part of the [plgg monorepo](../../README.md).
+
+The in-house minimal library bundler for the plgg monorepo. It reproduces what
+`vite build` + `vite-plugin-dts` produced for a library package — dual ESM+CJS
+output plus a per-file `.d.ts` tree — with **zero new dependencies** and **no
+native binding**, retiring the rolldown native-binding fragility that broke CI.
+
+## Why plain TypeScript (not the plgg Result/Option idiom)
+
+Every other `packages/` TypeScript follows the house functional idiom
+(`Result`/`Option`/`pipe`/exhaustive `match`). **plgg-bundle deliberately does
+not.** It is written in plain TypeScript — native control flow, guard-clause
+early returns, and `throw` on failure caught once at the bin boundary
+(`src/entrypoints/cli.ts`) and turned into a process exit code.
+
+The reason is a hard bootstrap constraint: **a foundation build tool must not
+depend on the artifact it builds.** plgg-bundle's job is to build `plgg`'s
+`dist`. If the bundler imported `plgg`, then:
+
+- on a clean checkout / fresh CI runner with no `packages/plgg/dist`, the tool
+  could not even start (`ERR_MODULE_NOT_FOUND`) — it cannot import the thing it
+  is about to produce; and
+- resolving `plgg` from *source* instead is not viable either: plgg's source is
+  not loadable under Node's type-stripping without converting the whole core
+  package to `verbatimModuleSyntax` + ESM (527 fixes across 109 files) — far out
+  of scope.
+
+So the bundler depends on **nothing it builds** and nothing new — only the
+project's own `typescript` (reused) via `ts.transpileModule` and
+`tsc --emitDeclarationOnly`. This mirrors the existing repo precedent of
+plgg-test's launcher being plain `.mjs` "because it runs at the very process
+entry." The FP idiom governs the library and its consumers; bootstrap tooling
+is exempt.
+
+What still holds: the **CLAUDE.md hard rule** — no `as`, no `any`, no
+`@ts-ignore`/`@ts-expect-error` — applies here too. Validation at the `unknown`
+boundary (`asBundleConfig`) uses real `typeof`/`Array.isArray`/`instanceof`
+guards; an unknown function's `any` return is contained to `unknown` before use.
+
+## Layout
+
+- `src/domain/model` — the config model (`BundleConfig`, `applyFileName`).
+- `src/domain/usecase` — pure bundling logic: `asBundleConfig` (validate at the
+  `unknown` boundary), `collectModules` (import-graph walk), `emitBundle`
+  (collision-free module-registry runtime → ESM + CJS), `emitDts` (per-file
+  `.d.ts` via tsc + `rewriteDtsAliases`), `resolveSpecifier`, `isExternal`,
+  `build` (orchestrator).
+- `src/vendors` — the anti-corruption boundary over the only externalized work:
+  `transpiler.ts` (`ts.transpileModule`) and `runner.ts` (`node:vm`
+  export-surface discovery, since ESM cannot declare exports dynamically).
+- `src/entrypoints/cli.ts` + `bin/plgg-bundle.mjs` — the CLI; the bin installs a
+  self-alias resolver hook (`bin/hook.mjs`) and runs the TS CLI under Node's
+  native type-stripping.
+
+## Usage
+
+Each package carries a `bundle.config.ts` (plain data: entries, formats,
+`fileNamePattern`, `external`, `alias`). Run from the package directory:
+
+```
+plgg-bundle            # reads ./bundle.config.ts
+plgg-bundle my.config.ts
+```
+
+See `DEPENDENCY-LOG.md` for the vendor-neutrality decision record and the gaps
+carried to the per-package migration (B2).

package/bin/appAliasHook.mjs

@@ -0,0 +1,89 @@
+// Dev-only cross-package source resolver, registered by
+// `plgg-bundle dev` with the config's `dev.sourceAliases`.
+// It resolves a dependency package's self-alias
+// (`<prefix>/<sub>`) to that package's SOURCE `.ts` (not
+// its built dist), so a theme/library package's source
+// participates in hot-reload. It runs BEFORE the package's
+// own `bin/hook.mjs` in the loader chain (registered
+// later), so on an alias hit it resolves + version-stamps
+// and short-circuits; everything else passes straight
+// through to the next hook (which owns `plgg-bundle/*`
+// resolution and the general `?v=` propagation) — so the
+// version is never appended twice.
+import { statSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { join } from "node:path";
+
+let aliases = [];
+
+// `register(..., { data })` delivers the sourceAliases here
+// (the hook runs on a separate thread; data is cloned in).
+export const initialize = (data) => {
+  aliases = Array.isArray(data?.aliases)
+    ? data.aliases
+    : [];
+};
+
+const isFile = (p) => {
+  try {
+    return statSync(p).isFile();
+  } catch {
+    return false;
+  }
+};
+
+// Resolve a base to a FILE (never a directory): a bare
+// `<prefix>` specifier's base is the src dir itself, which
+// exists — so `index.ts` must be preferred, not the dir.
+const pick = (base) =>
+  [
+    base,
+    `${base}.ts`,
+    join(base, "index.ts"),
+  ].find(isFile);
+
+const versionOf = (url) => {
+  if (!url) {
+    return null;
+  }
+  const m = url.match(/[?&]v=([^&]+)/);
+  return m ? m[1] : null;
+};
+
+const withVersion = (url, v) =>
+  `${url}${url.includes("?") ? "&" : "?"}v=${v}`;
+
+export const resolve = (
+  specifier,
+  context,
+  nextResolve,
+) => {
+  for (const { prefix, srcDir } of aliases) {
+    if (
+      specifier === prefix ||
+      specifier.startsWith(`${prefix}/`)
+    ) {
+      const sub = specifier
+        .slice(prefix.length)
+        .replace(/^\//, "")
+        .split("?")[0];
+      const file = pick(
+        sub === "" ? srcDir : join(srcDir, sub),
+      );
+      if (file) {
+        const url = pathToFileURL(file).href;
+        const v = versionOf(context.parentURL);
+        return {
+          url:
+            v === null
+              ? url
+              : withVersion(url, v),
+          shortCircuit: true,
+        };
+      }
+    }
+  }
+  // Not an aliased specifier — defer to the next hook,
+  // which owns the general `?v=` propagation.
+  return nextResolve(specifier, context);
+};

package/bin/hook.mjs

@@ -0,0 +1,94 @@
+// ESM resolver hook, two jobs:
+//
+// 1. Self-alias: rewrite `plgg-bundle/<sub>` to the
+//    on-disk `src/<sub>` file (`.ts` or `/index.ts`) so
+//    the bundler's own source uses extensionless
+//    self-alias specifiers like the rest of the monorepo.
+//
+// 2. Dev hot-reload version propagation: when the importer
+//    (`context.parentURL`) carries a `?v=<n>` query, append
+//    the SAME query to a resolved LOCAL file. `plgg-bundle
+//    dev` re-imports the app's dev entry as `entry?v=<n>`
+//    after a source edit; this propagation carries the
+//    version down the whole local import subgraph so Node
+//    re-evaluates every affected module (not just the
+//    entry) — real code hot-reload, no process restart.
+//    `node:*` and `node_modules` are never versioned (they
+//    don't change during a dev session), so they stay
+//    cached.
+//
+// Everything else (typescript, node:*) falls through to
+// Node's default resolution.
+import { existsSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { dirname, join } from "node:path";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const srcRoot = join(here, "..", "src");
+const prefix = "plgg-bundle/";
+
+const pick = (base) => {
+  const candidates = [
+    base,
+    `${base}.ts`,
+    join(base, "index.ts"),
+  ];
+  return candidates.find((c) => existsSync(c));
+};
+
+// The `?v=<n>` dev version carried by an importer URL, or
+// null when absent.
+const versionOf = (url) => {
+  if (!url) {
+    return null;
+  }
+  const match = url.match(/[?&]v=([^&]+)/);
+  return match ? match[1] : null;
+};
+
+// Append a dev version query to a resolved URL, respecting
+// an existing query string.
+const withVersion = (url, version) =>
+  `${url}${url.includes("?") ? "&" : "?"}v=${version}`;
+
+// Whether a resolved URL is a workspace-local source file
+// (a `file:` URL outside node_modules) — the only modules
+// that participate in hot-reload.
+const isLocalSource = (url) =>
+  url.startsWith("file:") &&
+  !url.includes("/node_modules/");
+
+export const resolve = async (
+  specifier,
+  context,
+  nextResolve,
+) => {
+  const version = versionOf(context.parentURL);
+  if (specifier.startsWith(prefix)) {
+    // Drop any propagated `?v=` before the on-disk lookup,
+    // then re-attach it so a versioned parent still busts
+    // a self-aliased child's module cache.
+    const [sub] = specifier
+      .slice(prefix.length)
+      .split("?");
+    const file = pick(join(srcRoot, sub));
+    if (file) {
+      const url = pathToFileURL(file).href;
+      return {
+        url:
+          version === null
+            ? url
+            : withVersion(url, version),
+        shortCircuit: true,
+      };
+    }
+  }
+  const resolved = await nextResolve(
+    specifier,
+    context,
+  );
+  return version !== null &&
+    isLocalSource(resolved.url)
+    ? { ...resolved, url: withVersion(resolved.url, version) }
+    : resolved;
+};

package/bin/plgg-bundle.mjs

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+// plgg-bundle launcher. Installs the self-alias resolver
+// hook, then hands off to the TypeScript CLI (Node 24
+// strips types on load). Kept as plain `.mjs` because it
+// runs at the very process entry, before the hook that
+// resolves `plgg-bundle/*` specifiers is registered.
+import { register } from "node:module";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+register("./hook.mjs", import.meta.url);
+
+const here = dirname(fileURLToPath(import.meta.url));
+const cli = join(here, "..", "src", "entrypoints", "cli.ts");
+
+await import(cli);

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

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

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

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

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

@@ -0,0 +1,145 @@
+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

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

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

package/dist/Dev/model/Fetch.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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>;
+//# sourceMappingURL=Fetch.d.ts.map

package/dist/Dev/model/Fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fetch.d.ts","sourceRoot":"","sources":["../../../src/Dev/model/Fetch.ts"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,MAAM,MAAM,KAAK,GAAG,CAClB,OAAO,EAAE,OAAO,KACb,OAAO,CAAC,QAAQ,CAAC,CAAC;AAEvB;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GAAG,MACvB,KAAK,GACL,OAAO,CAAC,KAAK,CAAC,CAAC"}

package/dist/Dev/model/Fetch.js

@@ -0,0 +1,8 @@
+// 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.
+export {};
+//# sourceMappingURL=Fetch.js.map

package/dist/Dev/model/Fetch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fetch.js","sourceRoot":"","sources":["../../../src/Dev/model/Fetch.ts"],"names":[],"mappings":"AAAA,mDAAmD;AACnD,yDAAyD;AACzD,qDAAqD;AACrD,yDAAyD;AACzD,sDAAsD;AACtD,4CAA4C"}

package/dist/Dev/model/ModuleGraph.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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;
+}>;
+//# sourceMappingURL=ModuleGraph.d.ts.map

package/dist/Dev/model/ModuleGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModuleGraph.d.ts","sourceRoot":"","sources":["../../../src/Dev/model/ModuleGraph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,WAAW,GAAG,WAAW,CACnC,MAAM,EACN,aAAa,CAAC,MAAM,CAAC,CACtB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,IAAI,GAAG,QAAQ,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC,CAAC"}

package/dist/Dev/model/ModuleGraph.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ModuleGraph.js.map

package/dist/Dev/model/ModuleGraph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModuleGraph.js","sourceRoot":"","sources":["../../../src/Dev/model/ModuleGraph.ts"],"names":[],"mappings":""}

package/dist/Dev/model/Protocol.d.ts

@@ -0,0 +1,22 @@
+/** The dev-only Server-Sent-Events live-reload route. */
+export declare const RELOAD_PATH = "/__plgg_reload";
+/**
+ * The SSE opener frame. A comment line keeps the stream
+ * from idling before the first reload is pushed.
+ */
+export declare const SSE_PRELUDE = ": connected\n\n";
+/**
+ * A default-event SSE frame the injected client's
+ * `onmessage` handler reacts to by reloading the page.
+ */
+export declare 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 declare const LIVE_RELOAD_SCRIPT: string;
+//# sourceMappingURL=Protocol.d.ts.map

package/dist/Dev/model/Protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Protocol.d.ts","sourceRoot":"","sources":["../../../src/Dev/model/Protocol.ts"],"names":[],"mappings":"AAQA,yDAAyD;AACzD,eAAO,MAAM,WAAW,mBAAmB,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,WAAW,oBAAoB,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,YAAY,qBAAqB,CAAC;AAE/C;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,QAGiB,CAAC"}

package/dist/Dev/model/Protocol.js

@@ -0,0 +1,31 @@
+// 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>";
+//# sourceMappingURL=Protocol.js.map

package/dist/Dev/model/Protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Protocol.js","sourceRoot":"","sources":["../../../src/Dev/model/Protocol.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,yDAAyD;AACzD,yDAAyD;AACzD,sDAAsD;AACtD,0DAA0D;AAC1D,wDAAwD;AACxD,8CAA8C;AAE9C,yDAAyD;AACzD,MAAM,CAAC,MAAM,WAAW,GAAG,gBAAgB,CAAC;AAE5C;;;GAGG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,iBAAiB,CAAC;AAE7C;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,kBAAkB,CAAC;AAE/C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAC7B,2BAA2B;IAC3B,WAAW;IACX,8CAA8C,CAAC"}

package/dist/Dev/node/devServer.d.ts

@@ -0,0 +1,21 @@
+import { type BundleConfig } from "plgg-bundle/domain/model/BundleConfig";
+/**
+ * A running dev server: the URL it is reachable at and a
+ * `close` that stops the listener + watchers. The CLI
+ * ignores `close` (the server runs for the process
+ * lifetime); a test uses it to shut the server down so the
+ * process can exit.
+ */
+export type DevServer = Readonly<{
+    url: string;
+    close: () => void;
+}>;
+/**
+ * Start the dev server for a config's `dev` section: load
+ * the app Fetch, serve it over node:http, watch the source
+ * roots, and hot-reload on every relevant code/content
+ * edit. Resolves once the listener is up, with the
+ * reachable URL and a `close` handle.
+ */
+export declare const runDevServer: (config: BundleConfig) => Promise<DevServer>;
+//# sourceMappingURL=devServer.d.ts.map

package/dist/Dev/node/devServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devServer.d.ts","sourceRoot":"","sources":["../../../src/Dev/node/devServer.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,uCAAuC,CAAC;AA8W1E;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CAAC,CAAC;AAeH;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,GACvB,QAAQ,YAAY,KACnB,OAAO,CAAC,SAAS,CAmFnB,CAAC"}