@sasjs/api 0.0.0-stage → 0.1.0

package/build/browser.js

@@ -0,0 +1,2469 @@
+/* @sasjs/api 0.1.0 - the SASjs Server API, for a service worker. https://github.com/sasjs/api */
+"use strict";
+var SASjsApi = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    ApiError: () => ApiError,
+    DRIVE_CORPUS: () => DRIVE_CORPUS,
+    HANDLED_ROUTES: () => HANDLED_ROUTES,
+    MemoryDriveStore: () => MemoryDriveStore,
+    OVERLAY: () => OVERLAY,
+    ROUTES: () => ROUTES,
+    TAG_CAPABILITIES: () => TAG_CAPABILITIES,
+    basename: () => basename,
+    createDriveService: () => createDriveService,
+    dirname: () => dirname,
+    dispatch: () => dispatch,
+    findRoute: () => findRoute,
+    hasBlockedExtension: () => hasBlockedExtension,
+    isApiError: () => isApiError,
+    isRoot: () => isRoot,
+    normaliseDrivePath: () => normaliseDrivePath,
+    routeById: () => routeById,
+    runCase: () => runCase,
+    servicesFor: () => servicesFor
+  });
+
+  // src/types.ts
+  var ApiError = class extends Error {
+    constructor(status, message) {
+      super(message);
+      this.status = status;
+      /** Told apart by marker rather than `instanceof` - see `isApiError`. */
+      this.apiError = true;
+      this.name = "ApiError";
+    }
+  };
+  var isApiError = (value) => !!value && value.apiError === true;
+
+  // src/drive/paths.ts
+  var BLOCKED_EXTENSION = /\.(exe|sh|htaccess)$/i;
+  var hasBlockedExtension = (path) => BLOCKED_EXTENSION.test(path);
+  var normaliseDrivePath = (input) => {
+    const given = typeof input === "string" ? input : "";
+    const segments = [];
+    for (const segment of given.replace(/\\/g, "/").split("/")) {
+      if (!segment || segment === ".") continue;
+      if (segment === "..") {
+        if (!segments.length) return null;
+        segments.pop();
+        continue;
+      }
+      segments.push(segment);
+    }
+    return "/" + segments.join("/");
+  };
+  var dirname = (path) => {
+    const cut = path.lastIndexOf("/");
+    return cut <= 0 ? "/" : path.slice(0, cut);
+  };
+  var basename = (path) => path.slice(path.lastIndexOf("/") + 1);
+  var isRoot = (path) => path === "/";
+  var checkFilePath = (input) => {
+    const path = normaliseDrivePath(input);
+    if (path === null) return { reason: "outside" };
+    if (hasBlockedExtension(path)) return { reason: "extension" };
+    return { path };
+  };
+
+  // src/drive/service.ts
+  var filePath = (input, outside) => {
+    const checked = checkFilePath(input);
+    if ("reason" in checked) {
+      throw checked.reason === "extension" ? new ApiError(400, "Invalid file extension") : new ApiError(400, outside);
+    }
+    if (isRoot(checked.path)) throw new ApiError(400, outside);
+    return checked.path;
+  };
+  var folderPath = (input, outside) => {
+    const path = normaliseDrivePath(input);
+    if (path === null) throw new ApiError(400, outside);
+    return path;
+  };
+  var createDriveService = (store) => {
+    const treeOf = async (path) => {
+      const listing = await store.list(path);
+      const children = [];
+      for (const folder of listing.folders) {
+        children.push(
+          await treeOf(path === "/" ? "/" + folder : path + "/" + folder)
+        );
+      }
+      for (const file of listing.files) {
+        children.push({
+          name: file,
+          relativePath: path === "/" ? "/" + file : path + "/" + file,
+          isFolder: false,
+          children: []
+        });
+      }
+      return {
+        name: path === "/" ? "files" : basename(path),
+        relativePath: path,
+        isFolder: true,
+        children
+      };
+    };
+    return {
+      async list(given) {
+        const path = folderPath(
+          given === void 0 ? "" : given,
+          "Can't get folder outside drive."
+        );
+        if (!await store.exists(path))
+          throw new ApiError(404, `Folder doesn't exist.`);
+        const stat = await store.stat(path);
+        if (!stat.directory) throw new ApiError(400, "Not a Folder.");
+        const listing = await store.list(path);
+        return {
+          files: [...listing.files].sort(),
+          folders: [...listing.folders].sort()
+        };
+      },
+      async read(given) {
+        const path = filePath(given, "Can't get file outside drive.");
+        if (!await store.exists(path))
+          throw new ApiError(404, `File doesn't exist.`);
+        const contents = await store.read(path);
+        return { contents, binary: typeof contents !== "string" };
+      },
+      async save(given, contents) {
+        const path = filePath(given, "Can't put file outside drive.");
+        if (await store.exists(path))
+          throw new ApiError(409, "File already exists.");
+        await store.mkdirp(dirname(path));
+        await store.write(path, contents);
+        return { status: "success" };
+      },
+      async update(given, contents) {
+        const path = filePath(given, "Can't modify file outside drive.");
+        if (!await store.exists(path))
+          throw new ApiError(404, `File doesn't exist.`);
+        await store.write(path, contents);
+        return { status: "success" };
+      },
+      async remove(given) {
+        const path = filePath(given, "Can't delete file outside drive.");
+        if (!await store.exists(path))
+          throw new ApiError(404, `File doesn't exist.`);
+        await store.remove(path);
+        return { status: "success" };
+      },
+      async mkdir(given) {
+        const path = folderPath(given, "Can't put folder outside drive.");
+        if (isRoot(path))
+          throw new ApiError(400, "Can't put folder outside drive.");
+        if (await store.exists(path))
+          throw new ApiError(409, "Folder already exists.");
+        await store.mkdirp(path);
+        return { status: "success" };
+      },
+      async rmdir(given) {
+        const path = folderPath(given, "Can't delete folder outside drive.");
+        if (isRoot(path))
+          throw new ApiError(400, "Can't delete folder outside drive.");
+        if (!await store.exists(path) || !(await store.stat(path)).directory)
+          throw new ApiError(404, `Folder doesn't exist.`);
+        await store.remove(path);
+        return { status: "success" };
+      },
+      async rename(oldPath, newPath) {
+        const from = folderPath(oldPath, "Old path can't be outside of drive.");
+        const to = folderPath(newPath, "New path can't be outside of drive.");
+        if (isRoot(from) || isRoot(to))
+          throw new ApiError(400, "New path can't be outside of drive.");
+        if (await store.exists(from)) {
+          const stat = await store.stat(from);
+          if (stat.directory && (to === from || to.startsWith(from + "/")))
+            throw new ApiError(
+              400,
+              "New path can't be inside the folder being moved."
+            );
+          if (await store.exists(to))
+            throw new ApiError(
+              409,
+              stat.directory ? "Folder with new name already exists." : "File with new name already exists."
+            );
+          await store.move(from, to);
+          return { status: "success" };
+        }
+        throw new ApiError(404, "No file/folder found for provided path.");
+      },
+      async tree(given) {
+        const path = folderPath(
+          given === void 0 ? "" : given,
+          "Can't get folder outside drive."
+        );
+        if (!await store.exists(path))
+          throw new ApiError(404, `Folder doesn't exist.`);
+        const stat = await store.stat(path);
+        if (!stat.directory) throw new ApiError(400, "Not a Folder.");
+        return { status: "success", tree: await treeOf(path) };
+      }
+    };
+  };
+
+  // src/drive/memory-store.ts
+  var MemoryDriveStore = class {
+    constructor(seed = {}) {
+      this.files = /* @__PURE__ */ new Map();
+      this.folders = /* @__PURE__ */ new Set(["/"]);
+      for (const [path, contents] of Object.entries(seed)) {
+        this.putSync(path, contents);
+      }
+    }
+    /** Everything on the drive, for a snapshot or an assertion. */
+    dump() {
+      const out = {};
+      for (const [path, contents] of this.files) out[path] = contents;
+      return out;
+    }
+    putSync(path, contents) {
+      this.mkdirpSync(dirname(path));
+      this.files.set(
+        path,
+        typeof contents === "string" ? contents : contents.slice()
+      );
+    }
+    mkdirpSync(path) {
+      const parts = path.split("/").filter(Boolean);
+      let acc = "";
+      for (const part of parts) {
+        acc += "/" + part;
+        this.folders.add(acc);
+      }
+    }
+    children(path) {
+      const prefix = path === "/" ? "/" : path + "/";
+      const files = [];
+      const folders = [];
+      for (const candidate of this.files.keys()) {
+        if (!candidate.startsWith(prefix)) continue;
+        const rest = candidate.slice(prefix.length);
+        if (rest && !rest.includes("/")) files.push(rest);
+      }
+      for (const candidate of this.folders) {
+        if (!candidate.startsWith(prefix)) continue;
+        const rest = candidate.slice(prefix.length);
+        if (rest && !rest.includes("/")) folders.push(rest);
+      }
+      return { files: files.sort(), folders: folders.sort() };
+    }
+    async read(path) {
+      const contents = this.files.get(path);
+      if (contents === void 0) throw new ApiError(404, `File doesn't exist.`);
+      return contents;
+    }
+    async write(path, contents) {
+      this.putSync(path, contents);
+    }
+    async exists(path) {
+      return this.files.has(path) || this.folders.has(path);
+    }
+    async stat(path) {
+      if (this.folders.has(path) && !this.files.has(path))
+        return { directory: true, size: 0 };
+      const contents = this.files.get(path);
+      if (contents === void 0) throw new ApiError(404, `File doesn't exist.`);
+      return {
+        directory: false,
+        size: typeof contents === "string" ? contents.length : contents.length
+      };
+    }
+    async list(path) {
+      return this.children(path);
+    }
+    async mkdirp(path) {
+      this.mkdirpSync(path);
+    }
+    async remove(path) {
+      if (this.files.delete(path)) return;
+      const prefix = path === "/" ? "/" : path + "/";
+      for (const candidate of [...this.files.keys()]) {
+        if (candidate.startsWith(prefix)) this.files.delete(candidate);
+      }
+      for (const candidate of [...this.folders]) {
+        if (candidate === path || candidate.startsWith(prefix))
+          this.folders.delete(candidate);
+      }
+    }
+    async move(from, to) {
+      const contents = this.files.get(from);
+      if (contents !== void 0) {
+        const copy = typeof contents === "string" ? contents : contents.slice();
+        this.files.delete(from);
+        this.mkdirpSync(dirname(to));
+        this.files.set(to, copy);
+        return;
+      }
+      const prefix = from + "/";
+      const moves = [];
+      for (const [candidate, value] of this.files) {
+        if (candidate.startsWith(prefix))
+          moves.push([candidate, to + candidate.slice(from.length), value]);
+      }
+      for (const [source] of moves) this.files.delete(source);
+      for (const [, destination, value] of moves) {
+        this.mkdirpSync(dirname(destination));
+        this.files.set(destination, value);
+      }
+      for (const candidate of [...this.folders]) {
+        if (candidate === from || candidate.startsWith(prefix)) {
+          this.folders.delete(candidate);
+          this.folders.add(to + candidate.slice(from.length));
+        }
+      }
+      this.mkdirpSync(to);
+    }
+  };
+
+  // src/routes/generated.ts
+  var GENERATED_ROUTES = [
+    {
+      id: "GET /",
+      method: "GET",
+      path: "/",
+      tag: "Web",
+      summary: "Serve the web interface",
+      params: [],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/admin/diagnostics",
+      method: "GET",
+      path: "/SASjsApi/admin/diagnostics",
+      tag: "Admin",
+      summary: "Diagnostics: version, uptime, memory, disk usage",
+      params: [],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/admin/logs",
+      method: "GET",
+      path: "/SASjsApi/admin/logs",
+      tag: "Admin",
+      summary: "List the server's log files",
+      params: [],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/admin/logs/{fileName}",
+      method: "GET",
+      path: "/SASjsApi/admin/logs/{fileName}",
+      tag: "Admin",
+      summary: "Read the tail of a log file",
+      params: [
+        {
+          name: "fileName",
+          in: "path",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "lines",
+          in: "query",
+          required: false,
+          type: "number"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/auth/logout",
+      method: "POST",
+      path: "/SASjsApi/auth/logout",
+      tag: "Auth",
+      summary: "Revoke the current tokens",
+      params: [],
+      requestBodies: [],
+      responses: [
+        {
+          status: 204,
+          description: "No content"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/auth/refresh",
+      method: "POST",
+      path: "/SASjsApi/auth/refresh",
+      tag: "Auth",
+      summary: "Refresh the access and refresh tokens",
+      params: [],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/auth/token",
+      method: "POST",
+      path: "/SASjsApi/auth/token",
+      tag: "Auth",
+      summary: "Exchange an authorization code for tokens",
+      params: [
+        {
+          name: "clientId",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "code",
+          in: "body",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "PATCH /SASjsApi/auth/updatePassword",
+      method: "PATCH",
+      path: "/SASjsApi/auth/updatePassword",
+      tag: "Auth",
+      summary: "Change the current user's password",
+      params: [
+        {
+          name: "currentPassword",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "newPassword",
+          in: "body",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 204,
+          description: "No content"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/authConfig",
+      method: "GET",
+      path: "/SASjsApi/authConfig",
+      tag: "Auth Config",
+      summary: "Get the configured authentication providers",
+      params: [],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/authConfig/synchroniseWithLDAP",
+      method: "POST",
+      path: "/SASjsApi/authConfig/synchroniseWithLDAP",
+      tag: "Auth Config",
+      summary: "Import users and groups from LDAP",
+      params: [],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/client",
+      method: "GET",
+      path: "/SASjsApi/client",
+      tag: "Client",
+      summary: "List all clients",
+      params: [],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/client",
+      method: "POST",
+      path: "/SASjsApi/client",
+      tag: "Client",
+      summary: "Create a client",
+      params: [
+        {
+          name: "clientId",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "clientSecret",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "accessTokenExpiration",
+          in: "body",
+          required: false,
+          type: "number"
+        },
+        {
+          name: "refreshTokenExpiration",
+          in: "body",
+          required: false,
+          type: "number"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/code/execute",
+      method: "POST",
+      path: "/SASjsApi/code/execute",
+      tag: "Code",
+      summary: "Execute code and return its output",
+      params: [
+        {
+          name: "code",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "runTime",
+          in: "body",
+          required: true,
+          type: "RunTimeType"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/code/format",
+      method: "POST",
+      path: "/SASjsApi/code/format",
+      tag: "Code",
+      summary: "Format SAS code and return the formatted text",
+      params: [
+        {
+          name: "code",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "filePath",
+          in: "body",
+          required: false,
+          type: "string"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/code/lint",
+      method: "POST",
+      path: "/SASjsApi/code/lint",
+      tag: "Code",
+      summary: "Lint SAS code and return the diagnostics",
+      params: [
+        {
+          name: "code",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "filePath",
+          in: "body",
+          required: false,
+          type: "string"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/code/trigger",
+      method: "POST",
+      path: "/SASjsApi/code/trigger",
+      tag: "Code",
+      summary: "Trigger code and return a session ID",
+      params: [
+        {
+          name: "code",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "runTime",
+          in: "body",
+          required: true,
+          type: "RunTimeType"
+        },
+        {
+          name: "expiresAfterMins",
+          in: "body",
+          required: false,
+          type: "number"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/drive/deploy",
+      method: "POST",
+      path: "/SASjsApi/drive/deploy",
+      tag: "Drive",
+      summary: "Deploy a file tree to SASjs Drive",
+      params: [
+        {
+          name: "appLoc",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "streamWebFolder",
+          in: "body",
+          required: false,
+          type: "string"
+        },
+        {
+          name: "fileTree",
+          in: "body",
+          required: true,
+          type: "FileTree"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        },
+        {
+          status: 400,
+          description: "Invalid Format"
+        },
+        {
+          status: 500,
+          description: "Execution Error"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/drive/deploy/upload",
+      method: "POST",
+      path: "/SASjsApi/drive/deploy/upload",
+      tag: "Drive",
+      summary: "Deploy an uploaded file to SASjs Drive",
+      params: [
+        {
+          name: "file",
+          in: "formData",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: ["multipart/form-data"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        },
+        {
+          status: 400,
+          description: "Invalid Format"
+        },
+        {
+          status: 500,
+          description: "Execution Error"
+        }
+      ]
+    },
+    {
+      id: "DELETE /SASjsApi/drive/file",
+      method: "DELETE",
+      path: "/SASjsApi/drive/file",
+      tag: "Drive",
+      summary: "Delete a file from SASjs Drive",
+      params: [
+        {
+          name: "_filePath",
+          in: "query",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        },
+        {
+          status: 400,
+          description: "Can't delete file outside drive"
+        },
+        {
+          status: 404,
+          description: "File doesn't exist"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/drive/file",
+      method: "GET",
+      path: "/SASjsApi/drive/file",
+      tag: "Drive",
+      summary: "Get a file from SASjs Drive",
+      params: [
+        {
+          name: "_filePath",
+          in: "query",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "The contents of the file"
+        },
+        {
+          status: 400,
+          description: "Can't get file outside drive"
+        },
+        {
+          status: 404,
+          description: "File doesn't exist"
+        }
+      ]
+    },
+    {
+      id: "PATCH /SASjsApi/drive/file",
+      method: "PATCH",
+      path: "/SASjsApi/drive/file",
+      tag: "Drive",
+      summary: "Replace a file in SASjs Drive",
+      params: [
+        {
+          name: "_filePath",
+          in: "query",
+          required: false,
+          type: "string"
+        },
+        {
+          name: "file",
+          in: "formData",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "filePath",
+          in: "formData",
+          required: false,
+          type: "string"
+        }
+      ],
+      requestBodies: ["multipart/form-data"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        },
+        {
+          status: 400,
+          description: "Can't modify file outside drive"
+        },
+        {
+          status: 404,
+          description: "File doesn't exist"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/drive/file",
+      method: "POST",
+      path: "/SASjsApi/drive/file",
+      tag: "Drive",
+      summary: "Create a file in SASjs Drive",
+      params: [
+        {
+          name: "_filePath",
+          in: "query",
+          required: false,
+          type: "string"
+        },
+        {
+          name: "file",
+          in: "formData",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "filePath",
+          in: "formData",
+          required: false,
+          type: "string"
+        }
+      ],
+      requestBodies: ["multipart/form-data"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        },
+        {
+          status: 400,
+          description: "Can't put file outside drive"
+        },
+        {
+          status: 409,
+          description: "File already exists"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/drive/filetree",
+      method: "GET",
+      path: "/SASjsApi/drive/filetree",
+      tag: "Drive",
+      summary: "Get the SASjs Drive file tree, or one folder of it",
+      params: [
+        {
+          name: "_folderPath",
+          in: "query",
+          required: false,
+          type: "string"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "DELETE /SASjsApi/drive/folder",
+      method: "DELETE",
+      path: "/SASjsApi/drive/folder",
+      tag: "Drive",
+      summary: "Delete a folder from SASjs Drive",
+      params: [
+        {
+          name: "_folderPath",
+          in: "query",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        },
+        {
+          status: 400,
+          description: "Can't delete folder outside drive"
+        },
+        {
+          status: 404,
+          description: "Folder doesn't exist"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/drive/folder",
+      method: "GET",
+      path: "/SASjsApi/drive/folder",
+      tag: "Drive",
+      summary: "List a folder in SASjs Drive",
+      params: [
+        {
+          name: "_folderPath",
+          in: "query",
+          required: false,
+          type: "string"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        },
+        {
+          status: 400,
+          description: "Can't get folder outside drive"
+        },
+        {
+          status: 404,
+          description: "Folder doesn't exist"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/drive/folder",
+      method: "POST",
+      path: "/SASjsApi/drive/folder",
+      tag: "Drive",
+      summary: "Create a folder in SASjs Drive",
+      params: [
+        {
+          name: "folderPath",
+          in: "body",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        },
+        {
+          status: 400,
+          description: "Can't put folder outside drive"
+        },
+        {
+          status: 409,
+          description: "Folder already exists"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/drive/rename",
+      method: "POST",
+      path: "/SASjsApi/drive/rename",
+      tag: "Drive",
+      summary: "Rename or move a file or folder in SASjs Drive",
+      params: [
+        {
+          name: "oldPath",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "newPath",
+          in: "body",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        },
+        {
+          status: 400,
+          description: "Can't rename outside drive"
+        },
+        {
+          status: 404,
+          description: "No file/folder found for provided path"
+        },
+        {
+          status: 409,
+          description: "Something already exists at the new path"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/group",
+      method: "GET",
+      path: "/SASjsApi/group",
+      tag: "Group",
+      summary: "List all groups",
+      params: [],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/group",
+      method: "POST",
+      path: "/SASjsApi/group",
+      tag: "Group",
+      summary: "Create a group",
+      params: [
+        {
+          name: "name",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "description",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "isActive",
+          in: "body",
+          required: false,
+          type: "boolean"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "DELETE /SASjsApi/group/{groupUid}/{userUid}",
+      method: "DELETE",
+      path: "/SASjsApi/group/{groupUid}/{userUid}",
+      tag: "Group",
+      summary: "Remove a user from a group",
+      params: [
+        {
+          name: "groupUid",
+          in: "path",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "userUid",
+          in: "path",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/group/{groupUid}/{userUid}",
+      method: "POST",
+      path: "/SASjsApi/group/{groupUid}/{userUid}",
+      tag: "Group",
+      summary: "Add a user to a group",
+      params: [
+        {
+          name: "groupUid",
+          in: "path",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "userUid",
+          in: "path",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "DELETE /SASjsApi/group/{uid}",
+      method: "DELETE",
+      path: "/SASjsApi/group/{uid}",
+      tag: "Group",
+      summary: "Delete a group",
+      params: [
+        {
+          name: "uid",
+          in: "path",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/group/{uid}",
+      method: "GET",
+      path: "/SASjsApi/group/{uid}",
+      tag: "Group",
+      summary: "Get a group by id",
+      params: [
+        {
+          name: "uid",
+          in: "path",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/group/by/groupname/{name}",
+      method: "GET",
+      path: "/SASjsApi/group/by/groupname/{name}",
+      tag: "Group",
+      summary: "Get a group by name",
+      params: [
+        {
+          name: "name",
+          in: "path",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/info",
+      method: "GET",
+      path: "/SASjsApi/info",
+      tag: "Info",
+      summary: "Get public server information",
+      params: [],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/info/authorizedRoutes",
+      method: "GET",
+      path: "/SASjsApi/info/authorizedRoutes",
+      tag: "Info",
+      summary: "List the routes that accept permissions",
+      params: [],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/info/myAuthorizedRoutes",
+      method: "GET",
+      path: "/SASjsApi/info/myAuthorizedRoutes",
+      tag: "Info",
+      summary: "List the routes this caller may use",
+      params: [],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/permission",
+      method: "GET",
+      path: "/SASjsApi/permission",
+      tag: "Permission",
+      summary: "List the permission rules for the current user",
+      params: [],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/permission",
+      method: "POST",
+      path: "/SASjsApi/permission",
+      tag: "Permission",
+      summary: "Create a permission rule",
+      params: [
+        {
+          name: "path",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "type",
+          in: "body",
+          required: true,
+          type: "PermissionType"
+        },
+        {
+          name: "setting",
+          in: "body",
+          required: true,
+          type: "PermissionSettingForRoute"
+        },
+        {
+          name: "principalType",
+          in: "body",
+          required: true,
+          type: "PrincipalType"
+        },
+        {
+          name: "principalId",
+          in: "body",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "DELETE /SASjsApi/permission/{uid}",
+      method: "DELETE",
+      path: "/SASjsApi/permission/{uid}",
+      tag: "Permission",
+      summary: "Delete a permission rule",
+      params: [
+        {
+          name: "uid",
+          in: "path",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 204,
+          description: "No content"
+        }
+      ]
+    },
+    {
+      id: "PATCH /SASjsApi/permission/{uid}",
+      method: "PATCH",
+      path: "/SASjsApi/permission/{uid}",
+      tag: "Permission",
+      summary: "Update a permission rule",
+      params: [
+        {
+          name: "uid",
+          in: "path",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "setting",
+          in: "body",
+          required: true,
+          type: "PermissionSettingForRoute"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/session",
+      method: "GET",
+      path: "/SASjsApi/session",
+      tag: "Session",
+      summary: "Get the current session",
+      params: [],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/session/{sessionId}",
+      method: "GET",
+      path: "/SASjsApi/session/{sessionId}",
+      tag: "Session",
+      summary: "Get a triggered session",
+      params: [
+        {
+          name: "sessionId",
+          in: "path",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/session/{sessionId}/log",
+      method: "GET",
+      path: "/SASjsApi/session/{sessionId}/log",
+      tag: "Session",
+      summary: "Get the log of a triggered session",
+      params: [
+        {
+          name: "sessionId",
+          in: "path",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/session/{sessionId}/output",
+      method: "GET",
+      path: "/SASjsApi/session/{sessionId}/output",
+      tag: "Session",
+      summary: "Get the output of a triggered session",
+      params: [
+        {
+          name: "sessionId",
+          in: "path",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/session/{sessionId}/state",
+      method: "GET",
+      path: "/SASjsApi/session/{sessionId}/state",
+      tag: "Session",
+      summary: "Get the state of a session",
+      params: [
+        {
+          name: "sessionId",
+          in: "path",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/stp/execute",
+      method: "GET",
+      path: "/SASjsApi/stp/execute",
+      tag: "STP",
+      summary: "Execute a stored program",
+      params: [
+        {
+          name: "_program",
+          in: "query",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "_debug",
+          in: "query",
+          required: false,
+          type: "number"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/stp/execute",
+      method: "POST",
+      path: "/SASjsApi/stp/execute",
+      tag: "STP",
+      summary: "Execute a stored program",
+      params: [
+        {
+          name: "_program",
+          in: "query",
+          required: false,
+          type: "string"
+        },
+        {
+          name: "_program",
+          in: "body",
+          required: false,
+          type: "string"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/stp/trigger",
+      method: "POST",
+      path: "/SASjsApi/stp/trigger",
+      tag: "STP",
+      summary: "Trigger a stored program and return a session ID",
+      params: [
+        {
+          name: "_program",
+          in: "query",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "_debug",
+          in: "query",
+          required: false,
+          type: "number"
+        },
+        {
+          name: "expiresAfterMins",
+          in: "query",
+          required: false,
+          type: "number"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/user",
+      method: "GET",
+      path: "/SASjsApi/user",
+      tag: "User",
+      summary: "List all users",
+      params: [],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "POST /SASjsApi/user",
+      method: "POST",
+      path: "/SASjsApi/user",
+      tag: "User",
+      summary: "Create a user",
+      params: [
+        {
+          name: "displayName",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "username",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "password",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "isAdmin",
+          in: "body",
+          required: false,
+          type: "boolean"
+        },
+        {
+          name: "isActive",
+          in: "body",
+          required: false,
+          type: "boolean"
+        },
+        {
+          name: "autoExec",
+          in: "body",
+          required: false,
+          type: "string"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "DELETE /SASjsApi/user/{uid}",
+      method: "DELETE",
+      path: "/SASjsApi/user/{uid}",
+      tag: "User",
+      summary: "Delete a user by id",
+      params: [
+        {
+          name: "uid",
+          in: "path",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "password",
+          in: "body",
+          required: false,
+          type: "string"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 204,
+          description: "No content"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/user/{uid}",
+      method: "GET",
+      path: "/SASjsApi/user/{uid}",
+      tag: "User",
+      summary: "Get a user by id",
+      params: [
+        {
+          name: "uid",
+          in: "path",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "PATCH /SASjsApi/user/{uid}",
+      method: "PATCH",
+      path: "/SASjsApi/user/{uid}",
+      tag: "User",
+      summary: "Update a user by id",
+      params: [
+        {
+          name: "uid",
+          in: "path",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "displayName",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "username",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "password",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "isAdmin",
+          in: "body",
+          required: false,
+          type: "boolean"
+        },
+        {
+          name: "isActive",
+          in: "body",
+          required: false,
+          type: "boolean"
+        },
+        {
+          name: "autoExec",
+          in: "body",
+          required: false,
+          type: "string"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "DELETE /SASjsApi/user/by/username/{username}",
+      method: "DELETE",
+      path: "/SASjsApi/user/by/username/{username}",
+      tag: "User",
+      summary: "Delete a user by username",
+      params: [
+        {
+          name: "username",
+          in: "path",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "password",
+          in: "body",
+          required: false,
+          type: "string"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 204,
+          description: "No content"
+        }
+      ]
+    },
+    {
+      id: "GET /SASjsApi/user/by/username/{username}",
+      method: "GET",
+      path: "/SASjsApi/user/by/username/{username}",
+      tag: "User",
+      summary: "Get a user by username",
+      params: [
+        {
+          name: "username",
+          in: "path",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "PATCH /SASjsApi/user/by/username/{username}",
+      method: "PATCH",
+      path: "/SASjsApi/user/by/username/{username}",
+      tag: "User",
+      summary: "Update a user by username",
+      params: [
+        {
+          name: "username",
+          in: "path",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "displayName",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "username",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "password",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "isAdmin",
+          in: "body",
+          required: false,
+          type: "boolean"
+        },
+        {
+          name: "isActive",
+          in: "body",
+          required: false,
+          type: "boolean"
+        },
+        {
+          name: "autoExec",
+          in: "body",
+          required: false,
+          type: "string"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "POST /SASLogon/authorize",
+      method: "POST",
+      path: "/SASLogon/authorize",
+      tag: "Web",
+      summary: "Issue an authorization code",
+      params: [
+        {
+          name: "clientId",
+          in: "body",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "POST /SASLogon/login",
+      method: "POST",
+      path: "/SASLogon/login",
+      tag: "Web",
+      summary: "Sign in with a username and password",
+      params: [
+        {
+          name: "username",
+          in: "body",
+          required: true,
+          type: "string"
+        },
+        {
+          name: "password",
+          in: "body",
+          required: true,
+          type: "string"
+        }
+      ],
+      requestBodies: ["application/json"],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    },
+    {
+      id: "GET /SASLogon/logout",
+      method: "GET",
+      path: "/SASLogon/logout",
+      tag: "Web",
+      summary: "Sign out",
+      params: [],
+      requestBodies: [],
+      responses: [
+        {
+          status: 200,
+          description: "Ok"
+        }
+      ]
+    }
+  ];
+
+  // src/routes/overlay.ts
+  var TAG_CAPABILITIES = {
+    Drive: ["storage"],
+    STP: ["runtime", "storage"],
+    Code: ["runtime"],
+    Session: ["runtime"],
+    Info: [],
+    Admin: ["storage"],
+    Auth: ["identity"],
+    "Auth Config": ["identity"],
+    User: ["identity"],
+    Group: ["identity"],
+    Permission: ["identity"],
+    Client: ["identity"],
+    Web: ["identity"]
+  };
+  var success = { status: "success" };
+  var OVERLAY = {
+    // the route inventory reports what the CALLER may use, so it needs an identity
+    // even though the rest of the Info tag needs nothing
+    "GET /SASjsApi/info/authorizedRoutes": { capabilities: ["identity"] },
+    "GET /SASjsApi/info/myAuthorizedRoutes": { capabilities: ["identity"] },
+    // the body is the file itself, so there is nothing to annotate
+    "GET /SASjsApi/drive/file": { implemented: true },
+    "POST /SASjsApi/drive/file": {
+      implemented: true,
+      responses: { 200: success, 409: "File already exists." }
+    },
+    "PATCH /SASjsApi/drive/file": {
+      implemented: true,
+      responses: { 200: success, 404: `File doesn't exist.` }
+    },
+    "DELETE /SASjsApi/drive/file": {
+      implemented: true,
+      responses: { 200: success, 404: `File doesn't exist.` }
+    },
+    "GET /SASjsApi/drive/folder": {
+      implemented: true,
+      responses: { 200: { files: [], folders: [] } }
+    },
+    "POST /SASjsApi/drive/folder": {
+      implemented: true,
+      responses: { 200: success, 409: "Folder already exists." }
+    },
+    "DELETE /SASjsApi/drive/folder": {
+      implemented: true,
+      responses: { 200: success, 404: `Folder doesn't exist.` }
+    },
+    "POST /SASjsApi/drive/rename": {
+      implemented: true,
+      responses: {
+        200: success,
+        409: "File with new name already exists.",
+        404: "No file/folder found for provided path."
+      }
+    },
+    "GET /SASjsApi/drive/filetree": {
+      implemented: true,
+      responses: { 200: { status: "success", tree: {} } }
+    },
+    // The two deploy routes write a whole tree in one request. They are the only
+    // ones where a caller can exhaust the host's storage, so they carry a cap -
+    // see the plan in sasjs/cli#1550 - and they are not implemented yet.
+    "POST /SASjsApi/drive/deploy": {
+      implemented: false
+    },
+    "POST /SASjsApi/drive/deploy/upload": {
+      implemented: false
+    }
+  };
+
+  // src/routes/index.ts
+  var merge = (generated) => {
+    const overlay = OVERLAY[generated.id] || {};
+    const documented = new Map(
+      generated.responses.map((r) => [r.status, r.description])
+    );
+    for (const status of Object.keys(overlay.responses || {}).map(Number)) {
+      if (!documented.has(status)) {
+        throw new Error(
+          `src/routes/overlay.ts annotates status ${status} for ${generated.id}, which the OpenAPI document does not state. Correct the document in sasjs/server and re-vendor spec/swagger.yaml, or drop the annotation.`
+        );
+      }
+    }
+    const responses = [...documented.keys()].sort((a, b) => a - b).map((status) => {
+      const body = overlay.responses ? overlay.responses[status] : void 0;
+      return {
+        status,
+        description: documented.get(status) || "",
+        ...body === void 0 ? {} : { body }
+      };
+    });
+    return {
+      ...generated,
+      responses,
+      capabilities: overlay.capabilities || TAG_CAPABILITIES[generated.tag] || [],
+      implemented: overlay.implemented === true
+    };
+  };
+  var ROUTES = GENERATED_ROUTES.map(merge);
+  var known = new Set(ROUTES.map((route) => route.id));
+  for (const id of Object.keys(OVERLAY))
+    if (!known.has(id))
+      throw new Error(
+        `src/routes/overlay.ts names an operation the OpenAPI document does not have: ${id}. Remove the entry or refresh spec/swagger.yaml.`
+      );
+  var byId = new Map(ROUTES.map((route) => [route.id, route]));
+  var routeById = (id) => byId.get(id);
+  var escape = (segment) => segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  var compiled = ROUTES.filter((route) => route.path.includes("{")).map(
+    (route) => {
+      const keys = [];
+      const pattern = route.path.split("/").map((segment) => {
+        if (segment.startsWith("{") && segment.endsWith("}")) {
+          keys.push(segment.slice(1, -1));
+          return "([^/]+)";
+        }
+        return escape(segment);
+      }).join("/");
+      return { route, keys, regex: new RegExp("^" + pattern + "/?$") };
+    }
+  );
+  var exact = /* @__PURE__ */ new Map();
+  for (const route of ROUTES)
+    if (!route.path.includes("{"))
+      exact.set(route.method + " " + route.path, route);
+  var findRoute = (method, path) => {
+    const verb = method.toUpperCase();
+    const clean = path.split("?")[0].replace(/\/+$/, "") || "/";
+    const hit = exact.get(verb + " " + clean);
+    if (hit) return { route: hit, params: {} };
+    for (const candidate of compiled) {
+      if (candidate.route.method !== verb) continue;
+      const match = candidate.regex.exec(clean);
+      if (!match) continue;
+      const params = {};
+      candidate.keys.forEach((key, index) => {
+        try {
+          params[key] = decodeURIComponent(match[index + 1]);
+        } catch {
+          params[key] = match[index + 1];
+        }
+      });
+      return { route: candidate.route, params };
+    }
+    return void 0;
+  };
+
+  // src/host/dispatch.ts
+  var validate = (route, request) => {
+    for (const param of route.params) {
+      if (!param.required || param.in === "formData" || param.in === "header")
+        continue;
+      if (param.in === "path") continue;
+      const given = param.in === "query" ? request.query?.[param.name] : request.body?.[param.name];
+      if (given === void 0 || given === "")
+        throw new ApiError(400, `"${param.name}" is required`);
+    }
+  };
+  var targetPath = (request) => {
+    const fromQuery = request.query?._filePath;
+    const fromBody = request.body?.filePath;
+    const path = fromQuery !== void 0 ? String(fromQuery) : fromBody;
+    if (path === void 0) throw new ApiError(400, '"_filePath" is required');
+    return path;
+  };
+  var dispatch = async (services, routeId, request = {}) => {
+    const route = routeById(routeId);
+    if (!route) throw new ApiError(404, `No such operation: ${routeId}`);
+    validate(route, request);
+    const { drive } = services;
+    const query = request.query || {};
+    switch (routeId) {
+      case "GET /SASjsApi/drive/file": {
+        const file = await drive.read(String(query._filePath || ""));
+        return { status: 200, contents: file.contents };
+      }
+      case "POST /SASjsApi/drive/file":
+      case "PATCH /SASjsApi/drive/file": {
+        if (!request.file) throw new ApiError(400, '"file" is not present.');
+        const path = targetPath(request);
+        const result = routeId === "PATCH /SASjsApi/drive/file" ? await drive.update(path, request.file.contents) : await drive.save(path, request.file.contents);
+        return { status: 200, body: result };
+      }
+      case "DELETE /SASjsApi/drive/file":
+        return {
+          status: 200,
+          body: await drive.remove(String(query._filePath || ""))
+        };
+      case "GET /SASjsApi/drive/folder":
+        return { status: 200, body: await drive.list(query._folderPath) };
+      case "POST /SASjsApi/drive/folder":
+        return {
+          status: 200,
+          body: await drive.mkdir(String(request.body?.folderPath || ""))
+        };
+      case "DELETE /SASjsApi/drive/folder":
+        return {
+          status: 200,
+          body: await drive.rmdir(String(query._folderPath || ""))
+        };
+      case "POST /SASjsApi/drive/rename":
+        return {
+          status: 200,
+          body: await drive.rename(
+            String(request.body?.oldPath || ""),
+            String(request.body?.newPath || "")
+          )
+        };
+      case "GET /SASjsApi/drive/filetree":
+        return { status: 200, body: await drive.tree(query._folderPath) };
+      default:
+        throw new ApiError(501, `This package has no handler for ${routeId}.`);
+    }
+  };
+  var HANDLED_ROUTES = [
+    "GET /SASjsApi/drive/file",
+    "POST /SASjsApi/drive/file",
+    "PATCH /SASjsApi/drive/file",
+    "DELETE /SASjsApi/drive/file",
+    "GET /SASjsApi/drive/folder",
+    "POST /SASjsApi/drive/folder",
+    "DELETE /SASjsApi/drive/folder",
+    "POST /SASjsApi/drive/rename",
+    "GET /SASjsApi/drive/filetree"
+  ];
+
+  // src/corpus/drive.ts
+  var success2 = { status: "success" };
+  var bytes = (...values) => Uint8Array.from(values);
+  var DRIVE_CORPUS = [
+    {
+      id: "create-file",
+      route: "POST /SASjsApi/drive/file",
+      description: "creates a file the drive did not have",
+      request: {
+        query: { _filePath: "/data/users.csv" },
+        file: { name: "users.csv", contents: "id,name\n1,Ann\n" }
+      },
+      expect: { status: 200, body: success2 }
+    },
+    {
+      id: "create-file-at-form-path",
+      route: "POST /SASjsApi/drive/file",
+      description: "takes the destination from the form field when the query has none",
+      request: {
+        file: { name: "x.csv", contents: "x" },
+        body: { filePath: "/data/from-form.csv" }
+      },
+      expect: { status: 200, body: success2 }
+    },
+    {
+      id: "create-file-over-existing",
+      route: "POST /SASjsApi/drive/file",
+      description: "refuses a create over a file that exists, as 409",
+      seed: { "/data/exists.csv": "a" },
+      request: {
+        query: { _filePath: "/data/exists.csv" },
+        file: { name: "x", contents: "b" }
+      },
+      expect: { status: 409, error: "File already exists." }
+    },
+    {
+      id: "create-file-blocked-extension",
+      route: "POST /SASjsApi/drive/file",
+      description: "refuses a refused extension before touching the drive",
+      request: {
+        query: { _filePath: "/data/run.sh" },
+        file: { name: "run.sh", contents: "x" }
+      },
+      expect: { status: 400, error: "Invalid file extension" }
+    },
+    {
+      id: "create-file-outside-drive",
+      route: "POST /SASjsApi/drive/file",
+      description: "refuses a path that climbs out of the drive",
+      request: {
+        query: { _filePath: "/../escape.csv" },
+        file: { name: "x", contents: "x" }
+      },
+      expect: { status: 400, error: "Can't put file outside drive." }
+    },
+    {
+      id: "create-file-without-payload",
+      route: "POST /SASjsApi/drive/file",
+      description: "answers for a missing file with the server wording",
+      request: { query: { _filePath: "/data/x.csv" } },
+      expect: { status: 400, error: '"file" is not present.' }
+    },
+    {
+      id: "create-file-without-destination",
+      route: "POST /SASjsApi/drive/file",
+      description: "answers for a missing destination with the validation wording",
+      request: { file: { name: "x", contents: "x" } },
+      expect: { status: 400, error: '"_filePath" is required' }
+    },
+    {
+      id: "replace-file",
+      route: "PATCH /SASjsApi/drive/file",
+      description: "replaces the contents of a file that exists",
+      seed: { "/data/keep.csv": "old" },
+      request: {
+        query: { _filePath: "/data/keep.csv" },
+        file: { name: "keep.csv", contents: "new" }
+      },
+      expect: { status: 200, body: success2 }
+    },
+    {
+      id: "replace-file-missing",
+      route: "PATCH /SASjsApi/drive/file",
+      description: "refuses a replace of a file that is not there, as 404",
+      request: {
+        query: { _filePath: "/data/missing.csv" },
+        file: { name: "x", contents: "x" }
+      },
+      expect: { status: 404, error: `File doesn't exist.` }
+    },
+    {
+      id: "replace-file-outside-drive",
+      route: "PATCH /SASjsApi/drive/file",
+      description: "refuses a replace of a path that climbs out of the drive",
+      request: {
+        query: { _filePath: "/../escape.csv" },
+        file: { name: "x", contents: "x" }
+      },
+      expect: { status: 400, error: "Can't modify file outside drive." }
+    },
+    {
+      id: "read-file",
+      route: "GET /SASjsApi/drive/file",
+      description: "answers with the file contents",
+      seed: { "/data/keep.csv": "a,b\n1,2\n" },
+      request: { query: { _filePath: "/data/keep.csv" } },
+      expect: { status: 200, contents: "a,b\n1,2\n" }
+    },
+    {
+      id: "read-file-missing",
+      route: "GET /SASjsApi/drive/file",
+      description: "refuses a read of a file that is not there",
+      request: { query: { _filePath: "/data/missing.csv" } },
+      expect: { status: 404, error: `File doesn't exist.` }
+    },
+    {
+      id: "read-file-outside-drive",
+      route: "GET /SASjsApi/drive/file",
+      description: "refuses a read of a path that climbs out of the drive",
+      request: { query: { _filePath: "/../escape.csv" } },
+      expect: { status: 400, error: "Can't get file outside drive." }
+    },
+    {
+      id: "delete-file",
+      route: "DELETE /SASjsApi/drive/file",
+      description: "deletes a file that exists",
+      seed: { "/data/keep.csv": "a" },
+      request: { query: { _filePath: "/data/keep.csv" } },
+      expect: { status: 200, body: success2 }
+    },
+    {
+      id: "delete-file-missing",
+      route: "DELETE /SASjsApi/drive/file",
+      description: "refuses a delete of a file that is not there",
+      request: { query: { _filePath: "/data/missing.csv" } },
+      expect: { status: 404, error: `File doesn't exist.` }
+    },
+    {
+      id: "delete-file-outside-drive",
+      route: "DELETE /SASjsApi/drive/file",
+      description: "refuses a delete of a path that climbs out of the drive",
+      request: { query: { _filePath: "/../escape.csv" } },
+      expect: { status: 400, error: "Can't delete file outside drive." }
+    },
+    {
+      id: "list-folder",
+      route: "GET /SASjsApi/drive/folder",
+      description: "lists the files and folders of a folder",
+      seed: { "/data/a.csv": "a", "/data/reports/b.csv": "b" },
+      request: { query: { _folderPath: "/data" } },
+      expect: { status: 200, body: { files: ["a.csv"], folders: ["reports"] } }
+    },
+    {
+      id: "list-folder-missing",
+      route: "GET /SASjsApi/drive/folder",
+      description: "refuses a listing of a folder that is not there",
+      request: { query: { _folderPath: "/nope" } },
+      expect: { status: 404, error: `Folder doesn't exist.` }
+    },
+    {
+      id: "list-folder-outside-drive",
+      route: "GET /SASjsApi/drive/folder",
+      description: "refuses a listing of a path that climbs out of the drive",
+      request: { query: { _folderPath: "/../escape" } },
+      expect: { status: 400, error: "Can't get folder outside drive." }
+    },
+    {
+      id: "delete-folder-without-path",
+      route: "DELETE /SASjsApi/drive/folder",
+      description: "answers for a missing folder path, because the table marks it required",
+      request: {},
+      expect: { status: 400, error: '"_folderPath" is required' }
+    },
+    {
+      id: "create-folder-without-path",
+      route: "POST /SASjsApi/drive/folder",
+      description: "answers for a missing folder path in the body",
+      request: { body: {} },
+      expect: { status: 400, error: '"folderPath" is required' }
+    },
+    {
+      id: "create-folder",
+      route: "POST /SASjsApi/drive/folder",
+      description: "creates a folder",
+      request: { body: { folderPath: "/data/reports" } },
+      expect: { status: 200, body: success2 }
+    },
+    {
+      id: "create-folder-existing",
+      route: "POST /SASjsApi/drive/folder",
+      description: "refuses a folder that already exists, as 409",
+      seed: { "/data/reports/a.csv": "a" },
+      request: { body: { folderPath: "/data/reports" } },
+      expect: { status: 409, error: "Folder already exists." }
+    },
+    {
+      id: "delete-folder",
+      route: "DELETE /SASjsApi/drive/folder",
+      description: "deletes a folder with everything under it",
+      seed: { "/data/reports/a.csv": "a", "/data/reports/nested/b.csv": "b" },
+      request: { query: { _folderPath: "/data/reports" } },
+      expect: { status: 200, body: success2 }
+    },
+    {
+      id: "delete-folder-missing",
+      route: "DELETE /SASjsApi/drive/folder",
+      description: "refuses a delete of a folder that is not there",
+      request: { query: { _folderPath: "/nope" } },
+      expect: { status: 404, error: `Folder doesn't exist.` }
+    },
+    {
+      id: "rename-file",
+      route: "POST /SASjsApi/drive/rename",
+      description: "moves a file to a new path",
+      seed: { "/data/old.csv": "r" },
+      request: { body: { oldPath: "/data/old.csv", newPath: "/data/new.csv" } },
+      expect: { status: 200, body: success2 }
+    },
+    {
+      id: "rename-onto-existing",
+      route: "POST /SASjsApi/drive/rename",
+      description: "refuses a move onto something that exists",
+      seed: { "/data/a.csv": "a", "/data/b.csv": "b" },
+      request: { body: { oldPath: "/data/a.csv", newPath: "/data/b.csv" } },
+      expect: { status: 409, error: "File with new name already exists." }
+    },
+    {
+      id: "rename-missing",
+      route: "POST /SASjsApi/drive/rename",
+      description: "refuses a move of something that is not there",
+      request: { body: { oldPath: "/data/nope.csv", newPath: "/data/x.csv" } },
+      expect: { status: 404, error: "No file/folder found for provided path." }
+    },
+    {
+      id: "rename-folder-into-itself",
+      route: "POST /SASjsApi/drive/rename",
+      description: "refuses a folder moved inside itself, which the server loses at the filesystem",
+      seed: { "/data/reports/a.csv": "a" },
+      request: {
+        body: { oldPath: "/data/reports", newPath: "/data/reports/nested" }
+      },
+      expect: {
+        status: 400,
+        error: "New path can't be inside the folder being moved."
+      }
+    },
+    {
+      id: "tree",
+      route: "GET /SASjsApi/drive/filetree",
+      description: "answers with the drive tree",
+      seed: { "/data/a.csv": "a" },
+      request: { query: { _folderPath: "/data" } },
+      expect: {
+        status: 200,
+        body: {
+          status: "success",
+          tree: {
+            name: "data",
+            relativePath: "/data",
+            isFolder: true,
+            children: [
+              {
+                name: "a.csv",
+                relativePath: "/data/a.csv",
+                isFolder: false,
+                children: []
+              }
+            ]
+          }
+        }
+      }
+    },
+    {
+      id: "bytes-round-trip",
+      route: "GET /SASjsApi/drive/file",
+      description: "keeps a byte file as bytes",
+      seed: { "/data/pack.zip": bytes(80, 75, 3, 4) },
+      request: { query: { _filePath: "/data/pack.zip" } },
+      expect: { status: 200, contents: bytes(80, 75, 3, 4) }
+    }
+  ];
+
+  // src/corpus/runner.ts
+  var servicesFor = (testCase) => ({
+    drive: createDriveService(new MemoryDriveStore(testCase.seed || {}))
+  });
+  var runCase = async (testCase, services = servicesFor(testCase)) => {
+    try {
+      const response = await dispatch(services, testCase.route, testCase.request);
+      return {
+        status: response.status,
+        body: response.body,
+        contents: response.contents
+      };
+    } catch (error) {
+      if (isApiError(error)) return { status: error.status, error: error.message };
+      throw error;
+    }
+  };
+  return __toCommonJS(index_exports);
+})();
+if (typeof self !== 'undefined') self.SASjsApi = SASjsApi