@activeledger/activestorage 4.5.12 → 4.5.14

package/src/selfhost.ts

@@ -1,1078 +0,0 @@
-/*
- * MIT License (MIT)
- * Copyright (c) 2018 Activeledger
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-import * as http from "http";
-import * as path from "path";
-import { promises as fsPromises } from "fs";
-import { randomUUID } from "crypto";
-import { ActiveHttpd, IActiveHttpIncoming } from "@activeledger/httpd";
-import { LevelMe } from "./levelme";
-//import { Socket } from "net";
-import { SSE } from "./sse";
-import { ActiveLogger } from "@activeledger/activelogger";
-import { IActiveHttpResponse } from "@activeledger/httpd/lib/httpd";
-
-(function () {
-  const fauxtonCache: { [key: string]: { mime: string; data: Buffer } } = {};
-  // Fauxton Path
-  const FAUXTON_PATH = __dirname + "/fauxton/";
-
-  // Directory Prefix
-  const DIR_PREFIX = "./" + process.argv[2] + "/";
-
-  // Listening Port
-  const PORT = process.argv[3];
-
-  // Data Storage Engine Provider, level provides backwards compatiblility
-  const DS_PROVIDER = process.argv[4] || "level";
-
-  // Database Connection Cache
-  let dbCache: { [index: string]: LevelMe } = {};
-
-  // Track if we are shutting down
-  let isShuttingDown = false;
-
-  /**
-   * Graceful Shutdown
-   *
-   * @param {ActiveHttpd} httpd host
-   */
-  const terminate = async (host: ActiveHttpd) => {
-    if (!isShuttingDown) {
-      isShuttingDown = true;
-      host.shutdown();
-      
-      // Close all databases
-      const dbNames = Object.keys(dbCache);
-      for (const name of dbNames) {
-        try {
-          await dbCache[name].close();
-          ActiveLogger.info(`Closed database: ${name}`);
-        } catch (err) {
-          ActiveLogger.error(`Error closing database ${name}:`, err);
-        }
-      }
-      process.exit(0);
-    }
-  }
-
-  /**
-   * Manages Pouch Connections
-   *
-   * @param {string} name
-   * @returns
-   */
-  const getDB = (name: string): LevelMe => {
-    // Must start with activeledger (will cause problem with config need to resolve)
-    if (!name.startsWith("activeledger")) {
-      throw new Error(`invalid database - ${name}`);
-    }
-    if (!dbCache[name]) {
-      try {
-        dbCache[name] = new LevelMe(DIR_PREFIX, name, DS_PROVIDER);
-      } catch (err) {
-        throw err;
-      }
-    } else {
-    }
-    return dbCache[name];
-  };
-
-  /**
-   * Fast uuidV4 Generator
-   * Credit : https://gist.github.com/jed/982883
-   *
-   * @param {number} [a]
-   * @returns {number}
-   */
-  const uuidGenV4 = (): string => randomUUID();
-
-  /**
-   * Checks for the existant of _id if not ads it and returns
-   *
-   * @param {*} doc
-   * @returns {*}
-   */
-  const checkDoc = (doc: any): any => {
-    if (!doc._id) doc._id = uuidGenV4();
-    return doc;
-  };
-
-  // Create Light Server
-  let http = new ActiveHttpd();
-
-  // Attempt better shutdown
-  process.on("SIGINT", () => {
-    terminate(http);
-  });
-  process.on("SIGTERM", () => {
-    terminate(http);
-  });
-  process.on("SIGQUIT", () => {
-    terminate(http);
-  });
-
-
-  // A hand-rolled PID-file "already running" check used to live here:
-  // record our PID on start, and on the next start, if a previous PID file
-  // exists and `process.kill(pid, 0)` finds *any* live process with that
-  // PID, refuse to start. That's unreliable the moment PIDs get reused,
-  // which happens on every container restart (each gets a fresh, small PID
-  // namespace) and eventually on bare metal too - a stale recorded PID
-  // just needs to coincide with some unrelated process for this to produce
-  // a false "Instance already running" that no amount of restarting fixes,
-  // since the file was also never cleaned up except on a graceful
-  // SIGINT/SIGTERM/SIGQUIT (see terminate() above) - a SIGKILL or crash
-  // left it behind for good. Reproduced live: two nodes' storage refused
-  // to restart after being recreated mid-session, in full isolation, with
-  // no other process touching the same data - deleting the stale PID file
-  // was the only fix.
-  //
-  // Removed rather than patched to clean up more reliably: LevelDB (via
-  // LevelMe below) already takes a real OS-level advisory lock on its own
-  // LOCK file per database when opened, which the kernel releases
-  // automatically no matter how the holding process dies - no cleanup
-  // logic needed, and it actually enforces single-writer correctness
-  // instead of approximating it by PID. This custom check was redundant
-  // with that at best, actively wrong at worst.
-
-  http.use("/", "GET", () => {
-    return {
-      activeledger: "Welcome to Activeledger data!",
-      adapters: ["levelme"],
-      engine: DS_PROVIDER,
-    };
-  });
-
-  // Standard Session
-  http.use("_session", "GET", () => {
-    return { ok: true, userCtx: { name: null, roles: ["_admin"] } };
-  });
-
-  // List all databases
-  http.use("_all_dbs", "GET", async () => {
-    // Check to see if it is a directory and not a special directory
-    const files = await fsPromises.readdir(DIR_PREFIX);
-    // Same pattern deleteDb() below already uses - stat every entry
-    // concurrently instead of one at a time.
-    const stats = await Promise.all(
-      files.map((file) => fsPromises.lstat(DIR_PREFIX + file))
-    );
-    const dbs = files.filter(
-      (file, i) =>
-        stats[i].isDirectory() &&
-        file !== process.argv[2] &&
-        file !== "pouch__all_dbs__" &&
-        file !== "_replicator" &&
-        !file.includes("-mrview-")
-    );
-
-    // Return directories
-    return dbs;
-  });
-
-  // Get Database Info
-  http.use("*", "GET", async (incoming: IActiveHttpIncoming) => {
-    // Get Database
-    let db = getDB(incoming.url[0]);
-    let info = await db.info();
-
-    // Now add data_size
-    const files = await fsPromises.readdir(DIR_PREFIX + incoming.url[0]);
-    const stats = await Promise.all(
-      files.map((source) =>
-        fsPromises.stat(DIR_PREFIX + incoming.url[0] + "/" + source)
-      )
-    );
-    info.data_size = stats.reduce((total, stat) => total + stat.size, 0);
-    return info;
-  });
-
-  // Create Database
-  http.use("*", "PUT", async (incoming: IActiveHttpIncoming) => {
-    // Get Database
-    let db = getDB(incoming.body.name);
-
-    // Create Database
-    await db.info();
-    return { ok: true };
-  });
-
-  // Delete Database Local Var
-  const deleteDb = async (dir: string) => {
-    // Read all files and delete
-    const files = await fsPromises.readdir(dir);
-    await Promise.all(files.map(source => fsPromises.unlink(dir + "/" + source)));
-
-    // Delete the folder
-    await fsPromises.rmdir(dir);
-  };
-
-  // Delete Database
-  http.use("*", "DELETE", async (incoming: IActiveHttpIncoming) => {
-    // Can just delete the folder, It shouldn't have nested so can delete all the files first
-    let dir = DIR_PREFIX + incoming.url[0];
-
-    // Check Folder
-    try {
-      await fsPromises.access(dir);
-    } catch {
-      // Directory doesn't exist, so we're good.
-      return { ok: true };
-    }
-    // If we have this db open we need to close it
-    if (dbCache[incoming.url[0]]) {
-      await dbCache[incoming.url[0]].close();
-      delete dbCache[incoming.url[0]];
-    }
-    // Delete Database
-    await deleteDb(dir);
-    return { ok: true };
-  });
-
-  // Get UUID
-  http.use("_uuids", "GET", async (incoming: IActiveHttpIncoming) => {
-    // uuid holder
-    let uuids = [];
-
-    // Loop for how many requested
-    for (let i = 0; i < incoming.query.count; i++) {
-      uuids.push(uuidGenV4());
-    }
-    return { uuids };
-  });
-
-  // Get all docs from a database
-  http.use("*/_all_docs", "GET", async (incoming: IActiveHttpIncoming) => {
-    // Get Database
-    let db = getDB(incoming.url[0]);
-    return await db.allDocs(prepareAllDocs(incoming.query));
-  });
-
-  // Get all docs filtered from a database
-  http.use("*/_all_docs", "POST", async (incoming: IActiveHttpIncoming) => {
-    // Get Database
-    let db = getDB(incoming.url[0]);
-    return await db.allDocs(
-      prepareAllDocs(Object.assign(incoming.query, incoming.body))
-    );
-  });
-
-  // Bit of a proxy call to focus on umids
-  http.use("*/umids", "GET", async (incoming: IActiveHttpIncoming) => {
-    return getTransactionUmids(incoming);
-  });
-
-  http.use("*/transactions", "GET", async (incoming: IActiveHttpIncoming) => {
-    return getTransactionUmids(incoming);
-  });
-
-  // Filters the call to  focus on umid transaction (assuming right database!)
-  const getTransactionUmids = async (incoming: IActiveHttpIncoming) => {
-    // Get Database
-    let db = getDB(incoming.url[0]);
-    // Lets make sure it starts with umid:
-    if (incoming.query["from"].startsWith("umid:")) {
-      incoming.query["startkey"] = incoming.query["from"];
-    } else {
-      incoming.query["startkey"] = `umid:${incoming.query["from"]}`;
-    }
-    const txs = (await db.allDocs(prepareAllDocs(incoming.query))) as any;
-    for (let i = txs.rows.length; i--;) {
-      const [timestamp, umid] = txs.rows[i]._id.split(",");
-      txs.rows[i] = {
-        umid,
-        timestamp: timestamp.replace("umid:", ""),
-      };
-    }
-    return txs;
-  };
-
-  /**
-   * C/Pouch conversion utility tool for _all_docs
-   *
-   * @param {*} options
-   * @returns
-   */
-  const prepareAllDocs = (options: any) => {
-    // Convert Limit
-    if (options.limit) {
-      options.limit = parseInt(options.limit) || null;
-    }
-
-    // Convert startkey to remove "
-    if (options.startkey) {
-      options.startkey = options.startkey.replace(/"/g, "");
-    }
-
-    // Convert endkey to remove " and keep unicode search
-    if (options.endkey) {
-      options.endkey = options.endkey.replace(/"/g, "");
-      options.endkey = options.endkey.slice(0, -1) + "\u9999";
-    }
-
-    // Filter prefixes
-    // Leaving this in even though filtering in permissionsChecker as well
-    if (options.keys) {
-      options.keys = options.keys.map((id: string) => filterPrefix(id));
-    }
-    return options;
-  };
-
-  /**
-   * Reusable Get for mutliple paths
-   *
-   * @param {string} dbLoc
-   * @param {string} path
-   * @returns {Promise<any>}
-   */
-  const genericGet = (dbLoc: string, path: string): Promise<any> => {
-    // Get Database
-    return new Promise(async (resolve, reject) => {
-      // Get Database
-      const db = getDB(dbLoc);
-      // Filter
-      db.get(filterPrefix(decodeURIComponent(path), dbLoc))
-        .then((doc: unknown) => resolve(doc))
-        .catch((e: unknown) => {
-          reject(e);
-        });
-    });
-  };
-
-  /**
-   * Reusable delete (purge like) for mutliple paths
-   * TODO: Allow recusive delete docName []
-   *
-   * @param {string} dbLoc
-   * @param {string} path
-   * @returns {Promise<any>}
-   */
-  const genericDelete = (dbLoc: string, docName: string): Promise<any> => {
-    return new Promise(async (resolve, reject) => {
-      // Get Database
-      const db = getDB(dbLoc);
-      try {
-        await db.del(filterPrefix(docName, dbLoc));
-        return resolve({ success: "ok" });
-      } catch (e) {
-        return reject(e);
-      }
-    });
-  };
-
-  // TODO : Verify request source
-  http.use("*/*", "DELETE", async (incoming: IActiveHttpIncoming) => {
-    return await genericDelete(
-      incoming.url[0],
-      decodeURIComponent(incoming.url[1])
-    );
-  });
-
-  // Start compacting process
-  http.use("*/_compact", "GET", async (incoming: IActiveHttpIncoming) => {
-    const db = getDB(incoming.url[0]);
-    return await db.compact();
-  });
-
-  // Direct sequence get
-  http.use("*/_seq/*", "GET", async (incoming: IActiveHttpIncoming) => {
-    const db = getDB(incoming.url[0]);
-    return await db.getSeq(incoming.url[2]);
-  });
-
-  // Direct sequence delete
-  http.use("*/_seq/*", "DELETE", async (incoming: IActiveHttpIncoming) => {
-    const db = getDB(incoming.url[0]);
-    try {
-      await db.delSeq([incoming.url[2]]);
-      return { success: "ok" };
-    } catch {
-      throw new Error("Seq Delete Failed");
-    }
-  });
-
-  // filename comes straight from the request body here - without this
-  // check it's an arbitrary file write/read primitive (LevelMe.backup()/
-  // restore() pass it directly to createWriteStream()/createReadStream()
-  // with no validation of their own, since they're also called from the
-  // CLI's --backup/--restore flags where an operator-chosen path outside
-  // the current directory is legitimate - the restriction belongs here,
-  // at the boundary where the value is actually untrusted remote input,
-  // not inside LevelMe itself). Restricting to a bare filename (no path
-  // separators, no ".." components) blocks traversal and absolute paths
-  // while still allowing any normal filename.
-  const isSafeFilename = (filename: unknown): filename is string =>
-    typeof filename === "string" &&
-    filename.length > 0 &&
-    path.basename(filename) === filename;
-
-  http.use("*/_backup", "POST", async (incoming: IActiveHttpIncoming) => {
-    const filename = incoming.body?.filename;
-    if (filename !== undefined && !isSafeFilename(filename)) {
-      throw new Error("Invalid backup filename");
-    }
-    getDB(incoming.url[0]).backup(filename);
-    return { status: "started" };
-  });
-
-  http.use("*/_restore", "POST", async (incoming: IActiveHttpIncoming) => {
-    const filename = incoming.body?.filename;
-    if (!isSafeFilename(filename)) {
-      throw new Error("Invalid restore filename");
-    }
-    getDB(incoming.url[0]).restore(filename);
-    return { status: "started" };
-  });
-
-  // Get specific docs from a database
-  http.use("*/*", "GET", async (incoming: IActiveHttpIncoming) => {
-    return await genericGet(incoming.url[0], incoming.url[1]);
-  });
-
-  // Gets raw unparsed document straight from leveldb
-  // Document Store http://localhost:5259/activeledger/_raw/[document._id]
-  // Sequence (data) http://localhost:5259/activeledger/_raw/[document._id]@[revision] (revision Example = 10-f0b21ef22ec86f7c6d71c250b4563bba)
-  http.use("*/_raw/*", "GET", async (incoming: IActiveHttpIncoming) => {
-    // Getting revision?
-    const [root, revision] = incoming.url[2].split("@");
-
-    // Get Database
-    const db = getDB(incoming.url[0]);
-
-    // Get Main Doc
-    const rootDoc = await db.get(decodeURIComponent(root), true);
-
-    // If getting revision we need sequence
-    if (revision) {
-      try {
-        return await db.getSeq(rootDoc.rev_map[revision]);
-      } catch (e) {
-        throw new Error("Revision Fetch Failed");
-      }
-    }
-    return rootDoc;
-  });
-
-  // Add new / updated document to the database
-  http.use("*/**", "PUT", async (incoming: IActiveHttpIncoming) => {
-    // Archive Document?
-    //await markAsArchived(incoming);
-    return genericPut(incoming.url[0], incoming.body);
-  });
-
-  /**
-   * Detects if root pouch document needs to be archived and archives
-   *
-   * @param {IActiveHttpIncoming} incoming
-   * @returns {Promise<boolean>}
-   */
-  // const markAsArchived = async (
-  //   incoming: IActiveHttpIncoming
-  // ): Promise<boolean> => {
-  //   // No more btree archives, return false for now
-  //   return false;
-
-  //   const position = isArchivable(incoming.body._rev);
-  //   if (position) {
-  //     try {
-  //       // Get Database
-  //       const db = getDB(incoming.url[0]);
-
-  //       // Raw meta doc
-  //       const metaDoc = await db.get(decodeURIComponent(incoming.url[1]), true);
-
-  //       // Make sure archive database exists
-  //       const archDb = await getCreateArchiveDb(incoming.url[0]);
-
-  //       // Time to modify!
-  //       const newMetaDoc = prepareArchiveDoc(metaDoc, position);
-
-  //       // Prevent clashes
-  //       metaDoc._id += ":" + position;
-
-  //       // We could add to existing but then we would archive the archive
-  //       // Write document to archive
-  //       await archDb.post(checkDoc(metaDoc));
-
-  //       // Rewrite meta root document
-  //       await db.writeRaw(newMetaDoc._id, JSON.stringify(newMetaDoc));
-  //       return true;
-  //     } catch (e) {
-  //       // Any errors continue
-  //       return false;
-  //     }
-  //   }
-  //   return false;
-  // };
-
-  /**
-   * Pouchdb Metadoc rewrite (trimming)
-   *
-   * @param {*} metaDoc
-   * @param {string} position
-   * @returns
-   */
-  // const prepareArchiveDoc = (metaDoc: any, position: number) => {
-  //   // Time to modify!
-  //   const newMetaDoc = {
-  //     _id: metaDoc._id,
-  //     rev_tree: [
-  //       {
-  //         // pos: metaDoc.rev_tree[0].pos,
-  //         pos: position - 1, // Get parent starting pos
-  //         ids: getLastInTree(metaDoc.rev_tree[0].ids),
-  //       },
-  //     ],
-  //     rev_map: {
-  //       [metaDoc.winningRev]: metaDoc.rev_map[metaDoc.winningRev],
-  //     },
-  //     winningRev: metaDoc.winningRev,
-  //     deleted: metaDoc.deleted,
-  //     seq: metaDoc.seq,
-  //   };
-  //   return newMetaDoc;
-  // };
-
-  /**
-   * Create Archive Database
-   *
-   * @param {string} name
-   * @returns
-   */
-  // const getCreateArchiveDb = async (name: string): Promise<LevelMe> => {
-  //   const archDb = getDB(name + "_archive");
-  //   await archDb.info();
-  //   return archDb;
-  // };
-
-  /**
-   * Gets the last 2 leafs in the tree (parent, current)
-   *
-   * @param {any[]} tree
-   * @param {any[]} [prevTree]
-   * @returns {*}
-   */
-  // const getLastInTree = (tree: any[], prevTree?: any[]): any => {
-  //   if (tree[2].length) {
-  //     return getLastInTree(tree[2][0], tree);
-  //   }
-  //   return prevTree ? prevTree : tree;
-  // };
-
-  /**
-   * Should we Archive the document
-   *
-   * @param {string} revString
-   * @returns {number}
-   */
-  // const isArchivable = (revString: string): number => {
-  //   if (revString) {
-  //     const position = parseInt(revString.split("-")[0]);
-
-  //     // Set at 300 to have 3 attempts before default 1000 id failure error triggered above
-  //     //return position % 300 === 0 ? position : 0;
-  //     return position % 15 === 0 ? position : 0;
-  //   }
-  //   return 0;
-  // };
-
-  /**
-   * Reusable Get for mutliple paths
-   *
-   * @param {string} dbLoc
-   * @param {string} path
-   * @returns {Promise<any>}
-   */
-  const genericPut = async (dbLoc: string, body: string): Promise<any> => {
-    // Get Database
-    let db = getDB(dbLoc);
-    try {
-      return await db.put(body);
-    } catch (e) {
-      e.reason = e.message;
-      throw e;
-    }
-  };
-
-  // Filters any prefix (so they're virtual) (: reserved character) to real stream id
-  const filterPrefix = (stream: string, db?: string): string => {
-
-    // Only need to filter activeledger, making optional just in case not passed
-    if (db && db !== 'activeledger') {
-      return stream;
-    } else {
-      // Remove any suffix like :volatile :stream :umid
-      let [streamId, suffix] = stream.split(":");
-
-      // If id length more than 64 trim the start
-      if (streamId.length > 64 && !streamId.startsWith("0x")) {
-        streamId = streamId.slice(-64);
-      }
-
-      // If suffix add it back to return
-      if (suffix) {
-        return streamId + ":" + suffix;
-      }
-
-      // Return just the id
-      return streamId;
-    }
-  };
-
-  // Add new / updated document to the database with auto id
-  http.use("*", "POST", async (incoming: IActiveHttpIncoming) => {
-    // Get Database
-    let db = getDB(incoming.url[0]);
-
-    // Archive Document?
-    //await markAsArchived(incoming);
-
-    try {
-      return await db.post(checkDoc(incoming.body));
-    } catch (e) {
-      e.reason = e.message;
-      throw e;
-    }
-  });
-
-  http.use(
-    "*/events",
-    "GET",
-    async (
-      incoming: IActiveHttpIncoming,
-      req: http.IncomingMessage,
-      res: IActiveHttpResponse
-    ) => {
-      // Get Database
-      let db = getDB(incoming.url[0]);
-
-      const sse = new SSE(res);
-      const lastEventId = req.headers["Last-Event-ID"];
-
-      // Fetch anything newer since then and push
-      if (lastEventId) {
-        // Merge with getTransactionUmids as there is little difference
-        const events = (await db.allDocs(
-          prepareAllDocs({
-            startkey: `event:${lastEventId}`,
-            endkey: `event:`,
-            include_docs: true,
-          })
-        )) as any;
-        // Start at 1 to skip the event that was already sent
-        for (let i = 1; i < events.rows.length; i++) {
-          const id = events.rows[i]._id.replace("event:", "");
-          delete events.rows[i]._id;
-          delete events.rows[i]._rev;
-          sse.write(id, events.rows[i]);
-        }
-      }
-
-      // Listener Process event (to turn off)
-      const listener = (change: any) => {
-        if (change.id.startsWith("event:")) {
-          delete change.doc._id;
-          delete change.doc._rev;
-          if (!sse.write(change.id.replace("event:", ""), change.doc)) {
-            cancelChanges();
-          }
-        }
-      };
-
-      // Stop listening for changes
-      const cancelChanges = () => {
-        changes.off("change", listener);
-      };
-
-      // Run on disconnect immediately, rather than only being discovered
-      // reactively the next time a change event fires and listener() sees
-      // sse.write() return false - on a quiet database that could be a long
-      // time (or never) after the client actually disconnects.
-      sse.onDisconnect(cancelChanges);
-
-      // Listening for changes
-      let changes = db.changes().on("change", listener);
-
-      return "handled";
-    }
-  );
-
-  // Listen for changes on the database
-  http.use(
-    "*/_changes",
-    "GET",
-    async (
-      incoming: IActiveHttpIncoming,
-      req: http.IncomingMessage,
-      res: IActiveHttpResponse
-    ) => {
-      // Get Database
-      let db = getDB(incoming.url[0]);
-
-      // Limit check
-      if (incoming.query.limit < 1) {
-        incoming.query.limit = 1;
-      }
-
-      // Convert since into number if not now
-      if (incoming.query.since !== "now") {
-        incoming.query.since = parseInt(incoming.query.since);
-      }
-
-      if (
-        incoming.query.feed === "continuous" ||
-        incoming.query.feed === "longpoll"
-      ) {
-        if (incoming.query.feed === "continuous") {
-          // Currently we do not do continuous
-        } else {
-          // Long polling heartbeat - armed only once the body is actually
-          // open for writing, further down.
-          let hBInterval: ReturnType<typeof setInterval> | null = null;
-
-          // Clean up
-          let cleanUp = () => {
-            if (hBInterval) {
-              clearInterval(hBInterval);
-              hBInterval = null;
-            }
-          };
-
-          // `res` here is the RAW uWebSockets.js HttpResponse (see
-          // IActiveHttpResponse/@activeledger/httpd/src/httpd.ts -
-          // it constructs a Node-like synthetic object for `req`, but
-          // passes `res` straight through unwrapped). The `http`/
-          // `http.ServerResponse` types this file imports for `req`/`res`
-          // are Node's own - never real here, a holdover from before this
-          // framework's uWS.js migration. Two real, compounding bugs
-          // followed from believing them: res.setHeader() doesn't exist on
-          // a real uWS HttpResponse (a prior "fix", 425ccc6 "make sse work
-          // again!", replaced a setHeader() call with two res.write() calls
-          // writing literal "HTTP/1.1 200 OK\r\n\r\n" text into the BODY
-          // instead - also wrong, since write() there is real and does
-          // append to the body); and every write from here on happens in a
-          // LATER tick than the request handler's own synchronous top
-          // portion (a .then() callback, an EventEmitter listener firing
-          // whenever a future change occurs) - uWS requires those to be
-          // wrapped in res.cork(), same as the already-working /events SSE
-          // handler (sse.ts) already does, or the write silently corrupts/
-          // fails. None of this was ever caught because BOTH bugs (and two
-          // more besides - see levelme.ts's since="now" and seq fixes)
-          // left the response either hanging forever or throwing before
-          // any client ever got as far as trying to parse a body - so nothing
-          // ever actually exercised this branch successfully until all of
-          // them were fixed together.
-          res.cork(() => {
-            res.writeHeader("Content-type", ActiveHttpd.mimeType[".json"]);
-          });
-
-          // Read Type
-          incoming.query.live = incoming.query.continuous = false;
-
-          db.changesFromSeq(incoming.query).then((complete: any) => {
-            if (complete.results.length) {
-              if (res.writable) {
-                res.cork(() => {
-                  res.write(JSON.stringify(complete));
-                  res.end();
-                });
-              }
-              cleanUp();
-            } else {
-              // do the longpolling
-              // mimicking CouchDB, start sending the JSON immediately
-              if (res.writable) {
-                res.cork(() => {
-                  res.write('{"results":[\n');
-                });
-              }
-              incoming.query.live = incoming.query.continuous = true;
-
-              // Keep bytes flowing while nothing is changing.
-              //
-              // This write was commented out, and that is what made a quiet
-              // feed fatal rather than merely quiet. The response holds open
-              // with nothing on the wire, so the client's undici bodyTimeout
-              // (300s - ActiveRequest's default, packages/utilities) fires and
-              // the round comes back with no body. Downstream,
-              // ActiveDSChanges.listen() dereferenced response.data.results on
-              // that null and threw, and nothing re-armed the loop - so the
-              // changes feed died for the lifetime of the process. Every five
-              // idle minutes was enough. Live-confirmed: nano-gateway kept its
-              // SSE socket open and heartbeating to its own subscribers the
-              // whole time, so every health signal said the link was fine
-              // while no change could ever arrive again. Background push on a
-              // real device stopped and nothing anywhere reported a fault.
-              //
-              // A newline is insignificant whitespace between JSON array
-              // elements, so it cannot corrupt the body being streamed - this
-              // is exactly what CouchDB sends. It has to be corked: uWS
-              // requires it for any write from a later tick, and an uncorked
-              // one is silently dropped or corrupts the stream, which is the
-              // likeliest reason this was disabled rather than fixed.
-              //
-              // Default is well under the client's timeout so an ordinary
-              // quiet period never reaches it. The client-side guard in
-              // dsconnect.ts is still required: this reduces how often a bad
-              // round happens, it does not make one survivable.
-              hBInterval = setInterval(() => {
-                if (!res.writable) {
-                  // The client went away mid-longpoll. Without this the
-                  // interval and the change listener both leak for the
-                  // lifetime of the process, one per abandoned request.
-                  cleanUp();
-                  cancelChanges();
-                  return;
-                }
-                res.cork(() => {
-                  res.write("\n");
-                });
-              }, Number(incoming.query.heartbeat) || 30000);
-
-              // Listener Process event (to turn off)
-              // A longpoll round returns EVERY pending change, not one.
-              //
-              // bulkDocs emits one "change" per document in a synchronous
-              // loop (levelme.ts). The previous listener responded to the
-              // FIRST emit by writing it, ending the response and detaching
-              // itself - all synchronously - so every remaining document in
-              // the same commit found no listener at all. With no sequence
-              // backfill (changesFromSeq can never return rows, see its own
-              // comment) those changes were gone permanently: `since` moved
-              // past them and nothing could replay them.
-              //
-              // For a ledger that means an ordinary multi-stream transaction -
-              // a transfer touching sender and recipient - notified about one
-              // of them. Which one was arbitrary: levelme emits backwards, so
-              // it was the LAST document written. Downstream that reads as an
-              // intermittent push bug rather than as data loss.
-              //
-              // So changes are accumulated and flushed on the next tick. Every
-              // emit from one commit is synchronous, so a single setImmediate
-              // catches the whole batch without waiting for anything.
-              let pending: any[] = [];
-              let flushScheduled = false;
-
-              const flush = () => {
-                try {
-                  if (!res.writable || pending.length === 0) return;
-                  const batch = pending;
-                  pending = [];
-                  // The highest seq in the batch, not the last one written -
-                  // levelme emits in reverse order, so "last" is the oldest.
-                  const lastSeq = batch.reduce(
-                    (max: number, c: any) => (Number(c.seq) > max ? Number(c.seq) : max),
-                    0
-                  );
-                  // res.end() is load-bearing, not tidiness. Both the write
-                  // and the end used to be commented out, so a client whose
-                  // HTTP layer waits for the response to COMPLETE before
-                  // resolving - ActiveRequest/axios does - hung forever the
-                  // moment a real change occurred, even though the bytes were
-                  // already on the socket. Live-confirmed: it is why a
-                  // nano-gateway subscriber connected fine, kept heartbeating,
-                  // and never received a push for a committed change.
-                  res.cork(() => {
-                    res.write(batch.map((c: any) => JSON.stringify(c)).join(",\n"));
-                    res.write('],\n"last_seq":' + lastSeq + "}\n");
-                    res.end();
-                  });
-                } finally {
-                  // In a finally so a throw while writing - an unserialisable
-                  // doc, a discarded uWS response - cannot leak the heartbeat
-                  // interval and the change listener for the process lifetime.
-                  cleanUp();
-                  cancelChanges();
-                }
-              };
-
-              const listener = (change: any) => {
-                // Deliberately does no writability check of its own - flush()
-                // does it once, for the whole batch, immediately before
-                // writing. (For the record on `res.writable`: it is the real,
-                // framework-maintained "is this connection still open" flag,
-                // unlike req.connection.destroyed, which this handler used to
-                // consult and which was always undefined - the httpd
-                // framework's synthetic `req` carries only
-                // connection.remoteAddress, so that check never gated anything
-                // and never threw. sse.ts relies on res.writable too.)
-                pending.push(change);
-                if (!flushScheduled) {
-                  flushScheduled = true;
-                  setImmediate(flush);
-                }
-              };
-
-
-              // Stop listening for changes
-              const cancelChanges = () => {
-                changes.off("change", listener);
-              };
-
-              // Listening for changes
-              let changes = db.changes().on("change", listener);
-            }
-          }).catch((error: unknown) => {
-            // Previously unhandled - a rejection here (e.g. a malformed
-            // `since`) surfaced only as an opaque 500 with an empty {}
-            // body and no indication anything had actually gone wrong
-            // server-side, all the way up through whatever HTTP client hit
-            // this route. Finalise the response with a real error instead
-            // of leaving it hanging or silently swallowed.
-            if (res.writable) {
-              res.cork(() => {
-                res.writeStatus("500");
-                res.write(JSON.stringify({ error: String(error) }));
-                res.end();
-              });
-            }
-            cleanUp();
-          });
-        }
-        return "handled";
-      } else {
-        // Just get the latest
-        return await db.changesFromSeq(incoming.query);
-      }
-    }
-  );
-
-  // Add new / updated BULK document to the database
-  http.use("*/_bulk_docs", "POST", async (incoming: IActiveHttpIncoming) => {
-    // Can no longer be an array
-    if (!Array.isArray(incoming.body)) {
-      // Must have docs
-      if (incoming.body.docs) {
-        // Get Database
-        let db = getDB(incoming.url[0]);
-
-        // Prepare Archive database
-        // Make sure archive database exists
-        //const archDb = await getCreateArchiveDb(incoming.url[0]);
-
-        // We need to see if the docs need archiving
-        // for (let i = incoming.body.docs.length; i--; ) {
-        //   const doc = incoming.body.docs[i];
-        //   const position = isArchivable(doc._rev);
-        //   if (position) {
-        //     try {
-        //       // Raw meta doc
-        //       const metaDoc = await db.get(doc._id, true);
-
-        //       // Time to modify!
-        //       const newMetaDoc = prepareArchiveDoc(metaDoc, position);
-
-        //       // Prevent clashes
-        //       metaDoc._id += ":" + position;
-
-        //       // We could add to existing but then we would archive the archive
-        //       // Write document to archive
-        //       await archDb.post(checkDoc(metaDoc));
-
-        //       // Rewrite meta root document
-        //       await db.writeRaw(newMetaDoc._id, JSON.stringify(newMetaDoc));
-        //     } catch (e) {
-        //       // Ignore errors and continue
-        //     }
-        //   }
-        // }
-
-        // Bulk Insert
-        if (await db.bulkDocs(incoming.body.docs, incoming.body.options)) {
-          return {
-            ok: true,
-          };
-        } else {
-          return {
-            ok: false,
-          };
-        }
-      }
-    }
-  });
-
-  // Find API
-  http.use("*/_find", "POST", async (incoming: IActiveHttpIncoming) => {
-    return { error: "find is deprecated" };
-  });
-
-  // Explain
-  http.use("*/_explain", "POST", async (incoming: IActiveHttpIncoming) => {
-    return { error: "explain is deprecated" };
-  });
-
-  // Fauxton
-  const fauxton = async (
-    incoming: IActiveHttpIncoming,
-    req: {
-      headers: {
-        [index: string]: string;
-      };
-      method: string;
-      url: string;
-      connection: {
-        remoteAddress: string;
-      };
-    },
-    res: IActiveHttpResponse
-  ) => {
-    // We want to force /_utils to /_utils/ as this is the CouchDB behavior
-    if (req.url === "/_utils") {
-      // res.writeHead(301, {
-      //   Location: "/_utils/",
-      // });
-      // return;
-      req.url = "/_utils/";
-    }
-
-    // File to send
-    let file = FAUXTON_PATH + "/index.html";
-
-    // If path is not default overwrite
-    if (req.url !== "/_utils/") {
-      file = FAUXTON_PATH + (req.url as string).replace("/_utils", "");
-    }
-
-    if (fauxtonCache[file]) {
-      return fauxtonCache[file];
-    }
-
-    try {
-      await fsPromises.access(file);
-      const data = await fsPromises.readFile(file);
-      const response = {
-        mime: `${ActiveHttpd.mimeType[path.parse(file).ext] || "text/plain"}`,
-        data: data as Buffer,
-      }
-      fauxtonCache[file] = response;
-      return response;
-    } catch {
-      // Not found, will result in a 404 from httpd
-    }
-  };
-  http.use("_utils", "GET", fauxton);
-  http.use("_utils/**", "GET", fauxton);
-
-  // Start Server
-  http.listen(parseInt(PORT));
-})();