@tiddlywiki/mws 0.0.17 → 0.0.19

package/dist/server.js

@@ -15,10 +15,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __glob = (map) => (path5) => {
-  var fn = map[path5];
+var __glob = (map) => (path6) => {
+  var fn = map[path6];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path5);
+  throw new Error("Module not found in bundle: " + path6);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -195,7 +195,7 @@ var require_depd = __commonJS({
   "node_modules/depd/index.js"(exports, module2) {
     "use strict";
     init_esm_shims();
-    var relative = __require("path").relative;
+    var relative2 = __require("path").relative;
     module2.exports = depd;
     var basePath = process.cwd();
     function containsNamespace(str, namespace) {
@@ -401,7 +401,7 @@ var require_depd = __commonJS({
     }
     __name(formatColor, "formatColor");
     function formatLocation(callSite) {
-      return relative(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
+      return relative2(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
     }
     __name(formatLocation, "formatLocation");
     function getStack() {
@@ -1786,14 +1786,14 @@ var require_etag = __commonJS({
     "use strict";
     init_esm_shims();
     module2.exports = etag;
-    var crypto = __require("crypto");
+    var crypto2 = __require("crypto");
     var Stats = __require("fs").Stats;
     var toString = Object.prototype.toString;
     function entitytag(entity) {
       if (entity.length === 0) {
         return '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"';
       }
-      var hash = crypto.createHash("sha1").update(entity, "utf8").digest("base64").substring(0, 27);
+      var hash = crypto2.createHash("sha1").update(entity, "utf8").digest("base64").substring(0, 27);
       var len = typeof entity === "string" ? Buffer.byteLength(entity, "utf8") : entity.length;
       return '"' + len.toString(16) + "-" + hash + '"';
     }
@@ -10497,11 +10497,11 @@ var require_mime_types = __commonJS({
       return exts[0];
     }
     __name(extension, "extension");
-    function lookup(path5) {
-      if (!path5 || typeof path5 !== "string") {
+    function lookup(path6) {
+      if (!path6 || typeof path6 !== "string") {
         return false;
       }
-      var extension2 = extname("x." + path5).toLowerCase().substr(1);
+      var extension2 = extname("x." + path6).toLowerCase().substr(1);
       if (!extension2) {
         return false;
       }
@@ -10812,33 +10812,33 @@ var require_send = __commonJS({
     var escapeHtml = require_escape_html();
     var etag = require_etag();
     var fresh = require_fresh();
-    var fs3 = __require("fs");
+    var fs4 = __require("fs");
     var mime = require_mime_types();
     var ms = require_ms();
     var onFinished = require_on_finished();
     var parseRange = require_range_parser();
-    var path5 = __require("path");
+    var path6 = __require("path");
     var statuses = require_statuses();
     var Stream = __require("stream");
     var util = __require("util");
-    var extname = path5.extname;
-    var join3 = path5.join;
-    var normalize = path5.normalize;
-    var resolve13 = path5.resolve;
-    var sep2 = path5.sep;
+    var extname = path6.extname;
+    var join4 = path6.join;
+    var normalize2 = path6.normalize;
+    var resolve13 = path6.resolve;
+    var sep2 = path6.sep;
     var BYTES_RANGE_REGEXP = /^ *bytes=/;
     var MAX_MAXAGE = 60 * 60 * 24 * 365 * 1e3;
     var UP_PATH_REGEXP = /(?:^|[\\/])\.\.(?:[\\/]|$)/;
     module2.exports = send2;
-    function send2(req, path6, options) {
-      return new SendStream(req, path6, options);
+    function send2(req, path7, options) {
+      return new SendStream(req, path7, options);
     }
     __name(send2, "send");
-    function SendStream(req, path6, options) {
+    function SendStream(req, path7, options) {
       Stream.call(this);
       var opts = options || {};
       this.options = opts;
-      this.path = path6;
+      this.path = path7;
       this.req = req;
       this._acceptRanges = opts.acceptRanges !== void 0 ? Boolean(opts.acceptRanges) : true;
       this._cacheControl = opts.cacheControl !== void 0 ? Boolean(opts.cacheControl) : true;
@@ -10953,10 +10953,10 @@ var require_send = __commonJS({
       var lastModified = this.res.getHeader("Last-Modified");
       return parseHttpDate(lastModified) <= parseHttpDate(ifRange);
     }, "isRangeFresh");
-    SendStream.prototype.redirect = /* @__PURE__ */ __name(function redirect(path6) {
+    SendStream.prototype.redirect = /* @__PURE__ */ __name(function redirect(path7) {
       var res = this.res;
       if (hasListeners(this, "directory")) {
-        this.emit("directory", res, path6);
+        this.emit("directory", res, path7);
         return;
       }
       if (this.hasTrailingSlash()) {
@@ -10976,38 +10976,38 @@ var require_send = __commonJS({
     SendStream.prototype.pipe = /* @__PURE__ */ __name(function pipe(res) {
       var root = this._root;
       this.res = res;
-      var path6 = decode(this.path);
-      if (path6 === -1) {
+      var path7 = decode(this.path);
+      if (path7 === -1) {
         this.error(400);
         return res;
       }
-      if (~path6.indexOf("\0")) {
+      if (~path7.indexOf("\0")) {
         this.error(400);
         return res;
       }
       var parts;
       if (root !== null) {
-        if (path6) {
-          path6 = normalize("." + sep2 + path6);
+        if (path7) {
+          path7 = normalize2("." + sep2 + path7);
         }
-        if (UP_PATH_REGEXP.test(path6)) {
-          debug('malicious path "%s"', path6);
+        if (UP_PATH_REGEXP.test(path7)) {
+          debug('malicious path "%s"', path7);
           this.error(403);
           return res;
         }
-        parts = path6.split(sep2);
-        path6 = normalize(join3(root, path6));
+        parts = path7.split(sep2);
+        path7 = normalize2(join4(root, path7));
       } else {
-        if (UP_PATH_REGEXP.test(path6)) {
-          debug('malicious path "%s"', path6);
+        if (UP_PATH_REGEXP.test(path7)) {
+          debug('malicious path "%s"', path7);
           this.error(403);
           return res;
         }
-        parts = normalize(path6).split(sep2);
-        path6 = resolve13(path6);
+        parts = normalize2(path7).split(sep2);
+        path7 = resolve13(path7);
       }
       if (containsDotFile(parts)) {
-        debug('%s dotfile "%s"', this._dotfiles, path6);
+        debug('%s dotfile "%s"', this._dotfiles, path7);
         switch (this._dotfiles) {
           case "allow":
             break;
@@ -11021,13 +11021,13 @@ var require_send = __commonJS({
         }
       }
       if (this._index.length && this.hasTrailingSlash()) {
-        this.sendIndex(path6);
+        this.sendIndex(path7);
         return res;
       }
-      this.sendFile(path6);
+      this.sendFile(path7);
       return res;
     }, "pipe");
-    SendStream.prototype.send = /* @__PURE__ */ __name(function send3(path6, stat) {
+    SendStream.prototype.send = /* @__PURE__ */ __name(function send3(path7, stat) {
       var len = stat.size;
       var options = this.options;
       var opts = {};
@@ -11039,9 +11039,9 @@ var require_send = __commonJS({
         this.headersAlreadySent();
         return;
       }
-      debug('pipe "%s"', path6);
-      this.setHeader(path6, stat);
-      this.type(path6);
+      debug('pipe "%s"', path7);
+      this.setHeader(path7, stat);
+      this.type(path7);
       if (this.isConditionalGET()) {
         if (this.isPreconditionFailure()) {
           this.error(412);
@@ -11090,30 +11090,30 @@ var require_send = __commonJS({
         res.end();
         return;
       }
-      this.stream(path6, opts);
+      this.stream(path7, opts);
     }, "send");
-    SendStream.prototype.sendFile = /* @__PURE__ */ __name(function sendFile(path6) {
+    SendStream.prototype.sendFile = /* @__PURE__ */ __name(function sendFile(path7) {
       var i = 0;
       var self = this;
-      debug('stat "%s"', path6);
-      fs3.stat(path6, /* @__PURE__ */ __name(function onstat(err, stat) {
-        var pathEndsWithSep = path6[path6.length - 1] === sep2;
-        if (err && err.code === "ENOENT" && !extname(path6) && !pathEndsWithSep) {
+      debug('stat "%s"', path7);
+      fs4.stat(path7, /* @__PURE__ */ __name(function onstat(err, stat) {
+        var pathEndsWithSep = path7[path7.length - 1] === sep2;
+        if (err && err.code === "ENOENT" && !extname(path7) && !pathEndsWithSep) {
           return next(err);
         }
         if (err) return self.onStatError(err);
-        if (stat.isDirectory()) return self.redirect(path6);
+        if (stat.isDirectory()) return self.redirect(path7);
         if (pathEndsWithSep) return self.error(404);
-        self.emit("file", path6, stat);
-        self.send(path6, stat);
+        self.emit("file", path7, stat);
+        self.send(path7, stat);
       }, "onstat"));
       function next(err) {
         if (self._extensions.length <= i) {
           return err ? self.onStatError(err) : self.error(404);
         }
-        var p = path6 + "." + self._extensions[i++];
+        var p = path7 + "." + self._extensions[i++];
         debug('stat "%s"', p);
-        fs3.stat(p, function(err2, stat) {
+        fs4.stat(p, function(err2, stat) {
           if (err2) return next(err2);
           if (stat.isDirectory()) return next();
           self.emit("file", p, stat);
@@ -11122,7 +11122,7 @@ var require_send = __commonJS({
       }
       __name(next, "next");
     }, "sendFile");
-    SendStream.prototype.sendIndex = /* @__PURE__ */ __name(function sendIndex(path6) {
+    SendStream.prototype.sendIndex = /* @__PURE__ */ __name(function sendIndex(path7) {
       var i = -1;
       var self = this;
       function next(err) {
@@ -11130,9 +11130,9 @@ var require_send = __commonJS({
           if (err) return self.onStatError(err);
           return self.error(404);
         }
-        var p = join3(path6, self._index[i]);
+        var p = join4(path7, self._index[i]);
         debug('stat "%s"', p);
-        fs3.stat(p, function(err2, stat) {
+        fs4.stat(p, function(err2, stat) {
           if (err2) return next(err2);
           if (stat.isDirectory()) return next();
           self.emit("file", p, stat);
@@ -11142,10 +11142,10 @@ var require_send = __commonJS({
       __name(next, "next");
       next();
     }, "sendIndex");
-    SendStream.prototype.stream = /* @__PURE__ */ __name(function stream(path6, options) {
+    SendStream.prototype.stream = /* @__PURE__ */ __name(function stream(path7, options) {
       var self = this;
       var res = this.res;
-      var stream2 = fs3.createReadStream(path6, options);
+      var stream2 = fs4.createReadStream(path7, options);
       this.emit("stream", stream2);
       stream2.pipe(res);
       function cleanup() {
@@ -11161,17 +11161,17 @@ var require_send = __commonJS({
         self.emit("end");
       }, "onend"));
     }, "stream");
-    SendStream.prototype.type = /* @__PURE__ */ __name(function type(path6) {
+    SendStream.prototype.type = /* @__PURE__ */ __name(function type(path7) {
       var res = this.res;
       if (res.getHeader("Content-Type")) return;
-      var ext = extname(path6);
+      var ext = extname(path7);
       var type2 = mime.contentType(ext) || "application/octet-stream";
       debug("content-type %s", type2);
       res.setHeader("Content-Type", type2);
     }, "type");
-    SendStream.prototype.setHeader = /* @__PURE__ */ __name(function setHeader(path6, stat) {
+    SendStream.prototype.setHeader = /* @__PURE__ */ __name(function setHeader(path7, stat) {
       var res = this.res;
-      this.emit("headers", res, path6, stat);
+      this.emit("headers", res, path7, stat);
       if (this._acceptRanges && !res.getHeader("Accept-Ranges")) {
         debug("accept ranges");
         res.setHeader("Accept-Ranges", "bytes");
@@ -11236,9 +11236,9 @@ var require_send = __commonJS({
       return err instanceof Error ? createError(status, err, { expose: false }) : createError(status, err);
     }
     __name(createHttpError, "createHttpError");
-    function decode(path6) {
+    function decode(path7) {
       try {
-        return decodeURIComponent(path6);
+        return decodeURIComponent(path7);
       } catch (err) {
         return -1;
       }
@@ -11662,14 +11662,6 @@ var init_data_checks = __esm({
           // allow owner for user 
           user_id && { owner_id: { equals: user_id, not: null } },
           // allow acl for user 
-          user_id && role_ids?.length && {
-            acl: {
-              some: {
-                permission: { in: checkPerms },
-                role_id: { in: role_ids }
-              }
-            }
-          },
           user_id && role_ids?.length && {
             acl: {
               some: {
@@ -11857,9 +11849,6 @@ var init_streamer = __esm({
         this.isSecure = !!req.socket.encrypted;
         this.urlInfo = new URL(`https://${this.headers.host}${this.url}`);
         this.cookies = this.parseCookieString(req.headers.cookie || "");
-        if (this.cookies.getAll("session").length > 1) {
-          console.warn("Multiple session cookies found. This is very likely to cause problems. This may happen after changing the path prefix.");
-        }
       }
       // RIP Push Stream. it was a great idea.
       // async pushStream(path: string) {
@@ -14268,7 +14257,7 @@ var init_bag_file_server = __esm({
         if (!recipe_name) {
           return state.sendEmpty(404);
         }
-        const bagTiddlers = await this.prisma.recipe_bags.findMany({
+        const bags = await this.prisma.recipe_bags.findMany({
           where: { recipe: { recipe_name } },
           select: {
             position: true,
@@ -14276,36 +14265,28 @@ var init_bag_file_server = __esm({
               select: {
                 bag_id: true,
                 bag_name: true,
-                is_plugin: true,
-                tiddlers: {
-                  select: {
-                    title: true,
-                    tiddler_id: true,
-                    is_deleted: true,
-                    attachment_hash: true,
-                    fields: true
-                  },
-                  where: {
-                    is_deleted: false
-                  }
-                }
+                is_plugin: true
               }
             }
           }
         });
-        bagTiddlers.sort((a, b) => a.position - b.position);
-        const recipeTiddlers = Array.from(new Map(bagTiddlers.flatMap(
-          (bag) => bag.bag.tiddlers.map((tiddler) => [tiddler.title, { bag: bag.bag, tiddler }])
-        )).values());
+        const lastTiddlerId = await this.prisma.tiddlers.aggregate({
+          _max: { tiddler_id: true },
+          where: { bag_id: { in: bags.map((e) => e.bag.bag_id) } }
+        });
         const template = readFileSync(resolve2(this.state.config.wikiPath, "tiddlywiki5.html"), "utf8");
         const hash = createHash2("md5");
         hash.update(template);
-        hash.update(recipeTiddlers.map((e) => e.tiddler.tiddler_id).join("|"));
+        hash.update(bags.map((e) => e.bag.bag_name).join(","));
+        hash.update(`${lastTiddlerId._max.tiddler_id}`);
         const contentDigest = hash.digest("hex");
+        if ('"' + contentDigest + '"' === state.headers["if-none-match"])
+          return state.sendEmpty(304, { "x-reason": "if-none-match" });
         state.writeHead(200, {
           "Content-Type": "text/html",
           "Etag": '"' + contentDigest + '"',
-          "Cache-Control": "max-age=0, must-revalidate"
+          // TODO: WHY IS THIS DISABLED???
+          "Cache-Control": "max-age=1000, must-revalidate"
         });
         if (state.method === "HEAD") return state.end();
         var marker = `<script class="tiddlywiki-tiddler-store" type="application/json">[`, markerPos = template.indexOf(marker);
@@ -14317,7 +14298,89 @@ var init_bag_file_server = __esm({
           state.write(",\n");
         }
         __name(writeTiddler, "writeTiddler");
-        state.write(template.substring(0, markerPos + marker.length));
+        state.write(template.substring(0, markerPos));
+        if (state.config.enablePluginCache) {
+          const preloadMarkup = `
+        ${"<"}script>
+        window.$tw = window.$tw || Object.create(null);
+        $tw.preloadTiddlers = $tw.preloadTiddlers || [];
+        $tw.preloadTiddler = function(fields) {
+          $tw.preloadTiddlers.push(fields);
+        };
+        ${"</"}script>
+      `;
+          state.write(preloadMarkup);
+          const pluginMarkup = /* @__PURE__ */ __name((plugin, hash2) => `
+        <script
+          src="${state.config.pathPrefix}/$cache/${plugin}/plugin.js"
+          integrity="${hash2}"
+          crossorigin="anonymous"></script>
+      `, "pluginMarkup");
+          const plugins = [...(/* @__PURE__ */ new Set([
+            "$:/core",
+            "$:/plugins/tiddlywiki/multiwikiclient",
+            "$:/plugins/tiddlywiki/tiddlyweb",
+            "$:/themes/tiddlywiki/snowwhite",
+            "$:/themes/tiddlywiki/vanilla",
+            ...bags.map((e) => e.bag.bag_name)
+          ])).values()].filter((e) => state.tiddlerCache.tiddlerFiles.has(e)).map((e) => pluginMarkup(
+            state.tiddlerCache.tiddlerFiles.get(e),
+            state.tiddlerCache.tiddlerHashes.get(e)
+          ));
+          state.write(plugins.join("\n"));
+        }
+        state.write(marker);
+        const bagOrder = new Map(bags.map((e) => [e.bag.bag_id, e.position]));
+        const bagIDs = bags.filter((e) => !state.tiddlerCache.tiddlerFiles.has(e.bag.bag_name)).map((e) => e.bag.bag_id);
+        await this.serveStoreTiddlers(bagIDs, bagOrder, writeTiddler);
+        writeTiddler({
+          title: "$:/config/multiwikiclient/recipe",
+          text: recipe_name
+        });
+        writeTiddler({
+          title: "$:/state/multiwikiclient/recipe/last_tiddler_id",
+          text: (lastTiddlerId._max.tiddler_id ?? 0).toString()
+        });
+        writeTiddler({
+          title: "$:/config/multiwikiclient/host",
+          text: "$protocol$//$host$" + this.state.config.pathPrefix + "/"
+        });
+        state.write(template.substring(markerPos + marker.length));
+        return state.end();
+      }
+      async serveStoreTiddlers(bagKeys, bagOrder, writeTiddler) {
+        const bagTiddlers = await this.prisma.bags.findMany({
+          where: { bag_id: { in: bagKeys } },
+          select: {
+            bag_id: true,
+            bag_name: true,
+            is_plugin: true,
+            description: true,
+            owner_id: true,
+            tiddlers: {
+              select: {
+                title: true,
+                tiddler_id: true,
+                is_deleted: true,
+                attachment_hash: true,
+                fields: true
+              },
+              where: {
+                is_deleted: false,
+                bag: { is_plugin: false }
+              }
+            }
+          }
+        });
+        if (!bagTiddlers.every((e) => bagOrder.has(e.bag_id))) {
+          console.log(bagTiddlers.map((e) => e.bag_id));
+          console.log(bagOrder);
+          throw new Error("Bags missing from bag order");
+        }
+        bagTiddlers.sort((a, b) => bagOrder.get(b.bag_id) - bagOrder.get(a.bag_id));
+        const recipeTiddlers = Array.from(new Map(bagTiddlers.flatMap(
+          (bag) => bag.tiddlers.map((tiddler) => [tiddler.title, { bag, tiddler }])
+        )).values());
         const bagInfo = {}, revisionInfo = {};
         for (const recipeTiddlerInfo of recipeTiddlers) {
           const { title, tiddler_id, attachment_hash, fields } = recipeTiddlerInfo.tiddler;
@@ -14346,21 +14409,6 @@ var init_bag_file_server = __esm({
           text: JSON.stringify(revisionInfo),
           type: "application/json"
         });
-        writeTiddler({
-          title: "$:/config/multiwikiclient/recipe",
-          text: recipe_name
-        });
-        const lastTiddlerId = await this.prisma.tiddlers.aggregate({ _max: { tiddler_id: true } });
-        writeTiddler({
-          title: "$:/state/multiwikiclient/recipe/last_tiddler_id",
-          text: (lastTiddlerId._max.tiddler_id ?? 0).toString()
-        });
-        writeTiddler({
-          title: "$:/config/multiwikiclient/host",
-          text: "$protocol$//$host$" + this.state.config.pathPrefix + "/"
-        });
-        state.write(template.substring(markerPos + marker.length));
-        return state.end();
       }
     };
     __name(_TiddlerServer, "TiddlerServer");
@@ -14627,26 +14675,27 @@ var init_router_tiddlers = __esm({
   }
 });
 
-// src/routes/tw-test.ts
+// src/routes/tw-routes.ts
 import { TiddlyWiki } from "tiddlywiki";
 function DocsRoute(parent, config) {
   const wikiRouter = new TWRouter(config);
+  console.log("The mws-docs tiddlywiki is being served at " + config.pathPrefix + "/mws-docs");
   parent.defineRoute({
     method: ["OPTIONS", "GET", "HEAD", "POST", "PUT", "DELETE"],
     bodyFormat: "stream",
-    path: /^\/mws(\/|$)/,
+    path: /^\/mwsp-docs(\/|$)/,
     pathParams: []
   }, async (state) => {
-    if (state.urlInfo.pathname === "/mws") throw state.redirect("/mws/");
+    if (state.urlInfo.pathname === "/mws-docs") throw state.redirect("/mws-docs/");
     const { req, res } = state.streamer;
-    if (req.url === "/mws") req.url = "/mws/";
+    if (req.url === "/mws-docs") req.url = "/mws-docs/";
     wikiRouter.twserver.requestHandler(req, res, {});
     return new Promise((r, c) => res.on("finish", r).on("error", c));
   });
 }
 var _TWRouter, TWRouter;
-var init_tw_test = __esm({
-  "src/routes/tw-test.ts"() {
+var init_tw_routes = __esm({
+  "src/routes/tw-routes.ts"() {
     "use strict";
     init_esm_shims();
     __name(DocsRoute, "DocsRoute");
@@ -14723,7 +14772,6 @@ async function RootRoute(root, config) {
         return state.sendJSON(200, await fn.call(table, state.data.arg));
       });
     });
-  await importEsbuild(root);
 }
 async function importEsbuild(root) {
   root.defineRoute({
@@ -14759,7 +14807,7 @@ var init_routes = __esm({
     init_utils2();
     init_managers();
     init_router_tiddlers();
-    init_tw_test();
+    init_tw_routes();
     init_();
     __name(RootRoute, "RootRoute");
     __name(importEsbuild, "importEsbuild");
@@ -14944,7 +14992,10 @@ var init_setupDevServer = __esm({
 
 // src/routes/cache.ts
 import { ok as ok4 } from "assert";
-async function startupCache(commander2) {
+import * as fs2 from "fs";
+import * as path3 from "path";
+import * as crypto from "crypto";
+async function startupCache(rootRoute2, commander2) {
   const $tw2 = commander2.$tw;
   const bootTiddlers = $tw2.loadTiddlersFromPath($tw2.boot.bootPath).flatMap((file) => file.tiddlers);
   const coreTiddler = $tw2.loadPluginFolder($tw2.boot.corePath);
@@ -14954,7 +15005,71 @@ async function startupCache(commander2) {
     [coreTiddler.title, JSON.stringify(coreTiddler)]
   ]);
   const tiddlerFileCache = /* @__PURE__ */ new Map();
-  return { tiddlerFileCache, tiddlerMemoryCache };
+  const { tiddlerFiles, tiddlerHashes } = await importTW5(path3.join($tw2.boot.corePath, ".."), commander2.cachePath, "client", $tw2);
+  rootRoute2.defineRoute({
+    method: ["GET", "HEAD"],
+    path: /^\/\$cache\/(.*)\/plugin\.js$/,
+    bodyFormat: "ignore",
+    pathParams: ["plugin"]
+  }, async (state) => {
+    ZodAssert.pathParams(state, (z5) => ({
+      plugin: z5.string()
+    }));
+    return state.sendFile(200, {}, {
+      root: commander2.cachePath,
+      reqpath: state.pathParams.plugin + "/plugin.js"
+    });
+  });
+  return { tiddlerFileCache, tiddlerMemoryCache, tiddlerFiles, tiddlerHashes };
+}
+async function importTW5(twFolder, cacheFolder, type, $tw2) {
+  const readLevel = /* @__PURE__ */ __name((d) => {
+    return fs2.readdirSync(path3.join(twFolder, d)).filter((e) => !$tw2.boot.excludeRegExp.test(e)).map((e) => path3.join(d, e));
+  }, "readLevel");
+  const plugins = [
+    ...[
+      ...[
+        "plugins",
+        "themes"
+      ].flatMap(readLevel),
+      "languages"
+    ].flatMap(readLevel),
+    "core"
+  ].map((e) => {
+    const oldPath = path3.join(twFolder, e);
+    const relativePluginPath = path3.normalize(path3.relative(twFolder, oldPath));
+    return [oldPath, relativePluginPath];
+  });
+  plugins.push([
+    dist_resolve("../plugins/client"),
+    "plugins/mws/client"
+  ]);
+  const hashes = {};
+  const tiddlerFiles = /* @__PURE__ */ new Map();
+  const tiddlerHashes = /* @__PURE__ */ new Map();
+  plugins.forEach(([oldPath, relativePluginPath]) => {
+    const plugin = $tw2.loadPluginFolder(oldPath);
+    const newPath = path3.join(cacheFolder, relativePluginPath);
+    fs2.mkdirSync(newPath, { recursive: true });
+    if (plugin && plugin.title) {
+      plugin.text = JSON.stringify(JSON.parse(plugin.text));
+      if (type === "server") {
+        plugin.tiddlers = JSON.parse(plugin.text).tiddlers;
+        delete plugin.text;
+        fs2.writeFileSync(path3.join(newPath, "plugin.info"), JSON.stringify(plugin));
+      } else if (type === "client") {
+        let js = Buffer.from(`$tw.preloadTiddler(${JSON.stringify(plugin)});`, "utf8");
+        let hash = crypto.createHash("sha384").update(js).digest("base64");
+        fs2.writeFileSync(path3.join(newPath, "plugin.js"), js);
+        tiddlerFiles.set(plugin.title, relativePluginPath);
+        tiddlerHashes.set(plugin.title, "sha384-" + hash);
+      }
+    } else {
+      console.log("Info: No plugin found at", oldPath);
+    }
+  });
+  fs2.writeFileSync(path3.join(cacheFolder, "hashes.json"), JSON.stringify(hashes, null, 2));
+  return { tiddlerFiles, tiddlerHashes };
 }
 var init_cache = __esm({
   "src/routes/cache.ts"() {
@@ -14962,6 +15077,7 @@ var init_cache = __esm({
     init_esm_shims();
     init_utils2();
     __name(startupCache, "startupCache");
+    __name(importTW5, "importTW5");
   }
 });
 
@@ -14982,10 +15098,10 @@ function defineRoute(parent, route, handler) {
   route.handler = handler;
   return route;
 }
-function zodRoute(method, path5, zodPathParams, bodyFormat, zodRequest, inner) {
+function zodRoute(method, path6, zodPathParams, bodyFormat, zodRequest, inner) {
   return {
     method,
-    path: path5,
+    path: path6,
     bodyFormat,
     inner,
     zodRequest,
@@ -15056,7 +15172,8 @@ var init_router = __esm({
         });
         await commander2.SessionManager.defineRoutes(rootRoute2);
         await RootRoute(rootRoute2, commander2.siteConfig);
-        const cache = await startupCache(commander2);
+        const cache = await startupCache(rootRoute2, commander2);
+        await importEsbuild(rootRoute2);
         return new _Router(rootRoute2, commander2, cache);
       }
       get pathPrefix() {
@@ -15189,11 +15306,11 @@ var init_router = __esm({
     registerZodRoutes = /* @__PURE__ */ __name((root, router, keys) => {
       keys.forEach((key) => {
         const route = router[key];
-        const { method, path: path5, bodyFormat, zodPathParams, zodRequest, inner } = route;
-        const pathParams = path5.split("/").filter((e) => e.startsWith(":")).map((e) => e.substring(1));
-        if (!path5.startsWith("/")) throw new Error(`Path ${path5} must start with a forward slash`);
+        const { method, path: path6, bodyFormat, zodPathParams, zodRequest, inner } = route;
+        const pathParams = path6.split("/").filter((e) => e.startsWith(":")).map((e) => e.substring(1));
+        if (!path6.startsWith("/")) throw new Error(`Path ${path6} must start with a forward slash`);
         if (key.startsWith(":")) throw new Error(`Key ${key} must not start with a colon`);
-        const pathregex = "^" + path5.split("/").map(
+        const pathregex = "^" + path6.split("/").map(
           (e) => e === "$key" ? key : e.startsWith(":") ? "([^/]+)" : e
         ).join("\\/") + "$";
         root.defineRoute({
@@ -15298,13 +15415,13 @@ var init_tiddlywiki = __esm({
 });
 
 // src/services/sessions.ts
-import { createHash as createHash4, randomBytes } from "node:crypto";
-function zodSession(path5, zodRequest, inner) {
+import { createHash as createHash5, randomBytes } from "node:crypto";
+function zodSession(path6, zodRequest, inner) {
   return {
-    ...zodRoute(["POST"], path5, (z5) => ({}), "json", zodRequest, async (state) => {
+    ...zodRoute(["POST"], path6, (z5) => ({}), "json", zodRequest, async (state) => {
       return state.$transaction(async (prisma) => await inner(state, prisma));
     }),
-    path: path5
+    path: path6
   };
 }
 async function createSession(prisma, user_id, session_key) {
@@ -15319,7 +15436,7 @@ async function createSession(prisma, user_id, session_key) {
   }).then(({ session_id: session_id2 }) => session_id2);
 }
 function assertSignature({ session_id, signature, session_key }) {
-  const hash = createHash4("sha256").update(session_key + session_id).digest("base64");
+  const hash = createHash5("sha256").update(session_key + session_id).digest("base64");
   if (hash !== signature) throw "Invalid session signature.";
 }
 var SessionKeyMap, _SessionManager, SessionManager;
@@ -15412,17 +15529,17 @@ var init_sessions = __esm({
         registerZodRoutes(root, new _SessionManager(), Object.keys(SessionKeyMap));
       }
       static async parseIncomingRequest(streamer, router) {
-        const sessionId = streamer.cookies.get("session");
-        const session = sessionId && await router.engine.sessions.findUnique({
-          where: { session_id: sessionId },
-          select: { user: { select: { user_id: true, username: true, roles: { select: { role_id: true } } } } }
+        const sessionId = streamer.cookies.getAll("session");
+        const session = sessionId && await router.engine.sessions.findFirst({
+          where: { session_id: { in: sessionId } },
+          select: { session_id: true, user: { select: { user_id: true, username: true, roles: { select: { role_id: true } } } } }
         });
         if (sessionId && session) return {
           user_id: session.user.user_id,
           username: session.user.username,
           isAdmin: session.user.roles.some((e) => e.role_id === 1),
           role_ids: session.user.roles.map((e) => e.role_id),
-          sessionId,
+          sessionId: session.session_id,
           isLoggedIn: true
         };
         else return {
@@ -15443,8 +15560,8 @@ var init_sessions = __esm({
 });
 
 // src/services/attachments.ts
-import * as path3 from "path";
-import * as fs2 from "fs";
+import * as path4 from "path";
+import * as fs3 from "fs";
 var import_sjcl2, $tw, _AttachmentService, AttachmentService;
 var init_attachments = __esm({
   "src/services/attachments.ts"() {
@@ -15543,15 +15660,15 @@ var init_attachments = __esm({
       async saveAttachment(options) {
         const contentHash = import_sjcl2.default.codec.hex.fromBits($tw.sjcl.hash.sha256.hash(options.text)).slice(0, 64).toString();
         const contentTypeInfo = this.config.contentTypeInfo[options.type] || this.config.contentTypeInfo["application/octet-stream"];
-        const attachmentPath = path3.resolve(this.config.storePath, "files", contentHash);
+        const attachmentPath = path4.resolve(this.config.storePath, "files", contentHash);
         createDirectory(attachmentPath);
         const dataFilename = "data" + contentTypeInfo.extension;
-        fs2.writeFileSync(path3.resolve(attachmentPath, dataFilename), options.text, contentTypeInfo.encoding);
-        this.writeMetaFile(fs2, path3, attachmentPath, options, contentHash, dataFilename);
+        fs3.writeFileSync(path4.resolve(attachmentPath, dataFilename), options.text, contentTypeInfo.encoding);
+        this.writeMetaFile(fs3, path4, attachmentPath, options, contentHash, dataFilename);
         return contentHash;
       }
-      writeMetaFile(fs3, path5, attachmentPath, options, contentHash, dataFilename) {
-        fs3.writeFileSync(path5.resolve(attachmentPath, "meta.json"), JSON.stringify({
+      writeMetaFile(fs4, path6, attachmentPath, options, contentHash, dataFilename) {
+        fs4.writeFileSync(path6.resolve(attachmentPath, "meta.json"), JSON.stringify({
           _canonical_uri: options._canonical_uri,
           created: (/* @__PURE__ */ new Date()).toISOString(),
           modified: (/* @__PURE__ */ new Date()).toISOString(),
@@ -15565,11 +15682,11 @@ var init_attachments = __esm({
       */
       async adoptAttachment({ incomingFilepath, type, hash, _canonical_uri }) {
         const contentTypeInfo = this.config.contentTypeInfo[type] || this.config.contentTypeInfo["application/octet-stream"];
-        const attachmentPath = path3.resolve(this.config.storePath, "files", hash);
+        const attachmentPath = path4.resolve(this.config.storePath, "files", hash);
         createDirectory(attachmentPath);
-        const dataFilename = "data" + contentTypeInfo.extension, dataFilepath = path3.resolve(attachmentPath, dataFilename);
-        fs2.renameSync(incomingFilepath, dataFilepath);
-        fs2.writeFileSync(path3.resolve(attachmentPath, "meta.json"), JSON.stringify({
+        const dataFilename = "data" + contentTypeInfo.extension, dataFilepath = path4.resolve(attachmentPath, dataFilename);
+        fs3.renameSync(incomingFilepath, dataFilepath);
+        fs3.writeFileSync(path4.resolve(attachmentPath, "meta.json"), JSON.stringify({
           _canonical_uri,
           created: (/* @__PURE__ */ new Date()).toISOString(),
           modified: (/* @__PURE__ */ new Date()).toISOString(),
@@ -15586,15 +15703,15 @@ var init_attachments = __esm({
       */
       async getAttachmentStream(content_hash) {
         if (!this.isValidAttachmentName(content_hash)) return null;
-        const attachmentPath = path3.resolve(this.config.storePath, "files", content_hash);
-        const metaJsonPath = path3.resolve(attachmentPath, "meta.json");
-        if (!fs2.existsSync(metaJsonPath) || !fs2.statSync(metaJsonPath).isFile()) return null;
-        const meta = tryParseJSON(fs2.readFileSync(metaJsonPath, "utf8"));
+        const attachmentPath = path4.resolve(this.config.storePath, "files", content_hash);
+        const metaJsonPath = path4.resolve(attachmentPath, "meta.json");
+        if (!fs3.existsSync(metaJsonPath) || !fs3.statSync(metaJsonPath).isFile()) return null;
+        const meta = tryParseJSON(fs3.readFileSync(metaJsonPath, "utf8"));
         if (!meta) return null;
-        const dataFilepath = path3.resolve(attachmentPath, meta.filename);
-        if (!fs2.existsSync(dataFilepath) || !fs2.statSync(dataFilepath).isFile()) return null;
+        const dataFilepath = path4.resolve(attachmentPath, meta.filename);
+        if (!fs3.existsSync(dataFilepath) || !fs3.statSync(dataFilepath).isFile()) return null;
         return {
-          stream: fs2.createReadStream(dataFilepath),
+          stream: fs3.createReadStream(dataFilepath),
           type: meta.type
         };
       }
@@ -15603,20 +15720,20 @@ var init_attachments = __esm({
       Returns the size in bytes, or null if the file doesn't exist.
       */
       async getAttachmentFileSize(content_hash) {
-        const attachmentPath = path3.resolve(this.config.storePath, "files", content_hash);
-        const metaJsonPath = path3.resolve(attachmentPath, "meta.json");
-        if (!(fs2.existsSync(metaJsonPath) && fs2.statSync(metaJsonPath).isFile())) return null;
-        const meta = tryParseJSON(fs2.readFileSync(metaJsonPath, "utf8"));
+        const attachmentPath = path4.resolve(this.config.storePath, "files", content_hash);
+        const metaJsonPath = path4.resolve(attachmentPath, "meta.json");
+        if (!(fs3.existsSync(metaJsonPath) && fs3.statSync(metaJsonPath).isFile())) return null;
+        const meta = tryParseJSON(fs3.readFileSync(metaJsonPath, "utf8"));
         if (!meta) return null;
-        const dataFilepath = path3.resolve(attachmentPath, meta.filename);
-        if (!(fs2.existsSync(dataFilepath) && fs2.statSync(dataFilepath).isFile())) return null;
-        return fs2.statSync(dataFilepath).size;
+        const dataFilepath = path4.resolve(attachmentPath, meta.filename);
+        if (!(fs3.existsSync(dataFilepath) && fs3.statSync(dataFilepath).isFile())) return null;
+        return fs3.statSync(dataFilepath).size;
       }
       async getAttachmentMetadata(content_hash) {
-        const attachmentPath = path3.resolve(this.config.storePath, "files", content_hash);
-        const metaJsonPath = path3.resolve(attachmentPath, "meta.json");
-        if (!fs2.existsSync(metaJsonPath)) return null;
-        return JSON.parse(fs2.readFileSync(metaJsonPath, "utf8"));
+        const attachmentPath = path4.resolve(this.config.storePath, "files", content_hash);
+        const metaJsonPath = path4.resolve(attachmentPath, "meta.json");
+        if (!fs3.existsSync(metaJsonPath)) return null;
+        return JSON.parse(fs3.readFileSync(metaJsonPath, "utf8"));
       }
     };
     __name(_AttachmentService, "AttachmentService");
@@ -16772,8 +16889,8 @@ var require_command = __commonJS({
     init_esm_shims();
     var EventEmitter = __require("node:events").EventEmitter;
     var childProcess = __require("node:child_process");
-    var path5 = __require("node:path");
-    var fs3 = __require("node:fs");
+    var path6 = __require("node:path");
+    var fs4 = __require("node:fs");
     var process2 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -17754,7 +17871,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs3.existsSync(executableFile)) return;
+        if (fs4.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -17772,11 +17889,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path5.resolve(baseDir, baseName);
-          if (fs3.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path5.extname(baseName))) return void 0;
+          const localBin = path6.resolve(baseDir, baseName);
+          if (fs4.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path6.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs3.existsSync(`${localBin}${ext}`)
+            (ext) => fs4.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -17789,21 +17906,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs3.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs4.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path5.resolve(
-            path5.dirname(resolvedScriptPath),
+          executableDir = path6.resolve(
+            path6.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path5.basename(
+            const legacyName = path6.basename(
               this._scriptPath,
-              path5.extname(this._scriptPath)
+              path6.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -17814,7 +17931,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path5.extname(executableFile));
+        launchWithNode = sourceExt.includes(path6.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -18662,7 +18779,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path5.basename(filename, path5.extname(filename));
+        this._name = path6.basename(filename, path6.extname(filename));
         return this;
       }
       /**
@@ -18676,9 +18793,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path6) {
-        if (path6 === void 0) return this._executableDir;
-        this._executableDir = path6;
+      executableDir(path7) {
+        if (path7 === void 0) return this._executableDir;
+        this._executableDir = path7;
         return this;
       }
       /**
@@ -19093,12 +19210,12 @@ __export(render_tiddlywiki5_exports, {
   info: () => info2
 });
 import { resolve as resolve6 } from "node:path";
-var writeFileSync3, info2, _Command2, Command3;
+var writeFileSync4, info2, _Command2, Command3;
 var init_render_tiddlywiki5 = __esm({
   "src/commands/render-tiddlywiki5.ts"() {
     "use strict";
     init_esm_shims();
-    ({ writeFileSync: writeFileSync3 } = __require("fs"));
+    ({ writeFileSync: writeFileSync4 } = __require("fs"));
     info2 = {
       name: "render-tiddlywiki5",
       description: "Render the TiddlyWiki5 HTML file",
@@ -19114,12 +19231,13 @@ var init_render_tiddlywiki5 = __esm({
       async execute() {
         const result = this.commander.$tw.wiki.renderTiddler("text/plain", "$:/core/templates/tiddlywiki5.html", {
           variables: {
-            saveTiddlerFilter: `
-          $:/boot/boot.css
-          $:/boot/boot.js
-          $:/boot/bootprefix.js
+            // the boot and library tiddlers get rendered into the page
+            // this list gets saved in the store array
+            // we have to render at least one tiddler
+            saveTiddlerFilter: this.commander.siteConfig.enablePluginCache ? `
+          $:/temp/nothing
+        ` : `
           $:/core
-          $:/library/sjcl.js
           $:/plugins/tiddlywiki/tiddlyweb
           $:/plugins/tiddlywiki/multiwikiclient
           $:/themes/tiddlywiki/snowwhite
@@ -19128,7 +19246,7 @@ var init_render_tiddlywiki5 = __esm({
           }
         });
         const filepath = resolve6(this.commander.wikiPath, "tiddlywiki5.html");
-        writeFileSync3(filepath, result);
+        writeFileSync4(filepath, result);
       }
     };
     __name(_Command2, "Command");
@@ -19147,11 +19265,11 @@ function makePluginBagName(type, publisher, name) {
   return "$:/" + type + "/" + (publisher ? publisher + "/" : "") + name;
 }
 function loadWikiFolder({ $tw: $tw2, store, ...options }) {
-  const path5 = __require("path"), fs3 = __require("fs");
-  const wikiInfoPath = path5.resolve(options.wikiPath, $tw2.config.wikiInfo);
+  const path6 = __require("path"), fs4 = __require("fs");
+  const wikiInfoPath = path6.resolve(options.wikiPath, $tw2.config.wikiInfo);
   let wikiInfo;
-  if (fs3.existsSync(wikiInfoPath)) {
-    wikiInfo = $tw2.utils.parseJSONSafe(fs3.readFileSync(wikiInfoPath, "utf8"), function() {
+  if (fs4.existsSync(wikiInfoPath)) {
+    wikiInfo = $tw2.utils.parseJSONSafe(fs4.readFileSync(wikiInfoPath, "utf8"), function() {
       return null;
     });
   }
@@ -19178,7 +19296,7 @@ function loadWikiFolder({ $tw: $tw2, store, ...options }) {
     with_acl: true
   });
   recipeList.reverse();
-  const tiddler_files_path = path5.resolve(options.wikiPath, $tw2.config.wikiTiddlersSubDir);
+  const tiddler_files_path = path6.resolve(options.wikiPath, $tw2.config.wikiTiddlersSubDir);
   const tiddlersFromPath = $tw2.loadTiddlersFromPath(
     resolve7($tw2.boot.corePath, $tw2.config.editionsPath, tiddler_files_path)
   );
@@ -19360,7 +19478,7 @@ __export(load_archive_exports, {
   Command: () => Command6,
   info: () => info5
 });
-import { join as join2, resolve as resolve9 } from "path";
+import { join as join3, resolve as resolve9 } from "path";
 import * as _fsp2 from "fs/promises";
 import { PrismaClientKnownRequestError } from "@prisma/client/runtime/library";
 import { existsSync as existsSync3 } from "fs";
@@ -19465,7 +19583,7 @@ var init_load_archive = __esm({
         });
       }
       async restoreBag(folder, prisma) {
-        const bagInfo = JSON.parse(await fsp2.readFile(join2(folder, "meta.json"), "utf8"));
+        const bagInfo = JSON.parse(await fsp2.readFile(join3(folder, "meta.json"), "utf8"));
         await prisma.bags.create({
           data: {
             bag_id: bagInfo.bag_id,
@@ -19476,10 +19594,10 @@ var init_load_archive = __esm({
             acl: { createMany: { data: bagInfo.acl } }
           }
         });
-        const tiddlerFiles = await fsp2.readdir(join2(folder, "tiddlers"));
+        const tiddlerFiles = await fsp2.readdir(join3(folder, "tiddlers"));
         const tiddlers = await Promise.all(tiddlerFiles.map(async (tiddlerFilename) => {
           if (!tiddlerFilename.endsWith(".json")) return;
-          const value = await fsp2.readFile(join2(folder, "tiddlers", tiddlerFilename), "utf8");
+          const value = await fsp2.readFile(join3(folder, "tiddlers", tiddlerFilename), "utf8");
           return JSON.parse(value);
         }));
         await prisma.tiddlers.createMany({
@@ -19563,7 +19681,7 @@ var init_load_archive = __esm({
         });
       }
       async restoreBag(folder, prisma) {
-        const bagInfo = JSON.parse(await fsp2.readFile(join2(folder, "meta.json"), "utf8"));
+        const bagInfo = JSON.parse(await fsp2.readFile(join3(folder, "meta.json"), "utf8"));
         await prisma.bags.create({
           data: {
             bag_id: bagInfo.bag_id,
@@ -19574,10 +19692,10 @@ var init_load_archive = __esm({
             acl: { createMany: { data: bagInfo.acl } }
           }
         });
-        const tiddlerFiles = await fsp2.readdir(join2(folder, "tiddlers"));
+        const tiddlerFiles = await fsp2.readdir(join3(folder, "tiddlers"));
         const tiddlers = await Promise.all(tiddlerFiles.map(async (tiddlerFilename) => {
           if (!tiddlerFilename.endsWith(".json")) return;
-          const value = await fsp2.readFile(join2(folder, "tiddlers", tiddlerFilename), "utf8");
+          const value = await fsp2.readFile(join3(folder, "tiddlers", tiddlerFilename), "utf8");
           return JSON.parse(value);
         }));
         await prisma.tiddlers.createMany({
@@ -19981,7 +20099,7 @@ var init_commands = __esm({
 // src/db/sqlite-adapter.ts
 import { PrismaBetterSQLite3 } from "@prisma/adapter-better-sqlite3";
 import { readdir, readFile as readFile2 } from "fs/promises";
-import { createHash as createHash5, randomUUID } from "crypto";
+import { createHash as createHash6, randomUUID } from "crypto";
 import { existsSync as existsSync5 } from "fs";
 var _SqliteAdapter, SqliteAdapter;
 var init_sqlite_adapter = __esm({
@@ -20030,7 +20148,7 @@ var init_sqlite_adapter = __esm({
         const new_migrations = migrations.filter((m) => !applied_migrations.has(m) && m !== "migration_lock.toml");
         if (!new_migrations.length) return;
         function generateChecksum(fileContent) {
-          return createHash5("sha256").update(fileContent).digest("hex");
+          return createHash6("sha256").update(fileContent).digest("hex");
         }
         __name(generateChecksum, "generateChecksum");
         console.log("New migrations found", new_migrations);
@@ -20060,9 +20178,9 @@ var init_sqlite_adapter = __esm({
 });
 
 // src/commander.ts
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 import { PrismaClient as PrismaClient2 } from "@prisma/client";
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4 } from "node:fs";
 import { ok as ok7 } from "node:assert";
 var _StartupCommander, StartupCommander, _Commander, Commander;
 var init_commander = __esm({
@@ -20088,12 +20206,12 @@ var init_commander = __esm({
           ok7(!config.config.pathPrefix.endsWith("/"), "pathPrefix must not end with a slash");
         }
         this.wikiPath = config.wikiPath;
-        this.storePath = path4.resolve(this.wikiPath, "store");
-        this.databasePath = path4.resolve(this.storePath, "database.sqlite");
-        this.outputPath = path4.resolve($tw2.boot.wikiPath, $tw2.config.wikiOutputSubDir);
-        this.cachePath = path4.resolve(this.wikiPath, "cache");
+        this.storePath = path5.resolve(this.wikiPath, "store");
+        this.databasePath = path5.resolve(this.storePath, "database.sqlite");
+        this.outputPath = path5.resolve($tw2.boot.wikiPath, $tw2.config.wikiOutputSubDir);
+        this.cachePath = path5.resolve(this.wikiPath, "cache");
         if (!existsSync6(this.storePath)) {
-          mkdirSync2(this.storePath, { recursive: true });
+          mkdirSync3(this.storePath, { recursive: true });
           this.setupRequired = true;
         }
         this.siteConfig = {
@@ -20375,7 +20493,7 @@ var init_PasswordService = __esm({
 
 // src/server.ts
 import * as opaque2 from "@serenity-kit/opaque";
-import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
 import { resolve as resolve12 } from "node:path";
 async function startServer(config) {
   await opaque2.ready;
@@ -20383,7 +20501,7 @@ async function startServer(config) {
     throw new Error("passwordMasterKeyFile must be a string or number");
   }
   if (typeof config.passwordMasterKeyFile === "string" && config.passwordMasterKeyFile && !existsSync7(config.passwordMasterKeyFile)) {
-    writeFileSync4(config.passwordMasterKeyFile, opaque2.server.createSetup());
+    writeFileSync5(config.passwordMasterKeyFile, opaque2.server.createSetup());
     console.log("Password master key created at", config.passwordMasterKeyFile);
   }
   const passwordMasterKey = readFileSync5(config.passwordMasterKeyFile, "utf8").trim();