@c9up/ream 0.2.23 → 0.2.25

package/dist/dev/hmr.js

@@ -36,6 +36,67 @@ function holder() {
 export function hotReloadHappened() {
     const store = holder();
     store[COUNTER] = (store[COUNTER] ?? 0) + 1;
+    notifyClients();
+}
+const clients = new Set();
+/** The event name the injected script listens for. */
+const HMR_EVENT = 'ream:hmr';
+/**
+ * Answer the dev client BEFORE any application middleware runs, and PUSH.
+ *
+ * Two problems, one change.
+ *
+ * It used to be an ordinary route polled once a second, per open tab, and a
+ * route runs the whole middleware stack. An application that resolves a user
+ * from a session cookie therefore ran `SELECT * FROM users` once a second for
+ * a response whose entire content is a process id and a counter, and which
+ * depends on no user, no session and no body.
+ *
+ * It is a stream now, so the cost is paid ONCE per tab instead of once a
+ * second, and a change reaches the browser immediately rather than up to a
+ * second later. Upstream gets the same thing from Vite's websocket; this needs
+ * no bundler, because the server already speaks SSE.
+ *
+ * Registered FIRST rather than merely outside the router: middleware that
+ * authenticates lives at either tier, and an application is free to put it in
+ * `server.use([...])` — many do, because it must run before routing.
+ *
+ * Development only. In production nothing injects the script and nothing
+ * registers this.
+ */
+export function hmrEndpoint() {
+    return async (ctx, next) => {
+        // `url()` carries the query string; a client may append a cache-buster.
+        const path = ctx.request.url().split('?')[0];
+        if (path !== HMR_PATH) {
+            await next();
+            return;
+        }
+        let stream;
+        try {
+            stream = await ctx.response.sse();
+        }
+        catch {
+            // A host without the streaming NAPI — a mock server in a test, say.
+            // Losing the reload is fine; failing the request is not.
+            await next();
+            return;
+        }
+        clients.add(stream);
+        stream.onClose(() => clients.delete(stream));
+        // Immediately, so a tab that connects after a restart compares against the
+        // CURRENT token rather than waiting for the next swap to learn anything.
+        await stream.send(HMR_EVENT, hmrToken());
+    };
+}
+/** Tell every open tab the token moved. */
+function notifyClients() {
+    const token = hmrToken();
+    for (const client of clients) {
+        // Detached: a swap must not wait on a socket, and a dead one is dropped by
+        // its own close handler.
+        void client.send(HMR_EVENT, token).catch(() => clients.delete(client));
+    }
 }
 /** How many hot swaps this process has seen. */
 export function hotReloadCount() {
@@ -51,10 +112,15 @@ export function hmrToken() {
 /**
  * The script injected into HTML pages in dev.
  *
- * It reloads when the token changes, NOT when the request fails: a server that
- * is restarting is unreachable for a moment, and reloading then would only show
- * the browser's error page. It waits for an answer, and the answer carries a
- * new boot id.
+ * An `EventSource`, not a poll. The server pushes the token, so a change
+ * reaches the page immediately and an idle tab costs one open connection
+ * rather than a request per second through the whole middleware stack.
+ *
+ * It reloads when the token CHANGES, never when the connection fails: a
+ * restarting server is unreachable for a moment, and reloading then would only
+ * show the browser's error page. `EventSource` reconnects on its own, and the
+ * server greets the new connection with its token — which after a restart is a
+ * different boot id, so the reload happens then, once the server can serve it.
  */
 export function hmrClientScript(nonce) {
     // A nonce-based CSP — which the scaffold ships, via `@c9up/blackhole` —
@@ -63,10 +129,10 @@ export function hmrClientScript(nonce) {
     // are escaped because a nonce is generated, not user input, but a broken
     // attribute would silently disable the tag rather than fail loudly.
     const attribute = nonce === undefined ? '' : ` nonce="${nonce.replace(/"/g, '"')}"`;
-    // A failed poll RETRIES. Returning on `!r.ok` stopped the loop for good, so a
-    // page opened in the window before the endpoint is mounted — or during any
-    // blip — never reloaded again for the life of that tab, which looks exactly
-    // like the feature not working.
-    return `<script${attribute}>(()=>{let t=null;const p=${JSON.stringify(HMR_PATH)};const tick=async()=>{try{const r=await fetch(p,{cache:'no-store'});if(r.ok){const n=(await r.text()).trim();if(t===null){t=n}else if(n!==t){location.reload();return}}}catch(e){}setTimeout(tick,1000)};tick()})()</script>`;
+    // `addEventListener(HMR_EVENT)`, NOT `onmessage`: the stream names its
+    // events, and `onmessage` fires only for unnamed ones — a client wired that
+    // way receives nothing at all, silently, which is a mistake this codebase
+    // has already made once with relay.
+    return `<script${attribute}>(()=>{let t=null;const s=new EventSource(${JSON.stringify(HMR_PATH)});s.addEventListener(${JSON.stringify(HMR_EVENT)},e=>{let n;try{n=JSON.parse(e.data)}catch(_){n=e.data}if(t===null){t=n}else if(n!==t){s.close();location.reload()}})})()</script>`;
 }
 //# sourceMappingURL=hmr.js.map

package/dist/dev/hmr.js.map

@@ -1 +1 @@
-{"version":3,"file":"hmr.js","sourceRoot":"","sources":["../../src/dev/hmr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,qEAAqE;AACrE,MAAM,CAAC,MAAM,QAAQ,GAAG,aAAa,CAAA;AAErC;;;GAGG;AACH,MAAM,OAAO,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAA;AAE3D,qEAAqE;AACrE,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAA;AAMrD;;;;;GAKG;AACH,SAAS,MAAM;IACb,OAAO,UAAsC,CAAA;AAC/C,CAAC;AAED,0EAA0E;AAC1E,MAAM,UAAU,iBAAiB;IAC/B,MAAM,KAAK,GAAG,MAAM,EAAE,CAAA;IACtB,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAA;AAC5C,CAAC;AAED,gDAAgD;AAChD,MAAM,UAAU,cAAc;IAC5B,OAAO,MAAM,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;AAC/B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,QAAQ;IACtB,OAAO,GAAG,OAAO,IAAI,cAAc,EAAE,EAAE,CAAA;AACzC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAAC,KAAc;IAC5C,wEAAwE;IACxE,4EAA4E;IAC5E,4EAA4E;IAC5E,yEAAyE;IACzE,oEAAoE;IACpE,MAAM,SAAS,GAAG,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAA;IACxF,8EAA8E;IAC9E,2EAA2E;IAC3E,4EAA4E;IAC5E,gCAAgC;IAChC,OAAO,UAAU,SAAS,6BAA6B,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,8NAA8N,CAAA;AAC/S,CAAC"}
+{"version":3,"file":"hmr.js","sourceRoot":"","sources":["../../src/dev/hmr.ts"],"names":[],"mappings":"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"}

package/dist/dev/hotGlob.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Matching the globs an application declares under `hotHook.boundaries`.
+ *
+ * A dependency for this would be `picomatch` plus `fast-glob`, which is two
+ * packages and their trees for the three wildcards these patterns actually use.
+ * The patterns are written by hand in a `package.json` and read once at boot;
+ * what they need is to be right, not fast.
+ *
+ * The dialect is the one those files already use:
+ *   *      any run of characters inside one path segment
+ *   **     any number of segments, including none
+ *   ?      exactly one character inside a segment
+ *   {a,b}  either alternative
+ *
+ * The brace form is the one a `metaFiles` entry uses —
+ * `resources/lang/**\/*.{json,yaml,yml}` — and it has to be understood on this
+ * side too: the CLI matches the same pattern when it copies those files into
+ * the build, and a dialect that differed between the two would let an entry
+ * copy at build time and never fire in development, or the reverse.
+ *
+ * A leading `./` is optional, and matching is done on POSIX-shaped paths
+ * relative to the project root, so a Windows checkout and a Linux one read the
+ * same pattern the same way.
+ */
+/** Turn one glob into an anchored regular expression. */
+export declare function globToRegExp(pattern: string): RegExp;
+/**
+ * A matcher over several globs.
+ *
+ * Returns a predicate rather than a class: the graph takes a function, and a
+ * project with no boundaries gets one that is honestly always false instead of
+ * an empty object that has to be checked for.
+ */
+export declare function globMatcher(patterns: readonly string[]): (path: string) => boolean;
+//# sourceMappingURL=hotGlob.d.ts.map

package/dist/dev/hotGlob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotGlob.d.ts","sourceRoot":"","sources":["../../src/dev/hotGlob.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,yDAAyD;AACzD,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAgDpD;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAOlF"}

package/dist/dev/hotGlob.js

@@ -0,0 +1,92 @@
+/**
+ * Matching the globs an application declares under `hotHook.boundaries`.
+ *
+ * A dependency for this would be `picomatch` plus `fast-glob`, which is two
+ * packages and their trees for the three wildcards these patterns actually use.
+ * The patterns are written by hand in a `package.json` and read once at boot;
+ * what they need is to be right, not fast.
+ *
+ * The dialect is the one those files already use:
+ *   *      any run of characters inside one path segment
+ *   **     any number of segments, including none
+ *   ?      exactly one character inside a segment
+ *   {a,b}  either alternative
+ *
+ * The brace form is the one a `metaFiles` entry uses —
+ * `resources/lang/**\/*.{json,yaml,yml}` — and it has to be understood on this
+ * side too: the CLI matches the same pattern when it copies those files into
+ * the build, and a dialect that differed between the two would let an entry
+ * copy at build time and never fire in development, or the reverse.
+ *
+ * A leading `./` is optional, and matching is done on POSIX-shaped paths
+ * relative to the project root, so a Windows checkout and a Linux one read the
+ * same pattern the same way.
+ */
+/** Turn one glob into an anchored regular expression. */
+export function globToRegExp(pattern) {
+    const cleaned = pattern.replace(/^\.\//, '');
+    let out = '';
+    for (let i = 0; i < cleaned.length; i += 1) {
+        const char = cleaned[i];
+        if (char === '*') {
+            if (cleaned[i + 1] === '*') {
+                // `**/` swallows the separator so that `a/**/b` also matches `a/b`;
+                // a trailing `**` simply matches the rest.
+                i += 1;
+                if (cleaned[i + 1] === '/') {
+                    i += 1;
+                    out += '(?:[^/]+/)*';
+                }
+                else {
+                    out += '.*';
+                }
+                continue;
+            }
+            out += '[^/]*';
+            continue;
+        }
+        if (char === '?') {
+            out += '[^/]';
+            continue;
+        }
+        if (char === '{') {
+            const close = cleaned.indexOf('}', i);
+            if (close !== -1) {
+                // Alternatives are literal text, never nested globs: that is the whole
+                // of the form these patterns use, and a recursive reading would accept
+                // shapes the CLI's matcher does not.
+                const options = cleaned
+                    .slice(i + 1, close)
+                    .split(',')
+                    .map((option) => option.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+                out += `(?:${options.join('|')})`;
+                i = close;
+                continue;
+            }
+            // Unclosed: read literally rather than throwing. A pattern is a string in
+            // a config file, and a malformed one should match nothing, not take the
+            // dev server down at boot.
+        }
+        // Everything else is literal, including the characters a regular
+        // expression would otherwise read as syntax.
+        out += (char ?? '').replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    }
+    return new RegExp(`^${out}$`);
+}
+/**
+ * A matcher over several globs.
+ *
+ * Returns a predicate rather than a class: the graph takes a function, and a
+ * project with no boundaries gets one that is honestly always false instead of
+ * an empty object that has to be checked for.
+ */
+export function globMatcher(patterns) {
+    const expressions = patterns.map(globToRegExp);
+    if (expressions.length === 0)
+        return () => false;
+    return (path) => {
+        const normalised = path.replace(/\\/g, '/').replace(/^\.\//, '');
+        return expressions.some((expression) => expression.test(normalised));
+    };
+}
+//# sourceMappingURL=hotGlob.js.map

package/dist/dev/hotGlob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotGlob.js","sourceRoot":"","sources":["../../src/dev/hotGlob.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,yDAAyD;AACzD,MAAM,UAAU,YAAY,CAAC,OAAe;IAC1C,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAA;IAC5C,IAAI,GAAG,GAAG,EAAE,CAAA;IACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;QACvB,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;YACjB,IAAI,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;gBAC3B,oEAAoE;gBACpE,2CAA2C;gBAC3C,CAAC,IAAI,CAAC,CAAA;gBACN,IAAI,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;oBAC3B,CAAC,IAAI,CAAC,CAAA;oBACN,GAAG,IAAI,aAAa,CAAA;gBACtB,CAAC;qBAAM,CAAC;oBACN,GAAG,IAAI,IAAI,CAAA;gBACb,CAAC;gBACD,SAAQ;YACV,CAAC;YACD,GAAG,IAAI,OAAO,CAAA;YACd,SAAQ;QACV,CAAC;QACD,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;YACjB,GAAG,IAAI,MAAM,CAAA;YACb,SAAQ;QACV,CAAC;QACD,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;YACjB,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,CAAA;YACrC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;gBACjB,uEAAuE;gBACvE,uEAAuE;gBACvE,qCAAqC;gBACrC,MAAM,OAAO,GAAG,OAAO;qBACpB,KAAK,CAAC,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC;qBACnB,KAAK,CAAC,GAAG,CAAC;qBACV,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC,CAAA;gBACjE,GAAG,IAAI,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAA;gBACjC,CAAC,GAAG,KAAK,CAAA;gBACT,SAAQ;YACV,CAAC;YACD,0EAA0E;YAC1E,wEAAwE;YACxE,2BAA2B;QAC7B,CAAC;QACD,iEAAiE;QACjE,6CAA6C;QAC7C,GAAG,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAAA;IAC1D,CAAC;IACD,OAAO,IAAI,MAAM,CAAC,IAAI,GAAG,GAAG,CAAC,CAAA;AAC/B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,QAA2B;IACrD,MAAM,WAAW,GAAG,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAA;IAC9C,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,GAAG,EAAE,CAAC,KAAK,CAAA;IAChD,OAAO,CAAC,IAAY,EAAE,EAAE;QACtB,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAA;QAChE,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAA;IACtE,CAAC,CAAA;AACH,CAAC"}

package/dist/dev/hotGraph.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The import graph a hot reload reasons over, and what it decides.
+ *
+ * Owned here rather than taken from `hot-hook`, which used to do this job. The
+ * package is 655 lines and four npm dependencies, and it had to be installed by
+ * every application because a dev-only loader has no business in a production
+ * install of the framework — so a project created before that convention simply
+ * lost hot reloading and was told nothing. The part that genuinely needs a
+ * library is the part Node now provides itself: `module.registerHooks` for the
+ * graph, `fs.watch` for the changes.
+ *
+ * NO node_modules dependency, deliberately: everything below is arithmetic on
+ * paths.
+ *
+ * The graph is built by the resolver as the program runs, never by reading
+ * files. A `resolve` hook is handed the importer and the imported, which is
+ * exactly an edge, and it sees dynamic imports as they happen — a static parse
+ * of the source could only guess at those.
+ */
+/** What a change to one file means. */
+export type Decision = {
+    kind: 'swap';
+    invalidated: string[];
+} | {
+    kind: 'reload';
+    file: string;
+    reason: 'outside-boundaries' | 'restart-list';
+} | {
+    kind: 'ignore';
+};
+export declare class HotGraph {
+    #private;
+    constructor(options: {
+        isBoundary: (file: string) => boolean;
+        isRestart: (file: string) => boolean;
+    });
+    /** Record that `importer` imported `file`. Called from the resolve hook. */
+    link(file: string, importer: string | undefined): void;
+    /** The version to hang off the URL, or 0 while the module has never been invalidated. */
+    version(file: string): number;
+    /** Whether the resolver has ever seen this file. */
+    knows(file: string): boolean;
+    /**
+     * What to do about `file` having changed.
+     *
+     * Walks up from the changed file collecting what has to be re-imported, and
+     * stops at each boundary: a boundary is imported dynamically, so the next
+     * import of it re-resolves, and with it everything below that was collected
+     * on the way. A path that reaches a module nobody imports without crossing a
+     * boundary cannot be re-imported by anyone, and that is a full reload.
+     *
+     * Deciding before invalidating matters: a decision that turns out to be a
+     * full reload must leave no version bumped behind, or a later swap would
+     * hand the caller a URL for a module the process never re-imported.
+     */
+    decide(file: string): Decision;
+}
+//# sourceMappingURL=hotGraph.d.ts.map

package/dist/dev/hotGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotGraph.d.ts","sourceRoot":"","sources":["../../src/dev/hotGraph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAUH,uCAAuC;AACvC,MAAM,MAAM,QAAQ,GAChB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,oBAAoB,GAAG,cAAc,CAAA;CAAE,GAC/E;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAA;AAEtB,qBAAa,QAAQ;;gBAKP,OAAO,EAAE;QACnB,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;QACrC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;KACrC;IAcD,4EAA4E;IAC5E,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAKtD,yFAAyF;IACzF,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAI7B,oDAAoD;IACpD,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI5B;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ;CAuB/B"}

package/dist/dev/hotGraph.js

@@ -0,0 +1,91 @@
+/**
+ * The import graph a hot reload reasons over, and what it decides.
+ *
+ * Owned here rather than taken from `hot-hook`, which used to do this job. The
+ * package is 655 lines and four npm dependencies, and it had to be installed by
+ * every application because a dev-only loader has no business in a production
+ * install of the framework — so a project created before that convention simply
+ * lost hot reloading and was told nothing. The part that genuinely needs a
+ * library is the part Node now provides itself: `module.registerHooks` for the
+ * graph, `fs.watch` for the changes.
+ *
+ * NO node_modules dependency, deliberately: everything below is arithmetic on
+ * paths.
+ *
+ * The graph is built by the resolver as the program runs, never by reading
+ * files. A `resolve` hook is handed the importer and the imported, which is
+ * exactly an edge, and it sees dynamic imports as they happen — a static parse
+ * of the source could only guess at those.
+ */
+export class HotGraph {
+    #nodes = new Map();
+    #isBoundary;
+    #isRestart;
+    constructor(options) {
+        this.#isBoundary = options.isBoundary;
+        this.#isRestart = options.isRestart;
+    }
+    #node(file) {
+        let node = this.#nodes.get(file);
+        if (node === undefined) {
+            node = { importers: new Set(), version: 0 };
+            this.#nodes.set(file, node);
+        }
+        return node;
+    }
+    /** Record that `importer` imported `file`. Called from the resolve hook. */
+    link(file, importer) {
+        const node = this.#node(file);
+        if (importer !== undefined && importer !== file)
+            node.importers.add(importer);
+    }
+    /** The version to hang off the URL, or 0 while the module has never been invalidated. */
+    version(file) {
+        return this.#nodes.get(file)?.version ?? 0;
+    }
+    /** Whether the resolver has ever seen this file. */
+    knows(file) {
+        return this.#nodes.has(file);
+    }
+    /**
+     * What to do about `file` having changed.
+     *
+     * Walks up from the changed file collecting what has to be re-imported, and
+     * stops at each boundary: a boundary is imported dynamically, so the next
+     * import of it re-resolves, and with it everything below that was collected
+     * on the way. A path that reaches a module nobody imports without crossing a
+     * boundary cannot be re-imported by anyone, and that is a full reload.
+     *
+     * Deciding before invalidating matters: a decision that turns out to be a
+     * full reload must leave no version bumped behind, or a later swap would
+     * hand the caller a URL for a module the process never re-imported.
+     */
+    decide(file) {
+        if (this.#isRestart(file))
+            return { kind: 'reload', file, reason: 'restart-list' };
+        if (!this.#nodes.has(file))
+            return { kind: 'ignore' };
+        const collected = new Set();
+        const queue = [file];
+        while (queue.length > 0) {
+            const current = queue.pop();
+            if (current === undefined || collected.has(current))
+                continue;
+            collected.add(current);
+            // A boundary is where the walk stops: whoever imports it does so
+            // dynamically and will ask for it again.
+            if (this.#isBoundary(current))
+                continue;
+            const importers = this.#nodes.get(current)?.importers;
+            if (importers === undefined || importers.size === 0) {
+                return { kind: 'reload', file, reason: 'outside-boundaries' };
+            }
+            for (const importer of importers)
+                queue.push(importer);
+        }
+        for (const path of collected)
+            this.#node(path).version += 1;
+        return { kind: 'swap', invalidated: [...collected] };
+    }
+}
+//# sourceMappingURL=hotGraph.js.map

package/dist/dev/hotGraph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotGraph.js","sourceRoot":"","sources":["../../src/dev/hotGraph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAgBH,MAAM,OAAO,QAAQ;IACV,MAAM,GAAG,IAAI,GAAG,EAAgB,CAAA;IAChC,WAAW,CAA2B;IACtC,UAAU,CAA2B;IAE9C,YAAY,OAGX;QACC,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,UAAU,CAAA;QACrC,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,SAAS,CAAA;IACrC,CAAC;IAED,KAAK,CAAC,IAAY;QAChB,IAAI,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAChC,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,IAAI,GAAG,EAAE,SAAS,EAAE,IAAI,GAAG,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE,CAAA;YAC3C,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;QAC7B,CAAC;QACD,OAAO,IAAI,CAAA;IACb,CAAC;IAED,4EAA4E;IAC5E,IAAI,CAAC,IAAY,EAAE,QAA4B;QAC7C,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAC7B,IAAI,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,IAAI;YAAE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;IAC/E,CAAC;IAED,yFAAyF;IACzF,OAAO,CAAC,IAAY;QAClB,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,OAAO,IAAI,CAAC,CAAA;IAC5C,CAAC;IAED,oDAAoD;IACpD,KAAK,CAAC,IAAY;QAChB,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IAC9B,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,IAAY;QACjB,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;YAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,CAAA;QAClF,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAA;QAErD,MAAM,SAAS,GAAG,IAAI,GAAG,EAAU,CAAA;QACnC,MAAM,KAAK,GAAG,CAAC,IAAI,CAAC,CAAA;QACpB,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxB,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,EAAE,CAAA;YAC3B,IAAI,OAAO,KAAK,SAAS,IAAI,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC;gBAAE,SAAQ;YAC7D,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;YACtB,iEAAiE;YACjE,yCAAyC;YACzC,IAAI,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;gBAAE,SAAQ;YACvC,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,SAAS,CAAA;YACrD,IAAI,SAAS,KAAK,SAAS,IAAI,SAAS,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;gBACpD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,oBAAoB,EAAE,CAAA;YAC/D,CAAC;YACD,KAAK,MAAM,QAAQ,IAAI,SAAS;gBAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QACxD,CAAC;QAED,KAAK,MAAM,IAAI,IAAI,SAAS;YAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,IAAI,CAAC,CAAA;QAC3D,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,GAAG,SAAS,CAAC,EAAE,CAAA;IACtD,CAAC;CACF"}

package/dist/dev/hotWatcher.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Watching the project for the changes a hot reload reacts to.
+ *
+ * `fs.watch` with `recursive: true`, which Node implements on Linux, macOS and
+ * Windows alike — the reason a watcher used to be a dependency here, and is not
+ * any more.
+ *
+ * Two behaviours are worth stating because they are not obvious from the API:
+ *
+ * A save is rarely one event. Editors write, rename and touch, and a single
+ * Ctrl-S can arrive as several notifications for the same file within a few
+ * milliseconds. Each one would walk the graph and bump a version, so they are
+ * coalesced.
+ *
+ * `ream dev` also watches from the outside, in Rust. That is not a duplicate:
+ * this watcher dies with the process it lives in, so a server that crashed on a
+ * syntax error has nothing left to notice the fix. The outer one covers exactly
+ * that window, and hands back over by restarting the process.
+ */
+export interface WatcherOptions {
+    /** Project root; every reported path is absolute, resolved against it. */
+    root: string;
+    /** Directories under the root to watch, when they exist. */
+    directories: readonly string[];
+    /** Individual files to watch — env files sit at the root, so no directory covers them. */
+    files: readonly string[];
+    /** Called once per settled change, with an absolute path. */
+    onChange: (file: string) => void;
+}
+export interface Watcher {
+    close: () => void;
+}
+export declare function watchProject(options: WatcherOptions): Watcher;
+//# sourceMappingURL=hotWatcher.d.ts.map

package/dist/dev/hotWatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotWatcher.d.ts","sourceRoot":"","sources":["../../src/dev/hotWatcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAQH,MAAM,WAAW,cAAc;IAC7B,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAA;IACZ,4DAA4D;IAC5D,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;IAC9B,0FAA0F;IAC1F,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;IACxB,6DAA6D;IAC7D,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CACjC;AAED,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CA+C7D"}

package/dist/dev/hotWatcher.js

@@ -0,0 +1,72 @@
+/**
+ * Watching the project for the changes a hot reload reacts to.
+ *
+ * `fs.watch` with `recursive: true`, which Node implements on Linux, macOS and
+ * Windows alike — the reason a watcher used to be a dependency here, and is not
+ * any more.
+ *
+ * Two behaviours are worth stating because they are not obvious from the API:
+ *
+ * A save is rarely one event. Editors write, rename and touch, and a single
+ * Ctrl-S can arrive as several notifications for the same file within a few
+ * milliseconds. Each one would walk the graph and bump a version, so they are
+ * coalesced.
+ *
+ * `ream dev` also watches from the outside, in Rust. That is not a duplicate:
+ * this watcher dies with the process it lives in, so a server that crashed on a
+ * syntax error has nothing left to notice the fix. The outer one covers exactly
+ * that window, and hands back over by restarting the process.
+ */
+import { watch } from 'node:fs';
+import { join, resolve } from 'node:path';
+/** How long to wait for a save to finish arriving before acting on it. */
+const SETTLE_MS = 40;
+export function watchProject(options) {
+    const watchers = [];
+    const pending = new Map();
+    const report = (file) => {
+        const existing = pending.get(file);
+        if (existing !== undefined)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            pending.delete(file);
+            options.onChange(file);
+        }, SETTLE_MS);
+        // The dev server must still be able to exit while a save is settling.
+        timer.unref?.();
+        pending.set(file, timer);
+    };
+    for (const directory of options.directories) {
+        const absolute = resolve(options.root, directory);
+        try {
+            watchers.push(watch(absolute, { recursive: true }, (_event, name) => {
+                if (typeof name !== 'string' || name === '')
+                    return;
+                report(join(absolute, name));
+            }));
+        }
+        catch {
+            // A directory this project does not have is not an error: the list is
+            // the framework's conventional layout, not a requirement.
+        }
+    }
+    for (const file of options.files) {
+        const absolute = resolve(options.root, file);
+        try {
+            watchers.push(watch(absolute, () => report(absolute)));
+        }
+        catch {
+            // Same: a `.env` that does not exist is simply not watched.
+        }
+    }
+    return {
+        close: () => {
+            for (const timer of pending.values())
+                clearTimeout(timer);
+            pending.clear();
+            for (const watcher of watchers)
+                watcher.close();
+        },
+    };
+}
+//# sourceMappingURL=hotWatcher.js.map

package/dist/dev/hotWatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotWatcher.js","sourceRoot":"","sources":["../../src/dev/hotWatcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAkB,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/C,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAEzC,0EAA0E;AAC1E,MAAM,SAAS,GAAG,EAAE,CAAA;AAiBpB,MAAM,UAAU,YAAY,CAAC,OAAuB;IAClD,MAAM,QAAQ,GAAgB,EAAE,CAAA;IAChC,MAAM,OAAO,GAAG,IAAI,GAAG,EAA0B,CAAA;IAEjD,MAAM,MAAM,GAAG,CAAC,IAAY,EAAQ,EAAE;QACpC,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAClC,IAAI,QAAQ,KAAK,SAAS;YAAE,YAAY,CAAC,QAAQ,CAAC,CAAA;QAClD,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;YAC5B,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;YACpB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;QACxB,CAAC,EAAE,SAAS,CAAC,CAAA;QACb,sEAAsE;QACtE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAA;QACf,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;IAC1B,CAAC,CAAA;IAED,KAAK,MAAM,SAAS,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;QAC5C,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,SAAS,CAAC,CAAA;QACjD,IAAI,CAAC;YACH,QAAQ,CAAC,IAAI,CACX,KAAK,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE;gBACpD,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,EAAE;oBAAE,OAAM;gBACnD,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAA;YAC9B,CAAC,CAAC,CACH,CAAA;QACH,CAAC;QAAC,MAAM,CAAC;YACP,sEAAsE;YACtE,0DAA0D;QAC5D,CAAC;IACH,CAAC;IAED,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;QACjC,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;QAC5C,IAAI,CAAC;YACH,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAA;QACxD,CAAC;QAAC,MAAM,CAAC;YACP,4DAA4D;QAC9D,CAAC;IACH,CAAC;IAED,OAAO;QACL,KAAK,EAAE,GAAG,EAAE;YACV,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,MAAM,EAAE;gBAAE,YAAY,CAAC,KAAK,CAAC,CAAA;YACzD,OAAO,CAAC,KAAK,EAAE,CAAA;YACf,KAAK,MAAM,OAAO,IAAI,QAAQ;gBAAE,OAAO,CAAC,KAAK,EAAE,CAAA;QACjD,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/env/loadEnvFiles.d.ts

@@ -1,3 +1,16 @@
+/**
+ * The `.env*` files that will be read, most-specific first.
+ *
+ * Exported because `@c9up/ream/hot` has to WATCH exactly this list: nothing
+ * imports an env file, so hot-hook's dependency tree never sees one and an
+ * edit to `.env` changed nothing at all. A second copy of the list in the
+ * loader entry would drift from this one the first time the naming changes.
+ *
+ * @param options.skipEnvLocal Skip `.env.local` — see {@link loadEnvFiles}.
+ */
+export declare function envFileNames(options?: {
+    skipEnvLocal?: boolean;
+}): string[];
 /**
  * Load `.env` files into `process.env` — the shared primitive behind both the
  * Ignitor (HTTP/console boot) and `Env.create()` (config/test flow), mirroring

package/dist/env/loadEnvFiles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loadEnvFiles.d.ts","sourceRoot":"","sources":["../../src/env/loadEnvFiles.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,IAAI,CAgCzF"}
+{"version":3,"file":"loadEnvFiles.d.ts","sourceRoot":"","sources":["../../src/env/loadEnvFiles.ts"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,MAAM,EAAE,CAW/E;AA4BD;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,IAAI,CAsCzF"}