@kensio/yulin 1.6.1 → 1.8.0

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

@@ -0,0 +1,86 @@
+import { once } from "node:events";
+import { simLiveReloadConfig } from "./sim-live-reload.config.js";
+/**
+ * One browser holding a live reload connection open.
+ *
+ * Server-Sent Events rather than a WebSocket, because the browser reconnects on
+ * its own. That is what lets a reload survive the process restarting: the
+ * outgoing process has nothing to hand over, and the incoming one has nothing
+ * to pick up.
+ */
+export class SimLiveReloadClient {
+    response;
+    constructor(response) {
+        this.response = response;
+    }
+    /**
+     * Start the event stream, telling the browser how soon to come back.
+     */
+    open() {
+        this.response.writeHead(200, {
+            "content-type": "text/event-stream",
+            "cache-control": "no-store",
+            connection: "keep-alive",
+        });
+        this.write(`retry: ${String(simLiveReloadConfig.clientRetryMs)}\n\n`);
+    }
+    /**
+     * Send one named event.
+     */
+    send(event, data) {
+        this.write(`event: ${event}\ndata: ${data}\n\n`);
+    }
+    /**
+     * Finish the stream and see its connection out, so the browser reconnects
+     * rather than waiting on a connection nothing is going to answer on.
+     *
+     * Waiting is what makes the last event readable. A socket destroyed with
+     * bytes still in flight is reset rather than closed, and a reset tells the
+     * peer to throw away what it has received but not yet handed to the page,
+     * which is the event that was just written. Ending the socket puts a normal
+     * close after the bytes instead, and resolving once it has gone leaves the
+     * server nothing left to destroy.
+     */
+    async end() {
+        const { socket } = this.response;
+        if (!this.response.writableEnded) {
+            await new Promise((resolve) => {
+                this.response.end(resolve);
+            });
+        }
+        if (socket === null || socket.destroyed) {
+            return;
+        }
+        socket.end();
+        await this.closed(socket);
+    }
+    /**
+     * Run something when the browser goes away.
+     */
+    onClose(listener) {
+        this.response.on("close", listener);
+    }
+    /**
+     * Wait for a connection to go, giving up on a browser that is no longer
+     * answering rather than holding the process open for it.
+     */
+    async closed(socket) {
+        try {
+            await once(socket, "close", {
+                signal: AbortSignal.timeout(simLiveReloadConfig.stoppingCloseMs),
+            });
+        }
+        catch {
+            // Either the connection failed on its way out or the browser never
+            // answered. Nothing is owed to a page that is not there, and the server
+            // destroys whatever is left of the connection anyway.
+        }
+    }
+    write(chunk) {
+        if (this.response.writableEnded) {
+            return;
+        }
+        this.response.write(chunk);
+    }
+}
+//# sourceMappingURL=sim-live-reload-client.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-live-reload-client.js","sourceRoot":"","sources":["../../../../src/serve/http/live-reload/sim-live-reload-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAGnC,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE;;;;;;;GAOG;AACH,MAAM,OAAO,mBAAmB;IACb,QAAQ,CAAiB;IAE1C,YAAY,QAAwB;QAClC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,IAAI;QACF,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,EAAE;YAC3B,cAAc,EAAE,mBAAmB;YACnC,eAAe,EAAE,UAAU;YAC3B,UAAU,EAAE,YAAY;SACzB,CAAC,CAAC;QACH,IAAI,CAAC,KAAK,CAAC,UAAU,MAAM,CAAC,mBAAmB,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;IACxE,CAAC;IAED;;OAEG;IACH,IAAI,CAAC,KAAa,EAAE,IAAY;QAC9B,IAAI,CAAC,KAAK,CAAC,UAAU,KAAK,WAAW,IAAI,MAAM,CAAC,CAAC;IACnD,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,GAAG;QACP,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC;QAEjC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,CAAC;YACjC,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;gBAClC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YAC7B,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC;YACxC,OAAO;QACT,CAAC;QAED,MAAM,CAAC,GAAG,EAAE,CAAC;QAEb,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC5B,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,QAAoB;QAC1B,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IACtC,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,MAAM,CAAC,MAAc;QACjC,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE;gBAC1B,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,mBAAmB,CAAC,eAAe,CAAC;aACjE,CAAC,CAAC;QACL,CAAC;QAAC,MAAM,CAAC;YACP,mEAAmE;YACnE,wEAAwE;YACxE,sDAAsD;QACxD,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,KAAa;QACzB,IAAI,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,CAAC;YAChC,OAAO;QACT,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;CACF"}

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

@@ -0,0 +1,47 @@
+/**
+ * Decides whether a response can carry the live reload script.
+ *
+ * The simulator's own account of a request goes in headers and never in the
+ * body, so that a response keeps the shape the real service returns. Injecting
+ * a script breaks that rule, and these checks are what keep the breakage to the
+ * one case it is worth it for: an HTML page a browser is about to render.
+ *
+ * Everything else comes back untouched. An SDK reading an HTML Object out of a
+ * Bucket has to get the bytes that were stored, and a range or an encoded body
+ * cannot take an insertion at all.
+ */
+export declare class SimLiveReloadInjectable {
+    /**
+     * Whether the script belongs in this response.
+     */
+    allows(request: Request, response: Response): boolean;
+    private hasBody;
+    /**
+     * A partial response is a slice of a body, and a slice cannot take an
+     * insertion without the offsets the client already asked for going wrong.
+     */
+    private isWholeResponse;
+    /**
+     * The media type has to be `text/html` itself, not merely start with it, so a
+     * type such as `text/htmlx` is left alone. An encoded body would have to be
+     * decoded, changed and re-encoded, and the simulator has no reason to be in
+     * that business.
+     */
+    private isPlainHtml;
+    /**
+     * Something asking for HTML is something that will render it.
+     */
+    private isBrowserRequest;
+    /**
+     * A signature comes either in a header or, for a presigned URL, in the query
+     * string. A presigned URL is the one signed request a browser makes with an
+     * ordinary HTML `accept` header, which is what an address bar sends, so
+     * missing it would mean handing back an Object with bytes added to it.
+     */
+    private isSignedRequest;
+    /**
+     * An `x-amz-*` header is an AWS client talking, whether it signed or not.
+     */
+    private isSdkRequest;
+}
+//# sourceMappingURL=sim-live-reload-injectable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-live-reload-injectable.d.ts","sourceRoot":"","sources":["../../../../src/serve/http/live-reload/sim-live-reload-injectable.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;GAWG;AACH,qBAAa,uBAAuB;IAClC;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CASpD;IAED,OAAO,CAAC,OAAO;IAIf;;;OAGG;IACH,OAAO,CAAC,eAAe;IAIvB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAUnB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAMxB;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IASvB;;OAEG;IACH,OAAO,CAAC,YAAY;CAGrB"}

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

@@ -0,0 +1,86 @@
+const sigV4AuthorizationPrefix = "AWS4-HMAC-SHA256";
+const htmlContentType = "text/html";
+const awsNamePrefix = "x-amz-";
+/**
+ * Whether any of these header or query parameter names is an AWS one.
+ */
+function hasAwsPrefixed(names) {
+    for (const name of names) {
+        if (name.toLowerCase().startsWith(awsNamePrefix)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Decides whether a response can carry the live reload script.
+ *
+ * The simulator's own account of a request goes in headers and never in the
+ * body, so that a response keeps the shape the real service returns. Injecting
+ * a script breaks that rule, and these checks are what keep the breakage to the
+ * one case it is worth it for: an HTML page a browser is about to render.
+ *
+ * Everything else comes back untouched. An SDK reading an HTML Object out of a
+ * Bucket has to get the bytes that were stored, and a range or an encoded body
+ * cannot take an insertion at all.
+ */
+export class SimLiveReloadInjectable {
+    /**
+     * Whether the script belongs in this response.
+     */
+    allows(request, response) {
+        return (this.hasBody(request, response) &&
+            this.isWholeResponse(response) &&
+            this.isPlainHtml(response) &&
+            this.isBrowserRequest(request) &&
+            !this.isSignedRequest(request) &&
+            !this.isSdkRequest(request));
+    }
+    hasBody(request, response) {
+        return request.method !== "HEAD" && response.body !== null;
+    }
+    /**
+     * A partial response is a slice of a body, and a slice cannot take an
+     * insertion without the offsets the client already asked for going wrong.
+     */
+    isWholeResponse(response) {
+        return response.status !== 206;
+    }
+    /**
+     * The media type has to be `text/html` itself, not merely start with it, so a
+     * type such as `text/htmlx` is left alone. An encoded body would have to be
+     * decoded, changed and re-encoded, and the simulator has no reason to be in
+     * that business.
+     */
+    isPlainHtml(response) {
+        const contentType = response.headers.get("content-type") ?? "";
+        const [mediaType = ""] = contentType.split(";");
+        return (mediaType.trim().toLowerCase() === htmlContentType &&
+            !response.headers.has("content-encoding"));
+    }
+    /**
+     * Something asking for HTML is something that will render it.
+     */
+    isBrowserRequest(request) {
+        const accept = request.headers.get("accept") ?? "";
+        return accept.toLowerCase().includes(htmlContentType);
+    }
+    /**
+     * A signature comes either in a header or, for a presigned URL, in the query
+     * string. A presigned URL is the one signed request a browser makes with an
+     * ordinary HTML `accept` header, which is what an address bar sends, so
+     * missing it would mean handing back an Object with bytes added to it.
+     */
+    isSignedRequest(request) {
+        const authorization = request.headers.get("authorization") ?? "";
+        return (authorization.startsWith(sigV4AuthorizationPrefix) ||
+            hasAwsPrefixed(new URL(request.url).searchParams.keys()));
+    }
+    /**
+     * An `x-amz-*` header is an AWS client talking, whether it signed or not.
+     */
+    isSdkRequest(request) {
+        return hasAwsPrefixed(request.headers.keys());
+    }
+}
+//# sourceMappingURL=sim-live-reload-injectable.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-live-reload-injectable.js","sourceRoot":"","sources":["../../../../src/serve/http/live-reload/sim-live-reload-injectable.ts"],"names":[],"mappings":"AAAA,MAAM,wBAAwB,GAAG,kBAAkB,CAAC;AACpD,MAAM,eAAe,GAAG,WAAW,CAAC;AACpC,MAAM,aAAa,GAAG,QAAQ,CAAC;AAE/B;;GAEG;AACH,SAAS,cAAc,CAAC,KAA+B;IACrD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE,CAAC;YACjD,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,uBAAuB;IAClC;;OAEG;IACH,MAAM,CAAC,OAAgB,EAAE,QAAkB;QACzC,OAAO,CACL,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,QAAQ,CAAC;YAC/B,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC;YAC9B,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC;YAC1B,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC;YAC9B,CAAC,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC;YAC9B,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAC5B,CAAC;IACJ,CAAC;IAEO,OAAO,CAAC,OAAgB,EAAE,QAAkB;QAClD,OAAO,OAAO,CAAC,MAAM,KAAK,MAAM,IAAI,QAAQ,CAAC,IAAI,KAAK,IAAI,CAAC;IAC7D,CAAC;IAED;;;OAGG;IACK,eAAe,CAAC,QAAkB;QACxC,OAAO,QAAQ,CAAC,MAAM,KAAK,GAAG,CAAC;IACjC,CAAC;IAED;;;;;OAKG;IACK,WAAW,CAAC,QAAkB;QACpC,MAAM,WAAW,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC;QAC/D,MAAM,CAAC,SAAS,GAAG,EAAE,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAEhD,OAAO,CACL,SAAS,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,KAAK,eAAe;YAClD,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAC1C,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,gBAAgB,CAAC,OAAgB;QACvC,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QAEnD,OAAO,MAAM,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;IACxD,CAAC;IAED;;;;;OAKG;IACK,eAAe,CAAC,OAAgB;QACtC,MAAM,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;QAEjE,OAAO,CACL,aAAa,CAAC,UAAU,CAAC,wBAAwB,CAAC;YAClD,cAAc,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,CACzD,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,YAAY,CAAC,OAAgB;QACnC,OAAO,cAAc,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IAChD,CAAC;CACF"}

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

@@ -0,0 +1,22 @@
+/**
+ * Puts the live reload script into HTML on its way to a browser.
+ *
+ * The script goes in at the end of the document, so the page has parsed before
+ * a connection is opened. The bytes of the body change, so anything describing
+ * those bytes has to change with them: `content-length` is recomputed, and
+ * `etag` and `last-modified` are dropped rather than left describing the
+ * stored Object the page no longer is.
+ *
+ * An injected page is also not stored. A cached copy would outlive the reload
+ * it was injected for, and a page held in the browser cache is a page live
+ * reload cannot reach.
+ */
+export declare class SimLiveReloadInjector {
+    private readonly injectable;
+    /**
+     * Return the response a browser should get, injected if it can take it.
+     */
+    injectInto(request: Request, response: Response): Promise<Response>;
+    private inject;
+}
+//# sourceMappingURL=sim-live-reload-injector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-live-reload-injector.d.ts","sourceRoot":"","sources":["../../../../src/serve/http/live-reload/sim-live-reload-injector.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiC;IAE5D;;OAEG;IACG,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAMxE;YAEa,MAAM;CAgBrB"}

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

@@ -0,0 +1,72 @@
+import { SimLiveReloadInjectable } from "./sim-live-reload-injectable.js";
+import { simLiveReloadScriptTag } from "./sim-live-reload-script.js";
+import { simLiveReloadHeaderName } from "./sim-live-reload.config.js";
+/**
+ * Puts the live reload script into HTML on its way to a browser.
+ *
+ * The script goes in at the end of the document, so the page has parsed before
+ * a connection is opened. The bytes of the body change, so anything describing
+ * those bytes has to change with them: `content-length` is recomputed, and
+ * `etag` and `last-modified` are dropped rather than left describing the
+ * stored Object the page no longer is.
+ *
+ * An injected page is also not stored. A cached copy would outlive the reload
+ * it was injected for, and a page held in the browser cache is a page live
+ * reload cannot reach.
+ */
+export class SimLiveReloadInjector {
+    injectable = new SimLiveReloadInjectable();
+    /**
+     * Return the response a browser should get, injected if it can take it.
+     */
+    async injectInto(request, response) {
+        if (!this.injectable.allows(request, response)) {
+            return response;
+        }
+        return this.inject(response);
+    }
+    async inject(response) {
+        const body = insertScriptTag(await response.text());
+        const headers = new Headers(response.headers);
+        headers.delete("etag");
+        headers.delete("last-modified");
+        headers.set("content-length", String(Buffer.byteLength(body)));
+        headers.set("cache-control", "no-store");
+        headers.set(simLiveReloadHeaderName, "injected");
+        return new Response(body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+        });
+    }
+}
+// Matched against the document as written, rather than against a lowercased
+// copy, because lowercasing can change a string's length and move every offset
+// after the character that changed.
+const closingTagPatterns = [/<\/body\s*>/gi, /<\/html\s*>/gi];
+/**
+ * Put the script at the end of the document, wherever that turns out to be.
+ *
+ * A closing tag is the ordinary case. HTML without one is still something a
+ * browser will render, so appending is better than declining to reload it.
+ */
+function insertScriptTag(html) {
+    for (const pattern of closingTagPatterns) {
+        const at = lastMatchIndex(html, pattern);
+        if (at !== -1) {
+            return html.slice(0, at) + simLiveReloadScriptTag + html.slice(at);
+        }
+    }
+    return html + simLiveReloadScriptTag;
+}
+/**
+ * Where the document's own closing tag is, rather than one inside it.
+ */
+function lastMatchIndex(html, pattern) {
+    let index = -1;
+    for (const match of html.matchAll(pattern)) {
+        index = match.index;
+    }
+    return index;
+}
+//# sourceMappingURL=sim-live-reload-injector.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-live-reload-injector.js","sourceRoot":"","sources":["../../../../src/serve/http/live-reload/sim-live-reload-injector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAEtE;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,qBAAqB;IACf,UAAU,GAAG,IAAI,uBAAuB,EAAE,CAAC;IAE5D;;OAEG;IACH,KAAK,CAAC,UAAU,CAAC,OAAgB,EAAE,QAAkB;QACnD,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,CAAC;YAC/C,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC/B,CAAC;IAEO,KAAK,CAAC,MAAM,CAAC,QAAkB;QACrC,MAAM,IAAI,GAAG,eAAe,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;QACpD,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAE9C,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACvB,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;QAChC,OAAO,CAAC,GAAG,CAAC,gBAAgB,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC/D,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;QACzC,OAAO,CAAC,GAAG,CAAC,uBAAuB,EAAE,UAAU,CAAC,CAAC;QAEjD,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE;YACxB,MAAM,EAAE,QAAQ,CAAC,MAAM;YACvB,UAAU,EAAE,QAAQ,CAAC,UAAU;YAC/B,OAAO;SACR,CAAC,CAAC;IACL,CAAC;CACF;AAED,4EAA4E;AAC5E,+EAA+E;AAC/E,oCAAoC;AACpC,MAAM,kBAAkB,GAAG,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;AAE9D;;;;;GAKG;AACH,SAAS,eAAe,CAAC,IAAY;IACnC,KAAK,MAAM,OAAO,IAAI,kBAAkB,EAAE,CAAC;QACzC,MAAM,EAAE,GAAG,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAEzC,IAAI,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC;YACd,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,sBAAsB,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;IAED,OAAO,IAAI,GAAG,sBAAsB,CAAC;AACvC,CAAC;AAED;;GAEG;AACH,SAAS,cAAc,CAAC,IAAY,EAAE,OAAe;IACnD,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC;IAEf,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QAC3C,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;IACtB,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC"}

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

@@ -0,0 +1,18 @@
+/**
+ * Says on startup that live reload is on.
+ *
+ * Live reload is the one thing the simulator does that changes a response body,
+ * which is otherwise the shape the real service returns. Something a served
+ * page did not ask for is worth being told about, once, at the point it starts
+ * happening, rather than being found later in a page's source.
+ *
+ * It goes to the console because the simulator has no logger of its own, the
+ * same as every other warning it raises.
+ */
+export declare class SimLiveReloadReport {
+    /**
+     * Report live reload on a server that has just started listening.
+     */
+    announce(port: string): void;
+}
+//# sourceMappingURL=sim-live-reload-report.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-live-reload-report.d.ts","sourceRoot":"","sources":["../../../../src/serve/http/live-reload/sim-live-reload-report.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,qBAAa,mBAAmB;IAC9B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAU3B;CACF"}

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

@@ -0,0 +1,27 @@
+import { simAwsLocalConfig } from "../local-server/sim-aws-local.config.js";
+import { simLiveReloadConfig } from "./sim-live-reload.config.js";
+/**
+ * Says on startup that live reload is on.
+ *
+ * Live reload is the one thing the simulator does that changes a response body,
+ * which is otherwise the shape the real service returns. Something a served
+ * page did not ask for is worth being told about, once, at the point it starts
+ * happening, rather than being found later in a page's source.
+ *
+ * It goes to the console because the simulator has no logger of its own, the
+ * same as every other warning it raises.
+ */
+export class SimLiveReloadReport {
+    /**
+     * Report live reload on a server that has just started listening.
+     */
+    announce(port) {
+        const channel = `http://${simAwsLocalConfig.hostname}:${port}${simLiveReloadConfig.channelPath}`;
+        // eslint-disable-next-line no-console
+        console.warn(`Simulated AWS live reload is on. HTML responses to browser requests ` +
+            `carry a reload script, so those responses are not byte for byte what ` +
+            `the real service would return. The reload channel is served at ` +
+            `${channel} on every served hostname.`);
+    }
+}
+//# sourceMappingURL=sim-live-reload-report.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-live-reload-report.js","sourceRoot":"","sources":["../../../../src/serve/http/live-reload/sim-live-reload-report.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yCAAyC,CAAC;AAC5E,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE;;;;;;;;;;GAUG;AACH,MAAM,OAAO,mBAAmB;IAC9B;;OAEG;IACH,QAAQ,CAAC,IAAY;QACnB,MAAM,OAAO,GAAG,UAAU,iBAAiB,CAAC,QAAQ,IAAI,IAAI,GAAG,mBAAmB,CAAC,WAAW,EAAE,CAAC;QAEjG,sCAAsC;QACtC,OAAO,CAAC,IAAI,CACV,sEAAsE;YACpE,uEAAuE;YACvE,iEAAiE;YACjE,GAAG,OAAO,4BAA4B,CACzC,CAAC;IACJ,CAAC;CACF"}

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

@@ -0,0 +1,20 @@
+/**
+ * The script a served page runs to reload itself.
+ *
+ * It reloads on two signals. An explicit `reload` event is a reload the
+ * simulator asked for. A `boot` event carrying an id other than the one this
+ * page first saw means it is talking to a process that has restarted, which is
+ * how a restart reaches a page without the outgoing and incoming processes
+ * having to agree on anything. Reconnecting to the same id, which is what a
+ * dropped connection to a still running process gives, does nothing.
+ *
+ * A `reloading` event says a reload is on its way. The page is left to decide
+ * what to make of that, through an attribute it can style, rather than having
+ * anything drawn over it.
+ */
+export declare const simLiveReloadScript: string;
+/**
+ * The script as it goes into a page.
+ */
+export declare const simLiveReloadScriptTag: string;
+//# sourceMappingURL=sim-live-reload-script.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-live-reload-script.d.ts","sourceRoot":"","sources":["../../../../src/serve/http/live-reload/sim-live-reload-script.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,QAwB1B,CAAC;AAEP;;GAEG;AACH,eAAO,MAAM,sBAAsB,QAAqE,CAAC"}

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

@@ -0,0 +1,45 @@
+import { simLiveReloadConfig } from "./sim-live-reload.config.js";
+/**
+ * The script a served page runs to reload itself.
+ *
+ * It reloads on two signals. An explicit `reload` event is a reload the
+ * simulator asked for. A `boot` event carrying an id other than the one this
+ * page first saw means it is talking to a process that has restarted, which is
+ * how a restart reaches a page without the outgoing and incoming processes
+ * having to agree on anything. Reconnecting to the same id, which is what a
+ * dropped connection to a still running process gives, does nothing.
+ *
+ * A `reloading` event says a reload is on its way. The page is left to decide
+ * what to make of that, through an attribute it can style, rather than having
+ * anything drawn over it.
+ */
+export const simLiveReloadScript = `(() => {
+  if (window.simAwsLiveReload) {
+    return;
+  }
+  window.simAwsLiveReload = true;
+
+  let bootId = null;
+  const source = new EventSource("${simLiveReloadConfig.channelPath}");
+
+  source.addEventListener("boot", (event) => {
+    if (bootId !== null && bootId !== event.data) {
+      window.location.reload();
+      return;
+    }
+    bootId = event.data;
+  });
+
+  source.addEventListener("reload", () => {
+    window.location.reload();
+  });
+
+  source.addEventListener("reloading", () => {
+    document.documentElement.dataset.simAwsLiveReload = "reloading";
+  });
+})();`;
+/**
+ * The script as it goes into a page.
+ */
+export const simLiveReloadScriptTag = `<script data-sim-aws-live-reload>${simLiveReloadScript}</script>`;
+//# sourceMappingURL=sim-live-reload-script.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-live-reload-script.js","sourceRoot":"","sources":["../../../../src/serve/http/live-reload/sim-live-reload-script.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG;;;;;;;oCAOC,mBAAmB,CAAC,WAAW;;;;;;;;;;;;;;;;;MAiB7D,CAAC;AAEP;;GAEG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,oCAAoC,mBAAmB,WAAW,CAAC"}

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

@@ -0,0 +1,13 @@
+/**
+ * Configuration for the live reload channel served on localhost.
+ */
+export declare const simLiveReloadConfig: {
+    channelPath: string;
+    clientRetryMs: number;
+    stoppingCloseMs: number;
+};
+/**
+ * Reports that a response carries the injected live reload script.
+ */
+export declare const simLiveReloadHeaderName = "x-sim-aws-live-reload";
+//# sourceMappingURL=sim-live-reload.config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-live-reload.config.d.ts","sourceRoot":"","sources":["../../../../src/serve/http/live-reload/sim-live-reload.config.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,mBAAmB;IAK9B,WAAW;IAIX,aAAa;IAMb,eAAe;CAChB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,0BAA0B,CAAC"}

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

@@ -0,0 +1,25 @@
+/**
+ * Configuration for the live reload channel served on localhost.
+ */
+export const simLiveReloadConfig = {
+    // Reserved on every served hostname, so the injected script can ask for it
+    // with a relative path whatever host the page was served from. The cost is
+    // that a simulated distribution cannot serve anything at this path while live
+    // reload is on.
+    channelPath: "/__sim-aws/live-reload",
+    // How soon a browser reconnects after the connection drops. The default is
+    // several seconds, which is the gap between a restarted process being ready
+    // and the page noticing.
+    clientRetryMs: 500,
+    // How long a stopping server gives a reload connection to go of its own
+    // accord before the socket is destroyed. Loopback needs a fraction of this,
+    // so it is only reached by a browser that has stopped answering, and reaching
+    // it costs nothing beyond the wait: the ports are already released and the
+    // socket is destroyed either way.
+    stoppingCloseMs: 500,
+};
+/**
+ * Reports that a response carries the injected live reload script.
+ */
+export const simLiveReloadHeaderName = "x-sim-aws-live-reload";
+//# sourceMappingURL=sim-live-reload.config.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-live-reload.config.js","sourceRoot":"","sources":["../../../../src/serve/http/live-reload/sim-live-reload.config.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,2EAA2E;IAC3E,2EAA2E;IAC3E,8EAA8E;IAC9E,gBAAgB;IAChB,WAAW,EAAE,wBAAwB;IACrC,2EAA2E;IAC3E,4EAA4E;IAC5E,yBAAyB;IACzB,aAAa,EAAE,GAAG;IAClB,wEAAwE;IACxE,4EAA4E;IAC5E,8EAA8E;IAC9E,2EAA2E;IAC3E,kCAAkC;IAClC,eAAe,EAAE,GAAG;CACrB,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,uBAAuB,CAAC"}

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

@@ -0,0 +1,55 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+interface SimLiveReloadProperties {
+    readonly bootId?: string;
+}
+/**
+ * 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 declare class SimLiveReload {
+    private readonly bootId;
+    private readonly clients;
+    private readonly injector;
+    constructor(properties?: SimLiveReloadProperties);
+    /**
+     * 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: IncomingMessage): boolean;
+    /**
+     * Open the reload channel for a browser, and tell it which process it has
+     * reached.
+     */
+    connect(response: ServerResponse): void;
+    /**
+     * Put the reload script into a response, if that response can take it.
+     */
+    injectInto(request: Request, response: Response): Promise<Response>;
+    /**
+     * Reload every connected browser now.
+     */
+    reload(): void;
+    /**
+     * 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.
+     */
+    stopping(): Promise<void>;
+    private send;
+}
+export {};
+//# sourceMappingURL=sim-live-reload.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-live-reload.d.ts","sourceRoot":"","sources":["../../../../src/serve/http/live-reload/sim-live-reload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAKjE,UAAU,uBAAuB;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAC1D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA+B;IAExD,YAAY,UAAU,GAAE,uBAA4B,EAGnD;IAED;;;;OAIG;IACH,gBAAgB,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAWlD;IAED;;;OAGG;IACH,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI,CAUtC;IAED;;OAEG;IACG,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAExE;IAED;;OAEG;IACH,MAAM,IAAI,IAAI,CAEb;IAED;;;;;;;;;OASG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAO9B;IAED,OAAO,CAAC,IAAI;CAKb"}