bun-plugin-stx 0.2.735 → 0.2.739

package/README.md

@@ -55,6 +55,11 @@ like `componentsDir`, whether configured in `stx.config.ts` or passed to
 update. These roots do not need a duplicate `watchDirs` entry. Missing roots
 are tolerated; resolution order and app overrides are unchanged.
 
+Page roots in `patterns` are watched as well. Removing an app override file or
+directory re-resolves the route against the remaining roots, including the
+fallback page's middleware. Recreating the override restores its precedence
+without restarting the development server.
+
 ## Usage with ESM
 
 ### 1. Configure Bun to use the plugin

package/dist/render-cache-store.d.ts

@@ -0,0 +1,47 @@
+/**
+ * A digest of everything an entry's signature does not cover. Files are
+ * described by path, mtime and size; a missing file is part of the answer
+ * too, since creating one (a new `.env.local`) can change what renders.
+ */
+export declare function renderInputsFingerprint(inputs: RenderInputs): Promise<string>;
+/** Put this process's build id where the rendering process put its own. */
+export declare function restampBuildId(html: string, renderedWith: string, current: string): string;
+/**
+ * One file per entry, read on demand. A dashboard's worth of pages is tens of
+ * megabytes of HTML, so nothing is loaded up front and a page nobody opens
+ * costs nothing.
+ */
+export declare function createRenderCacheStore(options: {
+  dir: string
+  inputs: () => RenderInputs
+  buildId: () => string
+}): RenderCacheStore;
+export declare interface PersistableEntry {
+  html: string
+  signature: Map<string, number>
+  status: number
+  headers?: Record<string, string>
+}
+export declare interface RenderInputs {
+  roots: readonly string[]
+  files: readonly string[]
+  extra: unknown
+}
+/**
+ * Taken before a render reads anything, and handed back to `write`.
+ *
+ * The fingerprint is settled first, so it can only be older than what the
+ * render read, never newer. An older one no longer matches after the change
+ * that made it older, which costs a miss; a newer one would vouch for HTML
+ * rendered from files it never described.
+ */
+export declare interface RenderTicket {
+  generation: number
+  fingerprint: string
+}
+export declare interface RenderCacheStore {
+  begin: () => Promise<RenderTicket>
+  read: (key: string) => Promise<PersistableEntry | undefined>
+  write: (key: string, entry: PersistableEntry, ticket: RenderTicket) => Promise<void>
+  invalidate: () => void
+}

package/dist/serve.d.ts

@@ -361,6 +361,7 @@ export declare interface ServeOptions {
   watchDirs?: string[]
   renderCache?: boolean
   renderCacheVary?: 'request' | 'source'
+  renderCachePersist?: boolean
   renderCacheLimit?: number
   clientAddress?: (req: Request, server: ServeServer) => string | null | undefined
   cssCacheLimit?: number

package/dist/serve.js

@@ -9,14 +9,14 @@ import {
 // src/serve.ts
 var {serve: bunServe, Glob } = globalThis.Bun;
 import { existsSync as existsSync2, watch as fsWatch, realpathSync as realpathSync2, statSync as statSync4 } from "fs";
-import nodeFs from "fs/promises";
-import nodePath from "path";
+import nodeFs2 from "fs/promises";
+import nodePath2 from "path";
 import process20 from "process";
 
 // ../../node_modules/bunfig/dist/index.js
 import { existsSync, statSync } from "fs";
 import { resolve } from "path";
-import process from "process";
+import process2 from "process";
 import { existsSync as existsSync12, mkdirSync as mkdirSync4, readdirSync as readdirSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir3 } from "os";
 import { dirname as dirname4, resolve as resolve12 } from "path";
@@ -33,7 +33,7 @@ import { homedir } from "os";
 import { dirname as dirname2, resolve as resolve3 } from "path";
 import process6 from "process";
 import { join, relative, resolve as resolve2 } from "path";
-import process2 from "process";
+import process22 from "process";
 import { existsSync as existsSync22, mkdirSync, readdirSync, writeFileSync } from "fs";
 import { dirname, resolve as resolve5 } from "path";
 import process3 from "process";
@@ -352,7 +352,7 @@ function getConfigPaths(options) {
   return patterns.flatMap((pattern) => CONFIG_FILE_EXTENSIONS.map((extension) => resolve(options.directory, `${pattern}${extension}`)));
 }
 function getLocalConfigDirectories(options = {}) {
-  const cwd = resolve(options.cwd || process.cwd());
+  const cwd = resolve(options.cwd || process2.cwd());
   return Array.from(new Set([
     cwd,
     resolve(cwd, "config"),
@@ -851,12 +851,12 @@ async function loadConfig({
   return defaultConfig;
 }
 function getProjectRoot(filePath, options = {}) {
-  let path = process2.cwd();
+  let path = process22.cwd();
   while (path.includes("storage"))
     path = resolve2(path, "..");
   const finalPath = resolve2(path, filePath || "");
   if (options?.relative)
-    return relative(process2.cwd(), finalPath);
+    return relative(process22.cwd(), finalPath);
   return finalPath;
 }
 async function loadConfig2() {
@@ -864,7 +864,7 @@ async function loadConfig2() {
     const loadedConfig = await loadConfig({
       name: "clarity",
       defaultConfig,
-      cwd: process2.cwd(),
+      cwd: process22.cwd(),
       endpoint: "",
       headers: {}
     });
@@ -5389,7 +5389,7 @@ var init_dist = __esm(async () => {
   };
   defaultConfigDir = resolve5(process3.cwd(), "config");
   defaultGeneratedDir = resolve5(process3.cwd(), "src/generated");
-  defaultLogDirectory = process2.env.CLARITY_LOG_DIR || join(getProjectRoot(), "logs");
+  defaultLogDirectory = process22.env.CLARITY_LOG_DIR || join(getProjectRoot(), "logs");
   defaultConfig = {
     level: "info",
     defaultName: "clarity",
@@ -8881,10 +8881,39 @@ async function servedTemplatesUseImageBuiltins(root, scope) {
     options.additionalComponentsDirs = options.additionalComponentsDirs.map(absolute);
   const directories = new Map;
   const sources = new Map;
+  const listings = new Map;
+  const isFileCache = new Map;
+  function listing(dir) {
+    let entries = listings.get(dir);
+    if (!entries) {
+      entries = readdir4(dir, { withFileTypes: true }).then((list) => ({ exact: new Map(list.map((entry) => [entry.name, entry])), folded: new Set(list.map((entry) => entry.name.toLowerCase())) }), () => null);
+      listings.set(dir, entries);
+    }
+    return entries;
+  }
+  function isFile(file) {
+    let known = isFileCache.get(file);
+    if (!known) {
+      known = (async () => {
+        const entries = await listing(path.dirname(file));
+        if (!entries)
+          return false;
+        const name = path.basename(file);
+        const entry = entries.exact.get(name);
+        if (entry?.isFile())
+          return true;
+        if (entry?.isSymbolicLink() || !entry && entries.folded.has(name.toLowerCase()))
+          return stat4(file).then((result) => result.isFile(), () => false);
+        return false;
+      })();
+      isFileCache.set(file, known);
+    }
+    return known;
+  }
   async function firstFile(candidates) {
     for (const candidate of candidates) {
       const file = absolute(candidate);
-      if (await stat4(file).then((result) => result.isFile(), () => false))
+      if (await isFile(file))
         return file;
     }
   }
@@ -8914,12 +8943,22 @@ async function servedTemplatesUseImageBuiltins(root, scope) {
     }
     return files;
   }
-  async function component(name, file, page, imported) {
+  const resolutions = new Map;
+  function component(name, file, page, imported) {
     const pascal = name.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
     for (const alias of [name, name.toLowerCase(), pascal, pascalToKebab(name)]) {
       if (imported.has(alias))
-        return imported.get(alias);
+        return Promise.resolve(imported.get(alias));
+    }
+    const key = `${name}\x00${path.dirname(page)}\x00${path.dirname(file)}`;
+    let resolving = resolutions.get(key);
+    if (!resolving) {
+      resolving = resolveComponent(name, pascal, file, page);
+      resolutions.set(key, resolving);
     }
+    return resolving;
+  }
+  async function resolveComponent(name, pascal, file, page) {
     if (name.startsWith("./") || name.startsWith("../"))
       return firstFile([path.resolve(path.dirname(file), name.endsWith(".stx") ? name : `${name}.stx`)]);
     const names = [...new Set([name, pascal, pascalToKebab(name)].map((value) => `${value.replace(/\.stx$/, "")}.stx`))];
@@ -9023,6 +9062,94 @@ async function servedTemplatesUseImageBuiltins(root, scope) {
   }
   return false;
 }
+
+// src/render-cache-store.ts
+import nodeFs from "fs/promises";
+import nodePath from "path";
+import { createHash } from "crypto";
+var WATCHED_EXTENSIONS = new Set([".stx", ".md", ".html", ".js", ".ts", ".tsx", ".mts", ".cts", ".json"]);
+async function renderInputsFingerprint(inputs) {
+  const lines = [];
+  for (const root of new Set(inputs.roots)) {
+    const absolute = nodePath.resolve(root);
+    const entries = await nodeFs.readdir(absolute, { recursive: true, withFileTypes: true }).catch(() => null);
+    if (!entries) {
+      lines.push(`root ${absolute} missing`);
+      continue;
+    }
+    const files = entries.filter((entry) => entry.isFile() && WATCHED_EXTENSIONS.has(nodePath.extname(entry.name))).map((entry) => nodePath.join(entry.parentPath, entry.name)).filter((file) => !nodePath.relative(absolute, nodePath.dirname(file)).split(nodePath.sep).some((part) => part === "node_modules" || part.startsWith(".")));
+    const stats = await Promise.all(files.map((file) => nodeFs.stat(file).catch(() => null)));
+    files.forEach((file, index) => lines.push(`file ${file} ${stats[index]?.mtimeMs ?? "gone"} ${stats[index]?.size ?? 0}`));
+  }
+  for (const file of new Set(inputs.files)) {
+    const stat = await nodeFs.stat(file).catch(() => null);
+    lines.push(`input ${nodePath.resolve(file)} ${stat ? `${stat.mtimeMs} ${stat.size}` : "missing"}`);
+  }
+  lines.sort();
+  lines.push(`extra ${JSON.stringify(inputs.extra)}`);
+  return createHash("sha256").update(lines.join(`
+`)).digest("hex");
+}
+function restampBuildId(html, renderedWith, current) {
+  if (renderedWith === current)
+    return html;
+  const before = `<meta name="stx-build" content="${renderedWith}">`;
+  const at = html.indexOf(before);
+  if (at === -1)
+    return html;
+  return `${html.slice(0, at)}<meta name="stx-build" content="${current}">${html.slice(at + before.length)}`;
+}
+function createRenderCacheStore(options) {
+  let generation = 0;
+  let fingerprint = null;
+  const current = () => fingerprint ??= renderInputsFingerprint(options.inputs());
+  const fileFor = (key) => nodePath.join(options.dir, `${createHash("sha256").update(key).digest("hex")}.json`);
+  return {
+    async begin() {
+      const at = generation;
+      return { generation: at, fingerprint: await current() };
+    },
+    async read(key) {
+      const file = fileFor(key);
+      const stored = await Bun.file(file).json().catch(() => null);
+      if (!stored)
+        return;
+      if (stored.v !== 1 || stored.key !== key || stored.fingerprint !== await current()) {
+        await nodeFs.rm(file, { force: true }).catch(() => {});
+        return;
+      }
+      return {
+        html: restampBuildId(stored.html, stored.buildId, options.buildId()),
+        signature: new Map(stored.signature),
+        status: stored.status,
+        headers: stored.headers
+      };
+    },
+    async write(key, entry, ticket) {
+      if (ticket.generation !== generation)
+        return;
+      const stored = {
+        v: 1,
+        key,
+        fingerprint: ticket.fingerprint,
+        buildId: options.buildId(),
+        html: entry.html,
+        signature: [...entry.signature],
+        status: entry.status,
+        headers: entry.headers
+      };
+      await nodeFs.mkdir(options.dir, { recursive: true });
+      const file = fileFor(key);
+      const temporary = `${file}.${process.pid}.tmp`;
+      await Bun.write(temporary, JSON.stringify(stored));
+      await nodeFs.rename(temporary, file);
+    },
+    invalidate() {
+      generation++;
+      fingerprint = null;
+    }
+  };
+}
 // src/page-middleware.ts
 var DEFAULT_PRIORITY = 10;
 function middlewarePriority(middleware) {
@@ -9262,9 +9389,9 @@ function publicFileExists(requestPath, publicDir) {
   }
   if (decoded.includes("\x00"))
     return false;
-  const publicRoot = nodePath.resolve(process20.cwd(), publicDir);
-  const resolved = nodePath.resolve(publicRoot, `.${decoded}`);
-  const inside = resolved === publicRoot || resolved.startsWith(`${publicRoot}${nodePath.sep}`);
+  const publicRoot = nodePath2.resolve(process20.cwd(), publicDir);
+  const resolved = nodePath2.resolve(publicRoot, `.${decoded}`);
+  const inside = resolved === publicRoot || resolved.startsWith(`${publicRoot}${nodePath2.sep}`);
   if (!inside)
     return false;
   try {
@@ -9418,7 +9545,7 @@ function boundedCache(limit) {
 }
 function pageExcluder(exclude, cwd = process20.cwd()) {
   const canonical = (entry) => {
-    const resolved = nodePath.resolve(cwd, entry);
+    const resolved = nodePath2.resolve(cwd, entry);
     try {
       return realpathSync2(resolved);
     } catch {
@@ -9430,7 +9557,7 @@ function pageExcluder(exclude, cwd = process20.cwd()) {
     return () => false;
   return (file) => {
     const resolved = canonical(file);
-    return roots.some((root) => resolved === root || resolved.startsWith(`${root}${nodePath.sep}`));
+    return roots.some((root) => resolved === root || resolved.startsWith(`${root}${nodePath2.sep}`));
   };
 }
 function resolveServeOpenUrl(port, openPath = "/") {
@@ -9665,9 +9792,9 @@ async function serve(options) {
   }
   const stxModule = options.stxModule ? Promise.resolve(options.stxModule) : defaultStxModule;
   const imageCacheDir = process20.env.STX_IMAGE_CACHE_DIR?.trim();
-  const imageDeliveryOutputDir = imageCacheDir ? nodePath.resolve(imageCacheDir, "image-delivery") : stateDir(process20.cwd(), "image-delivery");
-  const imagePlaceholderCachePath = imageCacheDir ? nodePath.resolve(imageCacheDir, "image-placeholders.json") : stateDir(process20.cwd(), "image-placeholders.json");
-  const imageDeliveryRoot = nodePath.join(imageDeliveryOutputDir, "_stx", "images");
+  const imageDeliveryOutputDir = imageCacheDir ? nodePath2.resolve(imageCacheDir, "image-delivery") : stateDir(process20.cwd(), "image-delivery");
+  const imagePlaceholderCachePath = imageCacheDir ? nodePath2.resolve(imageCacheDir, "image-placeholders.json") : stateDir(process20.cwd(), "image-placeholders.json");
+  const imageDeliveryRoot = nodePath2.join(imageDeliveryOutputDir, "_stx", "images");
   let resolvedStxModule = null;
   Promise.resolve(stxModule).then((m) => {
     resolvedStxModule = m;
@@ -9694,6 +9821,28 @@ After installing: bun add bun-plugin-stx`);
   const pendingShellRenders = new Map;
   const ENABLE_HTML_CACHE = options.renderCache === true;
   const RENDER_CACHE_VARY = options.renderCacheVary ?? "request";
+  const renderCacheStore = ENABLE_HTML_CACHE && RENDER_CACHE_VARY === "source" && options.renderCachePersist === true ? createRenderCacheStore({ dir: stateDir(process20.cwd(), "render-cache"), inputs: () => renderInputs(), buildId: getBuildId }) : null;
+  async function renderTicket(reqCtx) {
+    if (!renderCacheStore || reqCtx && reqCtx.method !== "GET" && reqCtx.method !== "HEAD")
+      return;
+    return renderCacheStore.begin().catch(() => {
+      return;
+    });
+  }
+  async function readRenderCache(key) {
+    const hit = htmlCache.read(key);
+    if (hit || !renderCacheStore)
+      return hit;
+    const kept = await renderCacheStore.read(key).catch(() => {
+      return;
+    });
+    return kept ? htmlCache.remember(key, kept) : undefined;
+  }
+  function rememberRender(key, entry, ticket) {
+    htmlCache.remember(key, entry);
+    if (renderCacheStore && ticket)
+      renderCacheStore.write(key, entry, ticket).catch(() => {});
+  }
   const cssCssCache = boundedCache(options.cssCacheLimit ?? 512);
   const hmrClients = new Set;
   const hmrEncoder = new TextEncoder;
@@ -9791,14 +9940,22 @@ function __stxOverlay(errs){
     currentBuildErrors = errors;
     broadcastHmr({ type: "build-error", errors });
   }
-  const watchersStarted = new Set;
+  const watchersStarted = new Map;
+  const clearRenderCaches = () => {
+    htmlCache.clear();
+    renderCacheStore?.invalidate();
+    cssCssCache.clear();
+    resolvedStxModule?.clearDevCaches?.();
+    resolvedStxModule?.clearStoreCache?.();
+    resolvedStxModule?.clearComposableCache?.();
+  };
   const startWatcher = (dir) => {
     if (production)
       return;
     if (watchersStarted.has(dir))
       return;
     try {
-      const watcher = fsWatch(dir, { recursive: true }, (_event, filename) => {
+      const watcher = fsWatch(dir, { recursive: true }, (event, filename) => {
         if (!filename)
           return;
         const f = String(filename);
@@ -9807,22 +9964,19 @@ function __stxOverlay(errs){
         const isData = f.endsWith(".json");
         const isCss = f.endsWith(".css");
         const isAsset = isCss || isCode || f.endsWith(".jpg") || f.endsWith(".jpeg") || f.endsWith(".png") || f.endsWith(".gif") || f.endsWith(".svg") || f.endsWith(".webp") || f.endsWith(".avif") || f.endsWith(".woff") || f.endsWith(".woff2") || f.endsWith(".ttf") || f.endsWith(".otf");
-        if (!isStxLike && !isAsset && !isData)
+        const topologyChanged = event === "rename";
+        if (!isStxLike && !isAsset && !isData && !topologyChanged)
           return;
-        if (isStxLike || isCode || isData) {
-          if (isStxLike)
+        if (isStxLike || isCode || isData || topologyChanged) {
+          if (isStxLike || topologyChanged)
             sourceFiles = null;
-          htmlCache.clear();
-          cssCssCache.clear();
-          resolvedStxModule?.clearDevCaches?.();
-          resolvedStxModule?.clearStoreCache?.();
-          resolvedStxModule?.clearComposableCache?.();
-          if (layoutsDir && f.endsWith(".stx") && nodePath.resolve(f).startsWith(nodePath.resolve(layoutsDir)))
+          clearRenderCaches();
+          if (layoutsDir && f.endsWith(".stx") && nodePath2.resolve(f).startsWith(nodePath2.resolve(layoutsDir)))
             writeLayoutTypes();
         }
-        const resolved = nodePath.resolve(dir, f);
-        const isStore = resolved.startsWith(nodePath.resolve(storesDir)) || composableDirs.some((d) => resolved.startsWith(nodePath.resolve(d)));
-        const isLayout = !!layoutsDir && resolved.startsWith(nodePath.resolve(layoutsDir));
+        const resolved = nodePath2.resolve(dir, f);
+        const isStore = resolved.startsWith(nodePath2.resolve(storesDir)) || composableDirs.some((d) => resolved.startsWith(nodePath2.resolve(d)));
+        const isLayout = !!layoutsDir && resolved.startsWith(nodePath2.resolve(layoutsDir));
         if (isCss && !isStxLike)
           broadcastHmr({ type: "css", file: f });
         else if (isStore)
@@ -9833,7 +9987,30 @@ function __stxOverlay(errs){
           broadcastHmr({ type: "reload", file: f });
       });
       watcher.on("error", () => {});
-      watchersStarted.add(dir);
+      watchersStarted.set(dir, watcher);
+    } catch {}
+  };
+  const pageRootWatchersStarted = new Set;
+  const watchPageRoot = (dir) => {
+    if (production || pageRootWatchersStarted.has(dir))
+      return;
+    const absolute = nodePath2.resolve(dir);
+    const parent = nodePath2.dirname(absolute);
+    if (parent === absolute)
+      return;
+    try {
+      const watcher = fsWatch(parent, { recursive: false }, (event, filename) => {
+        if (event !== "rename" || String(filename) !== nodePath2.basename(absolute))
+          return;
+        watchersStarted.get(dir)?.close();
+        watchersStarted.delete(dir);
+        startWatcher(dir);
+        sourceFiles = null;
+        clearRenderCaches();
+        broadcastHmr({ type: "reload", file: dir });
+      });
+      watcher.on("error", () => {});
+      pageRootWatchersStarted.add(dir);
     } catch {}
   };
   const writeLayoutTypes = async () => {
@@ -9843,9 +10020,9 @@ function __stxOverlay(errs){
     } catch {}
   };
   await writeLayoutTypes();
-  const storesDir = nodePath.resolve(stxConfig.root || ".", stxConfig.storesDir || "stores");
-  const composableDirs = stxConfig.composablesDir ? [nodePath.resolve(stxConfig.root || ".", stxConfig.composablesDir)] : ["composables", "functions"].map((d) => nodePath.resolve(stxConfig.root || ".", d));
-  for (const dir of [
+  const storesDir = nodePath2.resolve(stxConfig.root || ".", stxConfig.storesDir || "stores");
+  const composableDirs = stxConfig.composablesDir ? [nodePath2.resolve(stxConfig.root || ".", stxConfig.composablesDir)] : ["composables", "functions"].map((d) => nodePath2.resolve(stxConfig.root || ".", d));
+  const watchedRoots = [
     componentsDir,
     ...additionalComponentsDirs ?? [],
     layoutsDir,
@@ -9855,10 +10032,46 @@ function __stxOverlay(errs){
     storesDir,
     ...composableDirs,
     ...options.watchDirs ?? []
-  ]) {
-    if (!dir)
-      continue;
+  ].filter((dir) => !!dir);
+  for (const dir of watchedRoots)
     startWatcher(dir);
+  function renderInputs() {
+    const cwd = process20.cwd();
+    const configFiles = ["stx", "css"].flatMap((name) => [
+      `${name}.config.ts`,
+      `${name}.config.js`,
+      `.config/${name}.ts`,
+      `config/${name}.ts`
+    ]);
+    let stxEntry;
+    try {
+      stxEntry = Bun.resolveSync("@stacksjs/stx", import.meta.dir);
+    } catch {}
+    return {
+      roots: [...watchedRoots, ...patterns.filter((pattern) => !pattern.includes("*"))],
+      files: [
+        ...["package.json", "bun.lock", "bun.lockb", "pantry.lock", ".env", ".env.local", ".env.development", ".env.production", ...configFiles].map((file) => nodePath2.join(cwd, file)),
+        import.meta.path,
+        ...stxEntry ? [stxEntry] : []
+      ],
+      extra: {
+        bun: Bun.version,
+        production,
+        options: {
+          patterns,
+          root: cwd,
+          componentsDir,
+          additionalComponentsDirs,
+          layoutsDir,
+          fallbackLayoutsDir: options.fallbackLayoutsDir,
+          fallbackComponentsDir: options.fallbackComponentsDir,
+          partialsDir,
+          publicDir,
+          watchDirs: options.watchDirs,
+          domains: options.domains
+        }
+      }
+    };
   }
   const pageMiddlewareByPath = new Map;
   const pageMiddlewarePatterns = [];
@@ -9897,7 +10110,7 @@ function __stxOverlay(errs){
   }
   async function detectPageMiddleware(file) {
     try {
-      const src = await nodeFs.readFile(file, "utf-8");
+      const src = await nodeFs2.readFile(file, "utf-8");
       const meta = src.match(/definePageMeta\s*\(\s*\{[\s\S]*?\}\s*\)/);
       if (!meta)
         return [];
@@ -10137,7 +10350,9 @@ function __stxOverlay(errs){
     const supportedExtensions = [".stx", ".md", ".html"];
     for (const pattern of patterns) {
       try {
-        const stat = await nodeFs.stat(pattern).catch(() => null);
+        const stat = await nodeFs2.stat(pattern).catch(() => null);
+        if (stat?.isDirectory() || !stat && !pattern.includes("*") && !supportedExtensions.some((ext) => pattern.endsWith(ext)))
+          watchPageRoot(pattern);
         if (stat?.isDirectory()) {
           startWatcher(pattern);
           const excludeDirs = ["layouts", "components", "partials"];
@@ -10173,7 +10388,7 @@ function __stxOverlay(errs){
       const pagesDirs = patterns.map((p) => p.replace(/\/$/, "")).filter(Boolean);
       const router = new Router(process20.cwd(), { pagesDirs, stateDir: stateDirName(), exclude: options.exclude });
       if (!options.quiet)
-        console.log(`[stx] Generated ${router.routes.length} routes \u2192 ${nodePath.join(stateDirName(), "routes.ts")}`);
+        console.log(`[stx] Generated ${router.routes.length} routes \u2192 ${nodePath2.join(stateDirName(), "routes.ts")}`);
     } catch (e) {}
     return kept;
   }
@@ -10184,16 +10399,16 @@ function __stxOverlay(errs){
     const assetsDir = "./resources/assets";
     const targetAssetsDir = stateDir(process20.cwd(), "assets");
     try {
-      const assetsExist = await nodeFs.stat(assetsDir).then(() => true).catch(() => false);
+      const assetsExist = await nodeFs2.stat(assetsDir).then(() => true).catch(() => false);
       if (assetsExist) {
-        await nodeFs.rm(targetAssetsDir, { recursive: true, force: true });
-        await nodeFs.cp(assetsDir, targetAssetsDir, { recursive: true });
+        await nodeFs2.rm(targetAssetsDir, { recursive: true, force: true });
+        await nodeFs2.cp(assetsDir, targetAssetsDir, { recursive: true });
       }
     } catch {}
   }
   async function templateSignatureFresh(sig) {
     for (const [p, expected] of sig) {
-      const stat = await nodeFs.stat(p).catch(() => null);
+      const stat = await nodeFs2.stat(p).catch(() => null);
       if (!stat || stat.mtimeMs !== expected)
         return false;
     }
@@ -10202,7 +10417,7 @@ function __stxOverlay(errs){
   async function buildTemplateSignature(filePath, deps) {
     const sig = new Map;
     const allPaths = [filePath, ...deps];
-    const stats = await Promise.all(allPaths.map((p) => nodeFs.stat(p).catch(() => null)));
+    const stats = await Promise.all(allPaths.map((p) => nodeFs2.stat(p).catch(() => null)));
     for (let i = 0;i < allPaths.length; i++) {
       const stat = stats[i];
       if (stat)
@@ -10218,10 +10433,10 @@ function __stxOverlay(errs){
       return cssModule;
     cssLoadAttempted = true;
     let dir = process20.cwd();
-    while (dir !== nodePath.dirname(dir)) {
+    while (dir !== nodePath2.dirname(dir)) {
       for (const store of ["node_modules", "pantry"]) {
         for (const entry of ENGINE_PACKAGE_ENTRIES) {
-          const candidate = nodePath.join(dir, store, ...entry);
+          const candidate = nodePath2.join(dir, store, ...entry);
           try {
             if (!await Bun.file(candidate).exists())
               continue;
@@ -10233,7 +10448,7 @@ function __stxOverlay(errs){
           } catch {}
         }
       }
-      dir = nodePath.dirname(dir);
+      dir = nodePath2.dirname(dir);
     }
     for (const specifier of ENGINE_SPECIFIERS) {
       try {
@@ -10245,7 +10460,7 @@ function __stxOverlay(errs){
       } catch {}
     }
     try {
-      const localPath = nodePath.join(process20.env.HOME || "", "Code/Tools/crosswind/packages/toolkit/src/engine/index.ts");
+      const localPath = nodePath2.join(process20.env.HOME || "", "Code/Tools/crosswind/packages/toolkit/src/engine/index.ts");
       const mod = await import(localPath);
       cssModule = { CSSGenerator: mod.CSSGenerator, config: mod.config };
       return cssModule;
@@ -10375,6 +10590,7 @@ function __stxOverlay(errs){
       reqCtx.responseHeaders = { ...reqCtx.responseHeaders, ...headers };
   }
   async function processTemplate(filePath, reqCtx) {
+    const ticket = await renderTicket(reqCtx);
     const content = await Bun.file(filePath).text();
     if (reqCtx)
       reqCtx.responseStatus = extractPageResponseStatus(content) ?? 200;
@@ -10382,7 +10598,7 @@ function __stxOverlay(errs){
     const isMutating = !!reqCtx && reqCtx.method !== "GET" && reqCtx.method !== "HEAD";
     if (ENABLE_HTML_CACHE && !skipCacheHint && !isMutating) {
       const cacheKey = htmlCacheKey(filePath, reqCtx);
-      const cachedEntry = htmlCache.read(cacheKey);
+      const cachedEntry = await readRenderCache(cacheKey);
       if (cachedEntry && await templateSignatureFresh(cachedEntry.signature)) {
         if (reqCtx) {
           reqCtx.responseStatus = cachedEntry.status;
@@ -10394,7 +10610,7 @@ function __stxOverlay(errs){
     const { serverScripts, templateContent } = extractServerScriptsFromTemplate(content);
     const context = {
       __filename: filePath,
-      __dirname: nodePath.dirname(filePath),
+      __dirname: nodePath2.dirname(filePath),
       __stx_options: stxConfig,
       __stx_runtime_head: {}
     };
@@ -10461,7 +10677,7 @@ function __stxOverlay(errs){
     }
     if (ENABLE_HTML_CACHE && !context.__stx_skip_cache && !skipCacheHint && !isMutating && isRenderableCacheCandidate(output) && placeholdersAreReady) {
       const signature = await buildTemplateSignature(filePath, dependencies);
-      htmlCache.remember(htmlCacheKey(filePath, reqCtx), { html: output, signature, status: reqCtx?.responseStatus ?? 200, headers: reqCtx?.responseHeaders });
+      rememberRender(htmlCacheKey(filePath, reqCtx), { html: output, signature, status: reqCtx?.responseStatus ?? 200, headers: reqCtx?.responseHeaders }, ticket);
     }
     return output;
   }
@@ -10483,7 +10699,7 @@ function __stxOverlay(errs){
       possibleFiles.push(`${normalizedPath}/index.md`);
       possibleFiles.push(`${normalizedPath}/index.html`);
     }
-    const filename = nodePath.basename(normalizedPath, nodePath.extname(normalizedPath));
+    const filename = nodePath2.basename(normalizedPath, nodePath2.extname(normalizedPath));
     if (filename && !normalizedPath.includes("/")) {
       possibleFiles.push(`${filename}.stx`);
       possibleFiles.push(`${filename}.md`);
@@ -10565,6 +10781,7 @@ function __stxOverlay(errs){
     return null;
   }
   async function processTemplateDynamic(filePath, paramNames, paramValues, routePath, reqCtx) {
+    const ticket = await renderTicket(reqCtx);
     const content = await Bun.file(filePath).text();
     if (reqCtx)
       reqCtx.responseStatus = extractPageResponseStatus(content) ?? 200;
@@ -10583,7 +10800,7 @@ function __stxOverlay(errs){
     if (reqCtx)
       reqCtx.params = paramsObj;
     if (cacheShell) {
-      const cachedEntry = htmlCache.read(filePath);
+      const cachedEntry = await readRenderCache(filePath);
       if (cachedEntry && await templateSignatureFresh(cachedEntry.signature)) {
         if (reqCtx) {
           reqCtx.responseStatus = cachedEntry.status;
@@ -10606,7 +10823,7 @@ function __stxOverlay(errs){
     try {
       const context = {
         __filename: filePath,
-        __dirname: nodePath.dirname(filePath),
+        __dirname: nodePath2.dirname(filePath),
         __route: routePath,
         __stx_runtime_head: {}
       };
@@ -10678,7 +10895,7 @@ ${output}`;
       const recordedResponse = readResponseStatus(context) !== undefined || !!readResponseHeaders(context);
       if (!context.__stx_skip_cache && !recordedResponse && isRenderableCacheCandidate(output) && placeholdersAreReady) {
         const signature = await buildTemplateSignature(filePath, dependencies);
-        htmlCache.remember(filePath, { html: output, signature, status: reqCtx?.responseStatus ?? 200, headers: reqCtx?.responseHeaders });
+        rememberRender(filePath, { html: output, signature, status: reqCtx?.responseStatus ?? 200, headers: reqCtx?.responseHeaders }, ticket);
       }
       return fillRouteParams(output, paramsObj);
     } finally {
@@ -10842,7 +11059,7 @@ ${block}`;
     }
     try {
       const stx = await stxModule;
-      const publicRoot = nodePath.resolve(process20.cwd(), publicDir);
+      const publicRoot = nodePath2.resolve(process20.cwd(), publicDir);
       const [placeholderResult, deliveryResult] = await Promise.allSettled([
         stx.warmImagePlaceholders(publicRoot, {
           cachePath: imagePlaceholderCachePath,
@@ -11077,8 +11294,8 @@ ${block}`;
                 }
                 if (!decodedPath || decodedPath.includes("\x00"))
                   return new Response("Invalid image path", { status: 400 });
-                const resolvedPath = nodePath.resolve(imageDeliveryRoot, decodedPath);
-                if (!resolvedPath.startsWith(`${imageDeliveryRoot}${nodePath.sep}`))
+                const resolvedPath = nodePath2.resolve(imageDeliveryRoot, decodedPath);
+                if (!resolvedPath.startsWith(`${imageDeliveryRoot}${nodePath2.sep}`))
                   return new Response("Invalid image path", { status: 400 });
                 try {
                   const file = Bun.file(resolvedPath);
@@ -11140,6 +11357,7 @@ ${block}`;
                 if (hookResult && typeof hookResult === "object")
                   Object.assign(reqCtx, hookResult);
               }
+              await discoverFiles();
               const route = resolveRouteMiddleware(path);
               const extraNames = extraProtectedPrefixes.some((p) => path === p || path.startsWith(p.endsWith("/") ? p : `${p}/`)) ? ["auth"] : [];
               const requested = [...globalMiddlewareNames, ...route.names, ...extraNames];
@@ -11221,7 +11439,7 @@ ${block}`;
                   }
                   const body = await req.json();
                   const { Database } = await import("bun:sqlite");
-                  const dbPath = nodePath.resolve(process20.cwd(), "database/stacks.sqlite");
+                  const dbPath = nodePath2.resolve(process20.cwd(), "database/stacks.sqlite");
                   const db = new Database(dbPath);
                   try {
                     const tableInfo = db.query(`PRAGMA table_info("${tableName}")`).all();
@@ -11514,7 +11732,7 @@ ${trailingPageScripts.join(`
                   return new Response("Invalid asset path", { status: 400 });
                 for (const assetPath of assetRequestPaths(assetPathname)) {
                   try {
-                    const filePath = nodePath.resolve(process20.cwd(), `.${assetPath}`);
+                    const filePath = nodePath2.resolve(process20.cwd(), `.${assetPath}`);
                     const file = Bun.file(filePath);
                     if (await file.exists()) {
                       const ext = getAssetExtension(assetPath);
@@ -11533,7 +11751,7 @@ ${trailingPageScripts.join(`
                 }
               }
               if ((req.method === "GET" || req.method === "HEAD") && path !== "/") {
-                const publicRoot = nodePath.resolve(process20.cwd(), publicDir);
+                const publicRoot = nodePath2.resolve(process20.cwd(), publicDir);
                 let safePathname;
                 try {
                   safePathname = decodeURIComponent(path);
@@ -11541,8 +11759,8 @@ ${trailingPageScripts.join(`
                   safePathname = path;
                 }
                 if (!safePathname.includes("\x00")) {
-                  const resolvedPath = nodePath.resolve(publicRoot, `.${safePathname}`);
-                  const isInsidePublicRoot = resolvedPath === publicRoot || resolvedPath.startsWith(`${publicRoot}${nodePath.sep}`);
+                  const resolvedPath = nodePath2.resolve(publicRoot, `.${safePathname}`);
+                  const isInsidePublicRoot = resolvedPath === publicRoot || resolvedPath.startsWith(`${publicRoot}${nodePath2.sep}`);
                   if (isInsidePublicRoot) {
                     try {
                       const file = Bun.file(resolvedPath);
@@ -11823,7 +12041,7 @@ async function projectUsesImageBuiltins(root, scope) {
     for (const entry of entries) {
       if (entry.name.startsWith("."))
         continue;
-      const full = nodePath.join(dir, entry.name);
+      const full = nodePath2.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!TEMPLATE_SCAN_SKIP.has(entry.name))
           pending.push(full);
@@ -11837,7 +12055,7 @@ async function projectUsesImageBuiltins(root, scope) {
       } catch {
         continue;
       }
-      const inComponents = nodePath.relative(root, dir).split(nodePath.sep).includes("components");
+      const inComponents = nodePath2.relative(root, dir).split(nodePath2.sep).includes("components");
       const component = inComponents ? entry.name.slice(0, -".stx".length) : undefined;
       if (!component && IMAGE_BUILTIN_PATTERN.test(source))
         return true;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bun-plugin-stx",
   "type": "module",
-  "version": "0.2.735",
+  "version": "0.2.739",
   "description": "A Bun plugin that allows for using Laravel Blade-like syntax.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",
@@ -74,7 +74,7 @@
     "typecheck": "bun tsc --noEmit"
   },
   "dependencies": {
-    "@stacksjs/stx": "0.2.735",
-    "stx-router": "0.2.735"
+    "@stacksjs/stx": "0.2.739",
+    "stx-router": "0.2.739"
   }
 }