@transclude/core 0.10.0 → 0.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@transclude/core",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "description": "An HTML-first server framework. A page is an .html file, the directory tree is the route table, and any fragment of a page is a URL of its own. Runs on Node, Bun, Deno and workerd, and ships no client JavaScript by default.",
   "keywords": [
     "html",

package/src/app.js

@@ -444,7 +444,12 @@ export function createApp({
           return sendRendered(c, html, ctx, preload);
         }
 
-        const html = await cache.read(cacheKey(c.req.url), window, render);
+        // The fourth argument is what holds the background rebuild. Without it
+        // workerd stops the rebuild when this response is sent, and the entry it
+        // leaves in the in-flight map answers every later request with a dead
+        // promise.
+        const after = afterFor(c, (error) => report(error, c));
+        const html = await cache.read(cacheKey(c.req.url), window, render, after);
 
         // A miss rendered through the cache, and that render can answer with a
         // `Response`. It was not stored, but it is still the answer.

package/src/cache.js

@@ -62,6 +62,35 @@ export function memoryStore({ max = 1000 } = {}) {
   };
 }
 
+/**
+ * How long an unfinished render may hold a key.
+ *
+ * The map exists so one render happens per key. It assumed every promise it held
+ * would settle. On workerd one may not: the isolate is allowed to stop when the
+ * response is sent, and it stops the work with it. The `finally` never runs, the
+ * entry stays, and every later request for that key waits on a promise that is
+ * already dead. The page hangs for as long as the isolate lives.
+ *
+ * `after` is the fix, and this is the bound on it being wrong. A render slower
+ * than this loses its claim on the key rather than keeping it forever.
+ */
+const ABANDONED_MS = 30_000;
+
+/**
+ * Keeps the background rebuild alive, and its failure off the unhandled path.
+ *
+ * `after` is `waitUntil` on workerd and a no-op elsewhere, and it attaches its
+ * own catch. Without one, the catch here is all there is: a rebuild that throws
+ * must not take down a process that was only serving a stale page.
+ *
+ * @param {Promise<unknown>} work
+ * @param {((work: Promise<unknown>) => void)|null} after
+ */
+function hold(work, after) {
+  if (after) after(work);
+  else work.catch(() => {});
+}
+
 /**
  * One route's cache, wrapped around the render.
  *
@@ -80,8 +109,11 @@ export function createCache(store = memoryStore(), { now = () => Date.now() } =
   // and every request behind it each start their own.
   const inFlight = new Map();
 
-  const refresh = async (key, window, render) => {
-    if (inFlight.has(key)) return inFlight.get(key);
+  const refresh = (key, window, render) => {
+    const current = inFlight.get(key);
+    if (current && now() - current.at < ABANDONED_MS) return current.work;
+
+    const started = now();
 
     const work = (async () => {
       const result = await render();
@@ -97,15 +129,25 @@ export function createCache(store = memoryStore(), { now = () => Date.now() } =
         store.delete(key);
       }
       return result;
-    })().finally(() => inFlight.delete(key));
+    })().finally(() => {
+      // Only if this is still the entry made above. A render that ran past
+      // ABANDONED_MS was replaced, and it must not delete its replacement.
+      if (inFlight.get(key)?.at === started) inFlight.delete(key);
+    });
 
-    inFlight.set(key, work);
+    inFlight.set(key, { work, at: started });
     return work;
   };
 
   return {
-    /** `null` when the caller should just render, which is every uncached route. */
-    async read(key, window, render) {
+    /**
+     * `null` when the caller should just render, which is every uncached route.
+     *
+     * `after` is the request's `ctx.after`. Only the stale path uses it, and a
+     * caller that leaves it out gets a rebuild nothing holds, which is what this
+     * used to do everywhere.
+     */
+    async read(key, window, render, after = null) {
       if (!window) return null;
 
       const hit = store.get(key);
@@ -116,7 +158,10 @@ export function createCache(store = memoryStore(), { now = () => Date.now() } =
       // Stale. Answer with it now and rebuild behind the response. A failed
       // rebuild leaves the stale entry in place rather than emptying the cache
       // because one render threw.
-      refresh(key, window, render).catch(() => {});
+      //
+      // `after` is what keeps the rebuild alive. On workerd the isolate may stop
+      // the moment the response is sent, and work nothing holds stops with it.
+      hold(refresh(key, window, render), after);
       return hit.html;
     },
 

package/src/compiler/shim.js

@@ -18,6 +18,7 @@ import { ambientJsdoc } from './ambient.js';
 import { parseEach } from './directives.js';
 import { childrenOf } from './codegen.js';
 import { splitInterpolations } from './interp.js';
+import { GLOBALS as EXPRESSION_GLOBALS } from './expr.js';
 import { splitBlocks } from './index.js';
 import { planLift } from './script.js';
 import { ACTION_METHODS } from '../document.js';
@@ -700,10 +701,17 @@ function collectRoots(node, scope, out) {
   }
 }
 
-const GLOBALS = new Set([
-  'html', 'Math', 'JSON', 'String', 'Number', 'Boolean', 'Array', 'Object', 'Date',
-  'isNaN', 'parseInt', 'parseFloat', 'undefined', 'NaN', 'Infinity', 'true', 'false', 'null',
-]);
+/**
+ * The names an expression resolves without a data lookup, plus the three
+ * literals acorn hands back as identifiers where jsep does not.
+ *
+ * Taken from the expression layer rather than written out again. The two lists
+ * were separate and drifted: `json` was in one and not the other, so the
+ * documented helper compiled, rendered, and then failed `npm run check` saying
+ * it was not a field of the page's data. Anything the compiler resolves has to
+ * resolve here too, or the shim checks code the compiler never emits.
+ */
+const GLOBALS = new Set([...EXPRESSION_GLOBALS, 'true', 'false', 'null']);
 
 function collectUsedTags(nodes, components, found = new Set()) {
   for (const node of nodes) {