dsh-unlag 1.9.58 → 1.9.60

package/index.js

@@ -1269,7 +1269,12 @@ function serveBundlesAtCurrentRevision(ctx) {
        * from. Only when it has nothing is the same request tried at the revision of the plugin it
        * names, because a chunk is served at its entry's revision and nowhere else.
        */
-      const url = String(request?.url ?? '')
+      // Reading the address is the first thing that runs, and a request object that cannot answer it
+      // would reject this async handler before any guard below: it is read as no address instead.
+      let url = ''
+      try {
+        url = String(request?.url ?? '')
+      } catch {}
       // Same reason as the handler shape below: a rejection here is unhandled and ends the process.
       let retargeted = null
       try {
@@ -1315,7 +1320,12 @@ function serveBundlesAtCurrentRevision(ctx) {
    * first, so the served document and the chunks it later asks for are one generation.
    */
   const wrapped = async (req, res) => {
-    const originalUrl = String(req?.url ?? '')
+    // Same as the resource shape: an address that cannot be read is no address. Throwing here would
+    // reject the handler the server is awaiting, and a rejection nobody catches ends the process.
+    let originalUrl = ''
+    try {
+      originalUrl = String(req?.url ?? '')
+    } catch {}
     // Reading the table can throw while the plugin set is being swapped. This runs inside an async
     // route handler, where a rejection is an unhandled one and takes the whole app with it, so the
     // failure has to end here: answer the request as the table left it and say why in the log.
@@ -1325,10 +1335,22 @@ function serveBundlesAtCurrentRevision(ctx) {
     } catch (error) {
       log(`cannot read the plugin table for a bundle request: ${error?.message ?? error}`)
     }
-    const realWriteHead = res.writeHead
-    const realEnd = res.end
-    const realWriteRef = res.write
+    /**
+     * Reading the response is the other thing that runs before any guard. A response that cannot
+     * answer a read is treated as one that cannot be held: the table's answer goes through, and a
+     * throw here would reject the handler the server is awaiting.
+     */
+    let realWriteHead
+    let realEnd
+    let realWriteRef
     let canHold = true
+    try {
+      realWriteHead = res.writeHead
+      realEnd = res.end
+      realWriteRef = res.write
+    } catch {
+      canHold = false
+    }
     const ask = async (url) => {
       let held = null
       let body
@@ -1348,7 +1370,6 @@ function serveBundlesAtCurrentRevision(ctx) {
        * also owes the caller the callbacks it passed: dropping one would leave a handler that waits
        * for the flush awaiting forever, and the answer after it would never run.
        */
-      const realWrite = res.write
       const answerCallback = (args) => {
         for (let at = args.length - 1; at >= 0; at -= 1) {
           if (typeof args[at] === 'function') {
@@ -1375,14 +1396,14 @@ function serveBundlesAtCurrentRevision(ctx) {
        */
       if (canHold) {
         try {
-          if (typeof realWrite === 'function') {
+          if (typeof realWriteRef === 'function') {
             res.write = (chunk, ...rest) => {
               if (held !== null) {
                 if (typeof chunk === 'string' || Buffer.isBuffer(chunk)) parts.push(Buffer.from(chunk))
                 answerCallback(rest)
                 return true
               }
-              return realWrite.call(res, chunk, ...rest)
+              return realWriteRef.call(res, chunk, ...rest)
             }
           }
           if (typeof realEnd === 'function') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-unlag",
-  "version": "1.9.58",
+  "version": "1.9.60",
   "type": "module",
   "description": "A press applies plugin edits right away and brings a laggy interface back; automatic reloading stays off unless you turn it on, so the press is the only trigger, and nothing restarts.",
   "license": "MIT",