@kensio/yulin 1.6.1 → 1.8.0

package/dist/serve/http/live-reload/sim-live-reload.js

@@ -0,0 +1,84 @@
+import { randomUUID } from "node:crypto";
+import { SimLiveReloadClient } from "./sim-live-reload-client.js";
+import { SimLiveReloadInjector } from "./sim-live-reload-injector.js";
+import { simLiveReloadConfig } from "./sim-live-reload.config.js";
+/**
+ * Reloads a browser looking at a page the simulator served.
+ *
+ * Yulin is the only thing in the response path for a page served from a
+ * simulated distribution, Function URL or Bucket website, so it is the only
+ * thing that can tell the browser to reload. Pages get a script, the script
+ * holds a connection open, and this is the end that decides what to say on it.
+ *
+ * The boot id is what makes a restart work. It identifies this process to the
+ * pages connected to it, and a page that reconnects to a different one knows
+ * it is looking at output from a process that is no longer running.
+ */
+export class SimLiveReload {
+    bootId;
+    clients = new Set();
+    injector = new SimLiveReloadInjector();
+    constructor(properties = {}) {
+        const { bootId = randomUUID() } = properties;
+        this.bootId = bootId;
+    }
+    /**
+     * Whether this request is for the reload channel rather than for a simulated
+     * service. The path is reserved on every served hostname, so a page can ask
+     * for it relative to wherever it was served from.
+     */
+    isChannelRequest(request) {
+        if (request.method !== "GET") {
+            return false;
+        }
+        const path = new URL(request.url ?? "/", "http://sim-aws.invalid").pathname.replace(/\/$/, "");
+        return path === simLiveReloadConfig.channelPath;
+    }
+    /**
+     * Open the reload channel for a browser, and tell it which process it has
+     * reached.
+     */
+    connect(response) {
+        const client = new SimLiveReloadClient(response);
+        this.clients.add(client);
+        client.onClose(() => {
+            this.clients.delete(client);
+        });
+        client.open();
+        client.send("boot", this.bootId);
+    }
+    /**
+     * Put the reload script into a response, if that response can take it.
+     */
+    async injectInto(request, response) {
+        return this.injector.injectInto(request, response);
+    }
+    /**
+     * Reload every connected browser now.
+     */
+    reload() {
+        this.send("reload");
+    }
+    /**
+     * Say a reload is coming, then let the connections go.
+     *
+     * The page learns that the gap it is about to see is a restart rather than a
+     * server that has died. Ending the connections rather than leaving them for
+     * the browser to notice is what makes the reconnection prompt.
+     *
+     * Resolves once the connections have gone, so a caller closing a server has
+     * something to wait for before destroying sockets or leaving the process.
+     */
+    async stopping() {
+        this.send("reloading");
+        const leaving = [...this.clients];
+        this.clients.clear();
+        await Promise.all(leaving.map((client) => client.end()));
+    }
+    send(event) {
+        for (const client of this.clients) {
+            client.send(event, this.bootId);
+        }
+    }
+}
+//# sourceMappingURL=sim-live-reload.js.map

package/dist/serve/http/live-reload/sim-live-reload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-live-reload.js","sourceRoot":"","sources":["../../../../src/serve/http/live-reload/sim-live-reload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAMlE;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,aAAa;IACP,MAAM,CAAS;IACf,OAAO,GAAG,IAAI,GAAG,EAAuB,CAAC;IACzC,QAAQ,GAAG,IAAI,qBAAqB,EAAE,CAAC;IAExD,YAAY,UAAU,GAA4B,EAAE;QAClD,MAAM,EAAE,MAAM,GAAG,UAAU,EAAE,EAAE,GAAG,UAAU,CAAC;QAC7C,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;;;OAIG;IACH,gBAAgB,CAAC,OAAwB;QACvC,IAAI,OAAO,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;YAC7B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,IAAI,GAAG,IAAI,GAAG,CAClB,OAAO,CAAC,GAAG,IAAI,GAAG,EAClB,wBAAwB,CACzB,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAE9B,OAAO,IAAI,KAAK,mBAAmB,CAAC,WAAW,CAAC;IAClD,CAAC;IAED;;;OAGG;IACH,OAAO,CAAC,QAAwB;QAC9B,MAAM,MAAM,GAAG,IAAI,mBAAmB,CAAC,QAAQ,CAAC,CAAC;QAEjD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACzB,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE;YAClB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC9B,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,IAAI,EAAE,CAAC;QACd,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,UAAU,CAAC,OAAgB,EAAE,QAAkB;QACnD,OAAO,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IACrD,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACtB,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,QAAQ;QACZ,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAEvB,MAAM,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;QAClC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QAErB,MAAM,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IAC3D,CAAC;IAEO,IAAI,CAAC,KAAa;QACxB,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAClC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;CACF"}

package/dist/serve/http/live-reload/sim-local-live-reload.d.ts

@@ -0,0 +1,55 @@
+import { SimLiveReload } from "./sim-live-reload.js";
+import { type SimWatchRuntime } from "../../../watch/sim-watch-runtime.js";
+interface SimLocalLiveReloadProperties {
+    readonly enabled: boolean;
+    readonly watch?: SimWatchRuntime;
+}
+/**
+ * Live reload as the local server has to hold it: on or off, and wired into the
+ * server's own lifecycle either way.
+ *
+ * Keeping it here leaves `SimAwsLocalServer` with sockets and ports, which is
+ * enough for one class, and puts the three things that only matter together in
+ * one place: whether it is on, the notice given on startup, and the warning
+ * from a `yulin watch` supervisor that the process is about to be replaced.
+ */
+export declare class SimLocalLiveReload {
+    private readonly liveReload;
+    private readonly watch;
+    private readonly onSupervisorStopping;
+    constructor(properties: SimLocalLiveReloadProperties);
+    /**
+     * The channel to hand to the request handler, if there is one.
+     */
+    channel(): SimLiveReload | undefined;
+    /**
+     * Say live reload is on, and start listening for a supervised restart.
+     *
+     * Under `yulin watch` the process is killed rather than asked to close, so
+     * this is where a served page finds out a restart is coming.
+     */
+    serving(port: string): void;
+    /**
+     * Tell connected browsers a reload is coming, and stop listening.
+     *
+     * Resolves once those browsers have had it, so the server can go on to
+     * destroy what is left of its connections.
+     */
+    stopping(): Promise<void>;
+    /**
+     * Reload connected browsers now.
+     */
+    reload(): void;
+    /**
+     * Give now the refusal a reload would be given later, if there is one.
+     *
+     * For anything handed this server to reload for it, such as a watched
+     * template file. A server serving without live reload can never reload, and
+     * the refusal is worth having where the mistake was made rather than on the
+     * first change, long after.
+     */
+    checkReload(): void;
+    private reloadChannel;
+}
+export {};
+//# sourceMappingURL=sim-local-live-reload.d.ts.map

package/dist/serve/http/live-reload/sim-local-live-reload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-local-live-reload.d.ts","sourceRoot":"","sources":["../../../../src/serve/http/live-reload/sim-local-live-reload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,qCAAqC,CAAC;AAE7C,UAAU,4BAA4B;IACpC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe,CAAC;CAClC;AAED;;;;;;;;GAQG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA4B;IACvD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkB;IAKxC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAEnC;IAEF,YAAY,UAAU,EAAE,4BAA4B,EAInD;IAED;;OAEG;IACH,OAAO,IAAI,aAAa,GAAG,SAAS,CAEnC;IAED;;;;;OAKG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAO1B;IAED;;;;;OAKG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAG9B;IAED;;OAEG;IACH,MAAM,IAAI,IAAI,CAEb;IAED;;;;;;;OAOG;IACH,WAAW,IAAI,IAAI,CAElB;IAED,OAAO,CAAC,aAAa;CAStB"}

package/dist/serve/http/live-reload/sim-local-live-reload.js

@@ -0,0 +1,80 @@
+import { SimLiveReload } from "./sim-live-reload.js";
+import { SimLiveReloadReport } from "./sim-live-reload-report.js";
+import { simWatch, } from "../../../watch/sim-watch-runtime.js";
+/**
+ * Live reload as the local server has to hold it: on or off, and wired into the
+ * server's own lifecycle either way.
+ *
+ * Keeping it here leaves `SimAwsLocalServer` with sockets and ports, which is
+ * enough for one class, and puts the three things that only matter together in
+ * one place: whether it is on, the notice given on startup, and the warning
+ * from a `yulin watch` supervisor that the process is about to be replaced.
+ */
+export class SimLocalLiveReload {
+    liveReload;
+    watch;
+    // The supervisor has its own handshake for waiting: it holds off killing the
+    // process until this one says it has stopped, which it does once the
+    // listeners have run. So the writes go out here and nothing waits on them.
+    onSupervisorStopping = () => {
+        void this.liveReload?.stopping();
+    };
+    constructor(properties) {
+        const { enabled, watch = simWatch } = properties;
+        this.liveReload = enabled ? new SimLiveReload() : undefined;
+        this.watch = watch;
+    }
+    /**
+     * The channel to hand to the request handler, if there is one.
+     */
+    channel() {
+        return this.liveReload;
+    }
+    /**
+     * Say live reload is on, and start listening for a supervised restart.
+     *
+     * Under `yulin watch` the process is killed rather than asked to close, so
+     * this is where a served page finds out a restart is coming.
+     */
+    serving(port) {
+        if (this.liveReload === undefined) {
+            return;
+        }
+        new SimLiveReloadReport().announce(port);
+        this.watch.onStopping(this.onSupervisorStopping);
+    }
+    /**
+     * Tell connected browsers a reload is coming, and stop listening.
+     *
+     * Resolves once those browsers have had it, so the server can go on to
+     * destroy what is left of its connections.
+     */
+    async stopping() {
+        this.watch.offStopping(this.onSupervisorStopping);
+        await this.liveReload?.stopping();
+    }
+    /**
+     * Reload connected browsers now.
+     */
+    reload() {
+        this.reloadChannel().reload();
+    }
+    /**
+     * Give now the refusal a reload would be given later, if there is one.
+     *
+     * For anything handed this server to reload for it, such as a watched
+     * template file. A server serving without live reload can never reload, and
+     * the refusal is worth having where the mistake was made rather than on the
+     * first change, long after.
+     */
+    checkReload() {
+        this.reloadChannel();
+    }
+    reloadChannel() {
+        if (this.liveReload === undefined) {
+            throw new Error("Live reload is off for this server, serve with { liveReload: true } to use reload()");
+        }
+        return this.liveReload;
+    }
+}
+//# sourceMappingURL=sim-local-live-reload.js.map

package/dist/serve/http/live-reload/sim-local-live-reload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-local-live-reload.js","sourceRoot":"","sources":["../../../../src/serve/http/live-reload/sim-local-live-reload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EACL,QAAQ,GAET,MAAM,qCAAqC,CAAC;AAO7C;;;;;;;;GAQG;AACH,MAAM,OAAO,kBAAkB;IACZ,UAAU,CAA4B;IACtC,KAAK,CAAkB;IAExC,6EAA6E;IAC7E,qEAAqE;IACrE,2EAA2E;IAC1D,oBAAoB,GAAG,GAAS,EAAE;QACjD,KAAK,IAAI,CAAC,UAAU,EAAE,QAAQ,EAAE,CAAC;IACnC,CAAC,CAAC;IAEF,YAAY,UAAwC;QAClD,MAAM,EAAE,OAAO,EAAE,KAAK,GAAG,QAAQ,EAAE,GAAG,UAAU,CAAC;QACjD,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,CAAC,CAAC,IAAI,aAAa,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;QAC5D,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED;;OAEG;IACH,OAAO;QACL,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED;;;;;OAKG;IACH,OAAO,CAAC,IAAY;QAClB,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;YAClC,OAAO;QACT,CAAC;QAED,IAAI,mBAAmB,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACzC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IACnD,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,QAAQ;QACZ,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAClD,MAAM,IAAI,CAAC,UAAU,EAAE,QAAQ,EAAE,CAAC;IACpC,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,IAAI,CAAC,aAAa,EAAE,CAAC,MAAM,EAAE,CAAC;IAChC,CAAC;IAED;;;;;;;OAOG;IACH,WAAW;QACT,IAAI,CAAC,aAAa,EAAE,CAAC;IACvB,CAAC;IAEO,aAAa;QACnB,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CACb,qFAAqF,CACtF,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;CACF"}

package/dist/serve/http/local-server/node-server-port-binder.d.ts

@@ -0,0 +1,39 @@
+import type { Server } from "node:http";
+interface NodeServerPortBinderProperties {
+    readonly server: Server;
+    readonly address?: string;
+    readonly waitMs?: number;
+    readonly waitIntervalMs?: number;
+}
+/**
+ * Binds a Node HTTP server to a port, waiting out a port that is still held.
+ *
+ * Restarting local development overlaps the process being replaced: the
+ * outgoing one is still letting go of its listening socket while the incoming
+ * one asks for the same number. Giving up on the first `EADDRINUSE` makes that
+ * overlap fatal and loses the pinned port, so the bind is retried for a short
+ * bounded period first. The bound is finite because a port held by an unrelated
+ * process is never going to come free, and waiting forever would hide that.
+ */
+export declare class NodeServerPortBinder {
+    private readonly server;
+    private readonly address;
+    private readonly waitMs;
+    private readonly waitIntervalMs;
+    constructor(properties: NodeServerPortBinderProperties);
+    /**
+     * Start listening on the given port, waiting briefly for another listener to
+     * release it. Port zero asks the operating system for a free port, so it
+     * never waits.
+     */
+    bind(port: number): Promise<void>;
+    /**
+     * Try to bind once, and try again later if the port is only busy for now.
+     *
+     * A listen that failed leaves the server without a handle, so a later attempt
+     * is an ordinary fresh listen on the same server rather than a reopening.
+     */
+    private attempt;
+}
+export {};
+//# sourceMappingURL=node-server-port-binder.d.ts.map

package/dist/serve/http/local-server/node-server-port-binder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-server-port-binder.d.ts","sourceRoot":"","sources":["../../../../src/serve/http/local-server/node-server-port-binder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAKxC,UAAU,8BAA8B;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED;;;;;;;;;GASG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IAExC,YAAY,UAAU,EAAE,8BAA8B,EAWrD;IAED;;;;OAIG;IACG,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEtC;IAED;;;;;OAKG;YACW,OAAO;CAiBtB"}

package/dist/serve/http/local-server/node-server-port-binder.js

@@ -0,0 +1,71 @@
+import { simAwsLocalConfig } from "./sim-aws-local.config.js";
+import { SimAwsLocalPortInUse } from "./sim-aws-local-port.error.js";
+import { waitNodeServerListen } from "./wait-node-server-listen.js";
+/**
+ * Binds a Node HTTP server to a port, waiting out a port that is still held.
+ *
+ * Restarting local development overlaps the process being replaced: the
+ * outgoing one is still letting go of its listening socket while the incoming
+ * one asks for the same number. Giving up on the first `EADDRINUSE` makes that
+ * overlap fatal and loses the pinned port, so the bind is retried for a short
+ * bounded period first. The bound is finite because a port held by an unrelated
+ * process is never going to come free, and waiting forever would hide that.
+ */
+export class NodeServerPortBinder {
+    server;
+    address;
+    waitMs;
+    waitIntervalMs;
+    constructor(properties) {
+        const { server, address = simAwsLocalConfig.loopbackAddress, waitMs = simAwsLocalConfig.portWaitMs, waitIntervalMs = simAwsLocalConfig.portWaitIntervalMs, } = properties;
+        this.server = server;
+        this.address = address;
+        this.waitMs = waitMs;
+        this.waitIntervalMs = waitIntervalMs;
+    }
+    /**
+     * Start listening on the given port, waiting briefly for another listener to
+     * release it. Port zero asks the operating system for a free port, so it
+     * never waits.
+     */
+    async bind(port) {
+        await this.attempt(port, Date.now() + this.waitMs);
+    }
+    /**
+     * Try to bind once, and try again later if the port is only busy for now.
+     *
+     * A listen that failed leaves the server without a handle, so a later attempt
+     * is an ordinary fresh listen on the same server rather than a reopening.
+     */
+    async attempt(port, giveUpAt) {
+        try {
+            this.server.listen(port, this.address);
+            await waitNodeServerListen(this.server);
+        }
+        catch (error) {
+            if (!isPortInUse(error)) {
+                throw error;
+            }
+            if (Date.now() >= giveUpAt) {
+                throw new SimAwsLocalPortInUse(port, this.waitMs);
+            }
+            await pause(this.waitIntervalMs);
+            await this.attempt(port, giveUpAt);
+        }
+    }
+}
+/**
+ * Recognise the one listen failure that is worth waiting out.
+ */
+function isPortInUse(error) {
+    return (error instanceof Error && "code" in error && error.code === "EADDRINUSE");
+}
+/**
+ * Wait before the next attempt.
+ */
+async function pause(milliseconds) {
+    await new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
+    });
+}
+//# sourceMappingURL=node-server-port-binder.js.map

package/dist/serve/http/local-server/node-server-port-binder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-server-port-binder.js","sourceRoot":"","sources":["../../../../src/serve/http/local-server/node-server-port-binder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AASpE;;;;;;;;;GASG;AACH,MAAM,OAAO,oBAAoB;IACd,MAAM,CAAS;IACf,OAAO,CAAS;IAChB,MAAM,CAAS;IACf,cAAc,CAAS;IAExC,YAAY,UAA0C;QACpD,MAAM,EACJ,MAAM,EACN,OAAO,GAAG,iBAAiB,CAAC,eAAe,EAC3C,MAAM,GAAG,iBAAiB,CAAC,UAAU,EACrC,cAAc,GAAG,iBAAiB,CAAC,kBAAkB,GACtD,GAAG,UAAU,CAAC;QACf,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACvC,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,IAAI,CAAC,IAAY;QACrB,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IACrD,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,OAAO,CAAC,IAAY,EAAE,QAAgB;QAClD,IAAI,CAAC;YACH,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;YACvC,MAAM,oBAAoB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC1C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;gBACxB,MAAM,KAAK,CAAC;YACd,CAAC;YAED,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,QAAQ,EAAE,CAAC;gBAC3B,MAAM,IAAI,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;YACpD,CAAC;YAED,MAAM,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YACjC,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACrC,CAAC;IACH,CAAC;CACF;AAED;;GAEG;AACH,SAAS,WAAW,CAAC,KAAc;IACjC,OAAO,CACL,KAAK,YAAY,KAAK,IAAI,MAAM,IAAI,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,CACzE,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,KAAK,CAAC,YAAoB;IACvC,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC5B,UAAU,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;IACpC,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/serve/http/local-server/node-server-port.d.ts

@@ -0,0 +1,10 @@
+import type { Server } from "node:http";
+/**
+ * Read the TCP port a Node server took.
+ *
+ * A server that has not started listening has no port, and one listening on a
+ * Unix socket has an address that is not a port at all. Neither is a number to
+ * return, so both are refused rather than guessed at.
+ */
+export declare function nodeServerPort(server: Server): string;
+//# sourceMappingURL=node-server-port.d.ts.map

package/dist/serve/http/local-server/node-server-port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-server-port.d.ts","sourceRoot":"","sources":["../../../../src/serve/http/local-server/node-server-port.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAarD"}

package/dist/serve/http/local-server/node-server-port.js

@@ -0,0 +1,19 @@
+/**
+ * Read the TCP port a Node server took.
+ *
+ * A server that has not started listening has no port, and one listening on a
+ * Unix socket has an address that is not a port at all. Neither is a number to
+ * return, so both are refused rather than guessed at.
+ */
+export function nodeServerPort(server) {
+    if (!server.listening) {
+        throw new Error("Server is not yet listening, cannot get port number");
+    }
+    const address = server.address();
+    /* v8 ignore if -- does not happen in practice */
+    if (address === null || typeof address === "string") {
+        throw new Error("Expected local HTTP server to listen on a TCP port");
+    }
+    return String(address.port);
+}
+//# sourceMappingURL=node-server-port.js.map

package/dist/serve/http/local-server/node-server-port.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-server-port.js","sourceRoot":"","sources":["../../../../src/serve/http/local-server/node-server-port.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,MAAc;IAC3C,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;IACzE,CAAC;IAED,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC;IAEjC,iDAAiD;IACjD,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;QACpD,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;IACxE,CAAC;IAED,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAC9B,CAAC"}

package/dist/serve/http/local-server/sim-aws-local-port.error.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Thrown when a port stays held by another listener for the whole wait.
+ *
+ * A local development restart usually overlaps the process it replaces, so a
+ * pinned port being busy for a moment is expected and is waited out. Still
+ * being busy at the end of that wait means something else owns the port, which
+ * no amount of further waiting will fix.
+ */
+export declare class SimAwsLocalPortInUse extends Error {
+    readonly name = "SimAwsLocalPortInUse";
+    constructor(port: number, waitedMs: number);
+}
+//# sourceMappingURL=sim-aws-local-port.error.d.ts.map

package/dist/serve/http/local-server/sim-aws-local-port.error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-aws-local-port.error.d.ts","sourceRoot":"","sources":["../../../../src/serve/http/local-server/sim-aws-local-port.error.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,SAAyB,IAAI,0BAA0B;IAEvD,YAAY,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAKzC;CACF"}

package/dist/serve/http/local-server/sim-aws-local-port.error.js

@@ -0,0 +1,16 @@
+/**
+ * Thrown when a port stays held by another listener for the whole wait.
+ *
+ * A local development restart usually overlaps the process it replaces, so a
+ * pinned port being busy for a moment is expected and is waited out. Still
+ * being busy at the end of that wait means something else owns the port, which
+ * no amount of further waiting will fix.
+ */
+export class SimAwsLocalPortInUse extends Error {
+    name = "SimAwsLocalPortInUse";
+    constructor(port, waitedMs) {
+        super(`Port ${String(port)} is held by another listener. ` +
+            `It was still held after waiting ${String(waitedMs)}ms for it to be released.`);
+    }
+}
+//# sourceMappingURL=sim-aws-local-port.error.js.map

package/dist/serve/http/local-server/sim-aws-local-port.error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-aws-local-port.error.js","sourceRoot":"","sources":["../../../../src/serve/http/local-server/sim-aws-local-port.error.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IACpB,IAAI,GAAG,sBAAsB,CAAC;IAEvD,YAAY,IAAY,EAAE,QAAgB;QACxC,KAAK,CACH,QAAQ,MAAM,CAAC,IAAI,CAAC,gCAAgC;YAClD,mCAAmC,MAAM,CAAC,QAAQ,CAAC,2BAA2B,CACjF,CAAC;IACJ,CAAC;CACF"}

package/dist/serve/http/local-server/sim-aws-local-request-handler.d.ts

@@ -1,5 +1,10 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { SimAwsHttp } from "../sim-aws-http.js";
+import type { SimLiveReload } from "../live-reload/sim-live-reload.js";
+interface SimAwsLocalRequestHandlerProperties {
+    readonly simAwsHttp: SimAwsHttp;
+    readonly liveReload?: SimLiveReload;
+}
 /**
  * Bridges Node's HTTP server callbacks to the Fetch-shaped simulated AWS HTTP
  * interface.
@@ -7,17 +12,25 @@ import type { SimAwsHttp } from "../sim-aws-http.js";
  * Node hands over a request and a response object and expects nothing back,
  * while `SimAwsHttp` takes a `Request` and returns a `Response`. Keeping that
  * adaptation here leaves the local server owning only the socket lifecycle.
+ *
+ * Live reload sits either side of `SimAwsHttp` rather than inside it. That
+ * interface is also the SDK interception path and the in-process test path, so
+ * keeping the reload channel and the injected script out here means only a real
+ * browser talking to the local server ever sees either of them.
  */
 export declare class SimAwsLocalRequestHandler {
     private readonly simAwsHttp;
+    private readonly liveReload;
     private readonly nodeFetchHttpAdapter;
-    constructor(simAwsHttp: SimAwsHttp);
+    constructor(properties: SimAwsLocalRequestHandlerProperties);
     /**
      * Handle one Node HTTP request, reporting any failure on the response rather
      * than letting it escape into an unhandled rejection.
      */
     handle(nodeRequest: IncomingMessage, nodeResponse: ServerResponse): void;
     private respond;
+    private served;
     private respondWithError;
 }
+export {};
 //# sourceMappingURL=sim-aws-local-request-handler.d.ts.map

package/dist/serve/http/local-server/sim-aws-local-request-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sim-aws-local-request-handler.d.ts","sourceRoot":"","sources":["../../../../src/serve/http/local-server/sim-aws-local-request-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEjE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;GAOG;AACH,qBAAa,yBAAyB;IACpC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA8B;IAEnE,YAAY,UAAU,EAAE,UAAU,EAEjC;IAED;;;OAGG;IACH,MAAM,CAAC,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,cAAc,GAAG,IAAI,CAKvE;YAEa,OAAO;IAWrB,OAAO,CAAC,gBAAgB;CAgBzB"}
+{"version":3,"file":"sim-aws-local-request-handler.d.ts","sourceRoot":"","sources":["../../../../src/serve/http/local-server/sim-aws-local-request-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEjE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAEvE,UAAU,mCAAmC;IAC3C,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,UAAU,CAAC,EAAE,aAAa,CAAC;CACrC;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,yBAAyB;IACpC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA4B;IACvD,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA8B;IAEnE,YAAY,UAAU,EAAE,mCAAmC,EAI1D;IAED;;;OAGG;IACH,MAAM,CAAC,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,cAAc,GAAG,IAAI,CAUvE;YAEa,OAAO;YAcP,MAAM;IAWpB,OAAO,CAAC,gBAAgB;CAgBzB"}

package/dist/serve/http/local-server/sim-aws-local-request-handler.js

@@ -6,18 +6,30 @@ import { NodeFetchHttpAdapter } from "../node-fetch-http-adapter.js";
  * Node hands over a request and a response object and expects nothing back,
  * while `SimAwsHttp` takes a `Request` and returns a `Response`. Keeping that
  * adaptation here leaves the local server owning only the socket lifecycle.
+ *
+ * Live reload sits either side of `SimAwsHttp` rather than inside it. That
+ * interface is also the SDK interception path and the in-process test path, so
+ * keeping the reload channel and the injected script out here means only a real
+ * browser talking to the local server ever sees either of them.
  */
 export class SimAwsLocalRequestHandler {
     simAwsHttp;
+    liveReload;
     nodeFetchHttpAdapter = new NodeFetchHttpAdapter();
-    constructor(simAwsHttp) {
+    constructor(properties) {
+        const { simAwsHttp, liveReload } = properties;
         this.simAwsHttp = simAwsHttp;
+        this.liveReload = liveReload;
     }
     /**
      * Handle one Node HTTP request, reporting any failure on the response rather
      * than letting it escape into an unhandled rejection.
      */
     handle(nodeRequest, nodeResponse) {
+        if (this.liveReload?.isChannelRequest(nodeRequest) === true) {
+            this.liveReload.connect(nodeResponse);
+            return;
+        }
         // eslint-disable-next-line unicorn/prefer-await
         this.respond(nodeRequest, nodeResponse).catch((error) => {
             this.respondWithError(error, nodeResponse);
@@ -26,7 +38,13 @@ export class SimAwsLocalRequestHandler {
     async respond(nodeRequest, nodeResponse) {
         const request = this.nodeFetchHttpAdapter.nodeRequestToFetchRequest(nodeRequest);
         const response = await this.simAwsHttp.handleRequest(request);
-        await this.nodeFetchHttpAdapter.sendFetchResponse(nodeResponse, response);
+        await this.nodeFetchHttpAdapter.sendFetchResponse(nodeResponse, await this.served(request, response));
+    }
+    async served(request, response) {
+        if (this.liveReload === undefined) {
+            return response;
+        }
+        return this.liveReload.injectInto(request, response);
     }
     respondWithError(error, nodeResponse) {
         /* v8 ignore if */

package/dist/serve/http/local-server/sim-aws-local-request-handler.js.map

@@ -1 +1 @@
-{"version":3,"file":"sim-aws-local-request-handler.js","sourceRoot":"","sources":["../../../../src/serve/http/local-server/sim-aws-local-request-handler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAGrE;;;;;;;GAOG;AACH,MAAM,OAAO,yBAAyB;IACnB,UAAU,CAAa;IACvB,oBAAoB,GAAG,IAAI,oBAAoB,EAAE,CAAC;IAEnE,YAAY,UAAsB;QAChC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IAC/B,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,WAA4B,EAAE,YAA4B;QAC/D,gDAAgD;QAChD,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;YAC/D,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;QAC7C,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,OAAO,CACnB,WAA4B,EAC5B,YAA4B;QAE5B,MAAM,OAAO,GACX,IAAI,CAAC,oBAAoB,CAAC,yBAAyB,CAAC,WAAW,CAAC,CAAC;QACnE,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAE9D,MAAM,IAAI,CAAC,oBAAoB,CAAC,iBAAiB,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;IAC5E,CAAC;IAEO,gBAAgB,CAAC,KAAc,EAAE,YAA4B;QACnE,kBAAkB;QAClB,IAAI,YAAY,CAAC,aAAa,EAAE,CAAC;YAC/B,OAAO;QACT,CAAC;QAED,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC;YAC9B,YAAY,CAAC,UAAU,GAAG,GAAG,CAAC;YAC9B,YAAY,CAAC,SAAS,CAAC,cAAc,EAAE,2BAA2B,CAAC,CAAC;QACtE,CAAC;QAED,MAAM,OAAO,GACX,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,gCAAgC,CAAC;QAE5E,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC5B,CAAC;CACF"}
+{"version":3,"file":"sim-aws-local-request-handler.js","sourceRoot":"","sources":["../../../../src/serve/http/local-server/sim-aws-local-request-handler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AASrE;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,yBAAyB;IACnB,UAAU,CAAa;IACvB,UAAU,CAA4B;IACtC,oBAAoB,GAAG,IAAI,oBAAoB,EAAE,CAAC;IAEnE,YAAY,UAA+C;QACzD,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,UAAU,CAAC;QAC9C,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IAC/B,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,WAA4B,EAAE,YAA4B;QAC/D,IAAI,IAAI,CAAC,UAAU,EAAE,gBAAgB,CAAC,WAAW,CAAC,KAAK,IAAI,EAAE,CAAC;YAC5D,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;YACtC,OAAO;QACT,CAAC;QAED,gDAAgD;QAChD,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;YAC/D,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;QAC7C,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,OAAO,CACnB,WAA4B,EAC5B,YAA4B;QAE5B,MAAM,OAAO,GACX,IAAI,CAAC,oBAAoB,CAAC,yBAAyB,CAAC,WAAW,CAAC,CAAC;QACnE,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAE9D,MAAM,IAAI,CAAC,oBAAoB,CAAC,iBAAiB,CAC/C,YAAY,EACZ,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,CACrC,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,MAAM,CAClB,OAAgB,EAChB,QAAkB;QAElB,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;YAClC,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED,OAAO,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IACvD,CAAC;IAEO,gBAAgB,CAAC,KAAc,EAAE,YAA4B;QACnE,kBAAkB;QAClB,IAAI,YAAY,CAAC,aAAa,EAAE,CAAC;YAC/B,OAAO;QACT,CAAC;QAED,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC;YAC9B,YAAY,CAAC,UAAU,GAAG,GAAG,CAAC;YAC9B,YAAY,CAAC,SAAS,CAAC,cAAc,EAAE,2BAA2B,CAAC,CAAC;QACtE,CAAC;QAED,MAAM,OAAO,GACX,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,gCAAgC,CAAC;QAE5E,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC5B,CAAC;CACF"}

package/dist/serve/http/local-server/sim-aws-local-server.d.ts

@@ -1,15 +1,20 @@
 import { SimAws } from "../../../service/aws/sim-aws.js";
+import { type SimCloseOnSignalOptions } from "../../../util/process/close-on-signal.js";
 interface SimAwsLocalServerProperties {
     readonly simAws?: SimAws;
+    readonly liveReload?: boolean;
 }
 /**
  * Local HTTP server for a simulated AWS environment.
  * Useful for local integration testing and local development.
  */
 export declare class SimAwsLocalServer {
+    private readonly simAws;
     private readonly requestHandler;
     private readonly server;
+    private readonly portBinder;
     private readonly dnsServer;
+    private readonly liveReload;
     constructor(properties?: SimAwsLocalServerProperties);
     /**
      * Start serving simulated AWS services on localhost.
@@ -24,6 +29,9 @@ export declare class SimAwsLocalServer {
      * the resolver returns first, which is commonly `::1`. DNS answers with the
      * IPv4 loopback address, so binding it explicitly is what makes the address in
      * a DNS answer one that actually serves HTTP.
+     *
+     * A pinned port that is still held is waited for rather than refused, so a
+     * restart that overlaps the process it replaces still gets its port back.
      */
     listen(port?: number): Promise<this>;
     /**
@@ -44,8 +52,64 @@ export declare class SimAwsLocalServer {
     get dnsPort(): string;
     /**
      * Stop serving simulated AWS services.
+     *
+     * Open connections are ended rather than left to finish. Node's own close
+     * stops the server accepting and lets go of the connections that are idle,
+     * but one that is in use, which is what a browser part way through a request
+     * or a live reload stream holds, keeps its socket open and the process with
+     * it. Local development restarts on that process exiting, so the connections
+     * go.
+     *
+     * The environment being served goes with it, so the template file watches
+     * and mounted directory watches it holds are let go of here rather than in a
+     * second call the script has to know to make. Everything Yulin was holding
+     * open is released by this one call, and the simulated state it was serving
+     * is left exactly where it was.
+     *
+     * The order is what a browser needs. Both ports are let go first, so a
+     * replacement process can have them however long the rest takes. Then the
+     * environment, so a watch cannot answer a change while the server it would
+     * reload is going. Then the live reload streams are told a reload is coming
+     * and seen out, because a socket destroyed with bytes still in flight is
+     * reset, and a reset costs the browser the event it was just sent. Only what
+     * is left after that is destroyed.
+     *
+     * Await it to know the last event has gone before leaving the process.
+     */
+    close(): Promise<void>;
+    /**
+     * Close this server, and the environment it serves, when the process is
+     * signalled.
+     *
+     * Nothing installs a signal handler unless it is asked to, since a library
+     * taking over process signals gets in the way of whatever else the process is
+     * doing. Asking looks like this:
+     *
+     * ```typescript
+     * srv.closeOnSignal();
+     * ```
+     *
+     * `SIGINT` and `SIGTERM` unless other signals are named. What comes back
+     * takes the handlers off again, for a script that stops wanting them before
+     * the process ends.
+     */
+    closeOnSignal(options?: SimCloseOnSignalOptions): () => void;
+    /**
+     * Reload every browser connected to this server.
+     *
+     * For a change that needs no restart, such as new content in a simulated
+     * Bucket. A change to the code that built the environment needs the process
+     * to restart, and the pages reload themselves when it comes back.
+     */
+    reload(): void;
+    /**
+     * Give now the refusal a reload would be given later, if there is one.
+     *
+     * This is how something handed the server to reload for it, such as a
+     * watched template file, can refuse a server that was served without live
+     * reload as it is handed over rather than on the first change.
      */
-    close(): void;
+    checkReload(): void;
     /**
      * Adapt a simulated AWS URL for this local server instance.
      */
@@ -54,6 +118,7 @@ export declare class SimAwsLocalServer {
 interface ServeSimAwsProperties {
     readonly simAws?: SimAws;
     readonly port?: number;
+    readonly liveReload?: boolean;
 }
 /**
  * Serve a simulated AWS environment on localhost.