@deepnote/cloud-mock 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,2 @@
+import { a as sendError, i as sendBytes, n as MOCK_WORKSPACE_NAME, o as sendJson, r as HttpError, t as startMockDeepnoteCloud } from "./server-CcG0_Okb.js";
+export { HttpError, MOCK_WORKSPACE_NAME, sendBytes, sendError, sendJson, startMockDeepnoteCloud };

package/dist/server-BFi0ADBB.cjs

@@ -0,0 +1,588 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_crypto = require("node:crypto");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_stream_consumers = require("node:stream/consumers");
+let _deepnote_blocks = require("@deepnote/blocks");
+let fflate = require("fflate");
+let zod = require("zod");
+let node_events = require("node:events");
+let node_http = require("node:http");
+let node_os = require("node:os");
+node_os = __toESM(node_os, 1);
+//#region src/http.ts
+/** Thrown from a route, `onRequest` or `onNotFound`, answers the request with `status` and an `ErrorResponse` body. */
+var HttpError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+	}
+};
+/** Answers with `body` as JSON. */
+function sendJson(res, status, body) {
+	const text = JSON.stringify(body);
+	res.writeHead(status, { "Content-Type": "application/json" }).end(text);
+}
+/** Answers with `status` and the `ErrorResponse` body `{ message }`. */
+function sendError(res, status, message) {
+	sendJson(res, status, { message });
+}
+/** Answers with a 200 of `bytes` as `contentType`. */
+function sendBytes(res, contentType, bytes) {
+	res.writeHead(200, { "Content-Type": contentType }).end(bytes);
+}
+//#endregion
+//#region src/utils.ts
+const EPOCH = (/* @__PURE__ */ new Date(0)).toISOString();
+const decoder = new TextDecoder();
+function parseDocument(content) {
+	return (0, _deepnote_blocks.deserializeDeepnoteFile)(decoder.decode(content));
+}
+function sha256(data) {
+	return (0, node_crypto.createHash)("sha256").update(data).digest("hex");
+}
+/** The content hash from `packages/cloud/docs/project-import-contract.md`. */
+function canonicalHash(files) {
+	return sha256(files.map(({ filename, content }) => `${filename}\n${sha256(content)}`).sort().join("\n"));
+}
+function projectModifiedAt(files) {
+	const first = files.at(0);
+	return first ? parseDocument(first.content).metadata.modifiedAt ?? EPOCH : EPOCH;
+}
+function importedNotebooks(document, action) {
+	return document.project.notebooks.map(({ id, name }) => ({
+		id,
+		name,
+		action
+	}));
+}
+function dataAppSettings({ url, publishedDataApps }, { id, projectType }) {
+	return projectType === "data_app" ? {
+		published: publishedDataApps.has(id),
+		url: `${url}/apps/${id}/`
+	} : null;
+}
+//#endregion
+//#region src/file-utils.ts
+const NOTEBOOK_FILE = /^[^/\\]+\.deepnote$/;
+const FILES_DIR = ".files";
+const DATA_APP_MARKER = ".data-app";
+async function statIfExists(target) {
+	try {
+		return await node_fs_promises.default.stat(target);
+	} catch (error) {
+		const { code } = error;
+		if (code === "ENOENT" || code === "ENOTDIR") return;
+		throw error;
+	}
+}
+/** Sorted the way `@deepnote/cloud`'s `exportProject` sorts them, so the first one is the one
+* sync reads `modifiedAt` from. */
+async function readNotebookFiles(projectDir) {
+	const filenames = (await node_fs_promises.default.readdir(projectDir, { withFileTypes: true })).filter((entry) => entry.isFile() && NOTEBOOK_FILE.test(entry.name)).map(({ name }) => name).sort((a, b) => a.localeCompare(b));
+	return Promise.all(filenames.map(async (filename) => ({
+		filename,
+		content: await node_fs_promises.default.readFile(node_path.default.join(projectDir, filename))
+	})));
+}
+async function projectDir(rootDir, projectId) {
+	const dir = node_path.default.join(rootDir, projectId);
+	if (!(await statIfExists(dir))?.isDirectory()) throw new HttpError(404, "Project not found");
+	return dir;
+}
+function normalizeFilePath(rawPath) {
+	const trimmedPath = rawPath.trim();
+	if (!trimmedPath) throw new HttpError(400, "path is required");
+	if (trimmedPath.includes("\0")) throw new HttpError(400, "path must not contain null bytes");
+	if (trimmedPath.split("/").filter((segment) => segment.length > 0).includes("..")) throw new HttpError(400, "path must not contain directory traversal");
+	if (trimmedPath.endsWith("/")) throw new HttpError(400, "path must reference a file, not a directory");
+	const normalizedPath = node_path.default.posix.normalize(trimmedPath).replace(/^\/+/, "");
+	if (!normalizedPath || normalizedPath === ".") throw new HttpError(400, "path is required");
+	return normalizedPath;
+}
+function workingFile(filesDir, value) {
+	const target = node_path.default.resolve(filesDir, normalizeFilePath(value));
+	if (!target.startsWith(filesDir + node_path.default.sep)) throw new HttpError(400, "Invalid path");
+	return target;
+}
+async function freeWorkingFile(target) {
+	const { dir, name, ext } = node_path.default.parse(target);
+	for (let n = 1;; n++) {
+		const candidate = node_path.default.join(dir, `${name} (${n})${ext}`);
+		if (!await statIfExists(candidate)) return candidate;
+	}
+}
+async function listWorkingFiles(filesDir) {
+	if (!(await statIfExists(filesDir))?.isDirectory()) return [];
+	const filePaths = (await node_fs_promises.default.readdir(filesDir, {
+		recursive: true,
+		withFileTypes: true
+	})).filter((entry) => entry.isFile()).map((entry) => node_path.default.relative(filesDir, node_path.default.join(entry.parentPath, entry.name)).split(node_path.default.sep).join("/")).sort();
+	return Promise.all(filePaths.map(async (filePath) => {
+		const { size, mtime } = await node_fs_promises.default.stat(node_path.default.join(filesDir, filePath));
+		return {
+			name: node_path.default.posix.basename(filePath),
+			path: filePath,
+			type: "file",
+			size,
+			updatedAt: mtime.toISOString()
+		};
+	}));
+}
+async function projectSummary(dir) {
+	const id = node_path.default.basename(dir);
+	const first = (await readNotebookFiles(dir)).at(0);
+	const { birthtime, mtime } = await node_fs_promises.default.stat(dir);
+	return {
+		id,
+		name: first ? parseDocument(first.content).project.name : id,
+		projectType: (await statIfExists(node_path.default.join(dir, ".data-app")))?.isFile() ? "data_app" : "standard",
+		createdAt: birthtime.toISOString(),
+		updatedAt: mtime.toISOString(),
+		folder: null
+	};
+}
+//#endregion
+//#region src/schemas.ts
+const BooleanQueryParamSchema = zod.z.enum(["true", "false"]).transform((value) => value === "true");
+const ProjectIdSchema = zod.z.uuid().brand();
+const ProjectIdParamSchema = zod.z.object({ projectId: ProjectIdSchema });
+const FileReferenceQuerySchema = zod.z.strictObject({
+	projectId: ProjectIdSchema,
+	path: zod.z.string().min(1)
+});
+const CreateFileMultipartFieldsSchema = zod.z.strictObject({
+	projectId: ProjectIdSchema,
+	path: zod.z.string().min(1),
+	overwrite: BooleanQueryParamSchema.optional().default(false)
+});
+const CreateProjectBodySchema = zod.z.strictObject({
+	name: zod.z.string().min(1),
+	folderId: zod.z.uuid().optional(),
+	projectType: zod.z.enum([
+		"standard",
+		"notebook",
+		"agent",
+		"data_app",
+		"streamlit_app"
+	]).optional(),
+	environmentId: zod.z.uuid().optional()
+});
+const UpdateProjectBodySchema = zod.z.strictObject({
+	dataApp: zod.z.strictObject({ published: zod.z.boolean() }).optional(),
+	environmentId: zod.z.uuid().optional(),
+	folderId: zod.z.uuid().nullable().optional()
+}).refine((update) => update.dataApp !== void 0 || update.environmentId !== void 0 || update.folderId !== void 0, { message: "At least one project setting must be provided." });
+const ImportProjectQuerySchema = zod.z.strictObject({
+	baseModifiedAt: zod.z.iso.datetime().optional(),
+	baseContentHash: zod.z.string().regex(/^[0-9a-f]{64}$/, "Must be a 64-character lowercase SHA-256 hex digest.").optional(),
+	deleteMissingNotebooks: BooleanQueryParamSchema.optional().default(false),
+	force: BooleanQueryParamSchema.optional().default(false)
+});
+/** Parses `input`, throwing a 400 {@link HttpError} that names each invalid field. */
+function parseRequestInput(schema, input) {
+	const result = schema.safeParse(input, { error: (issue) => issue.code === "invalid_type" && issue.input === void 0 ? "is required" : void 0 });
+	if (!result.success) throw new HttpError(400, readableErrors(result.error));
+	return result.data;
+}
+function readableErrors(error) {
+	return error.issues.map((issue) => {
+		const field = issue.path.map(String).join(".");
+		return field ? `${field} ${issue.message.toLowerCase()}` : issue.message;
+	}).join("; ");
+}
+//#endregion
+//#region src/mock-deepnote-cloud.ts
+const MOCK_WORKSPACE_NAME = "Mock Workspace";
+const DATA_APP_PLACEHOLDER_HTML = "<!doctype html>\n<title>Untitled data app</title>\n";
+const ME = {
+	apiKey: {
+		id: "3a9e5c1d-7f2b-4d6e-8c0a-1b4f6d8e2a5c",
+		name: "Mock API key",
+		type: "public-api",
+		createdAt: "2026-01-01T00:00:00.000Z",
+		lastUsedAt: null,
+		expiresAt: null
+	},
+	user: {
+		id: "0b3c6f1e-2d4a-4e8b-9c7d-5a1f3e2b8c4d",
+		email: null,
+		name: null
+	},
+	workspace: {
+		id: "7e2d9a4c-1b5f-4c3e-8a6d-9f0b2c4e6a8d",
+		name: MOCK_WORKSPACE_NAME,
+		slug: "mock-workspace"
+	},
+	accessLevel: "admin"
+};
+async function readJsonBody(req) {
+	if (req.headers["content-type"]?.split(";")[0]?.trim().toLowerCase() !== "application/json") return {};
+	const body = await (0, node_stream_consumers.text)(req);
+	if (body === "") return {};
+	const value = JSON.parse(body);
+	if (typeof value !== "object" || value === null) throw new SyntaxError("The JSON body is not an object or array");
+	return value;
+}
+async function listProjects({ rootDir, res }) {
+	const ids = (await node_fs_promises.default.readdir(rootDir, { withFileTypes: true })).filter((entry) => entry.isDirectory() && ProjectIdSchema.safeParse(entry.name).success).map(({ name }) => name).sort();
+	const projects = await Promise.all(ids.map(async (id) => ({
+		...await projectSummary(node_path.default.join(rootDir, id)),
+		notebooks: []
+	})));
+	sendJson(res, 200, {
+		projects,
+		pagination: {
+			pageSize: projects.length,
+			nextPageToken: null,
+			hasMore: false
+		}
+	});
+}
+async function createProject({ rootDir, req, res }) {
+	const { name, folderId, projectType, environmentId } = parseRequestInput(CreateProjectBodySchema, await readJsonBody(req));
+	if (projectType !== void 0 && projectType !== "standard" && projectType !== "data_app") throw new HttpError(400, "The mock creates only standard and data_app projects");
+	if (folderId !== void 0) throw new HttpError(404, "Folder not found");
+	if (environmentId !== void 0) throw new HttpError(404, "Environment not found");
+	const projectId = (0, node_crypto.randomUUID)();
+	const dir = node_path.default.join(rootDir, projectId);
+	await node_fs_promises.default.mkdir(dir);
+	if (projectType === "data_app") {
+		await node_fs_promises.default.writeFile(node_path.default.join(dir, DATA_APP_MARKER), "");
+		await node_fs_promises.default.mkdir(node_path.default.join(dir, FILES_DIR, "_deepnote_static"), { recursive: true });
+		await node_fs_promises.default.writeFile(node_path.default.join(dir, FILES_DIR, "_deepnote_static/index.html"), DATA_APP_PLACEHOLDER_HTML);
+	}
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const notebook = {
+		id: (0, node_crypto.randomUUID)(),
+		name: "Notebook 1",
+		blocks: []
+	};
+	await node_fs_promises.default.writeFile(node_path.default.join(dir, "notebook.deepnote"), (0, _deepnote_blocks.serializeDeepnoteFile)({
+		version: "1.0.0",
+		metadata: {
+			createdAt: now,
+			modifiedAt: now
+		},
+		project: {
+			id: projectId,
+			name,
+			notebooks: [notebook]
+		}
+	}));
+	const summary = await projectSummary(dir);
+	sendJson(res, 201, { project: {
+		...summary,
+		notebooks: [{
+			id: notebook.id,
+			projectId,
+			name: notebook.name,
+			createdAt: summary.createdAt,
+			isInit: false,
+			isScheduled: false,
+			lastRunAt: null
+		}],
+		environment: null
+	} });
+}
+async function getProject(request) {
+	const { projectId } = parseRequestInput(ProjectIdParamSchema, { projectId: request.pathProjectId });
+	const dir = await projectDir(request.rootDir, projectId);
+	const summary = await projectSummary(dir);
+	const body = { project: {
+		...summary,
+		notebooks: [],
+		integrations: [],
+		files: await listWorkingFiles(node_path.default.join(dir, FILES_DIR)),
+		dataApp: dataAppSettings(request, summary),
+		environment: null
+	} };
+	sendJson(request.res, 200, body);
+}
+async function updateProject(request) {
+	const { projectId } = parseRequestInput(ProjectIdParamSchema, { projectId: request.pathProjectId });
+	const { dataApp: update } = parseRequestInput(UpdateProjectBodySchema, await readJsonBody(request.req));
+	const summary = await projectSummary(await projectDir(request.rootDir, projectId));
+	if (update) {
+		if (summary.projectType !== "data_app") throw new HttpError(400, "Only data apps can be published.");
+		if (update.published) request.publishedDataApps.add(summary.id);
+		else request.publishedDataApps.delete(summary.id);
+	}
+	const body = { project: {
+		...summary,
+		dataApp: dataAppSettings(request, summary),
+		environment: null
+	} };
+	sendJson(request.res, 200, body);
+}
+async function exportProject({ rootDir, res, pathProjectId }) {
+	const { projectId } = parseRequestInput(ProjectIdParamSchema, { projectId: pathProjectId });
+	const files = await readNotebookFiles(await projectDir(rootDir, projectId));
+	sendBytes(res, "application/zip", (0, fflate.zipSync)(Object.fromEntries(files.map((file) => [file.filename, file.content]))));
+}
+async function importProject({ rootDir, req, res, requestUrl, pathProjectId }) {
+	const { projectId } = parseRequestInput(ProjectIdParamSchema, { projectId: pathProjectId });
+	const options = parseRequestInput(ImportProjectQuerySchema, Object.fromEntries(requestUrl.searchParams));
+	if (req.headers["content-type"]?.split(";")[0]?.trim().toLowerCase() !== "application/zip") throw new HttpError(400, "Content-Type must be application/zip");
+	const dir = await projectDir(rootDir, projectId);
+	const body = await (0, node_stream_consumers.buffer)(req);
+	const archive = Object.entries((0, fflate.unzipSync)(body)).map(([filename, content]) => ({
+		filename,
+		content
+	}));
+	if (!archive.every(({ filename }) => NOTEBOOK_FILE.test(filename))) throw new HttpError(422, "The archive may contain only .deepnote files");
+	const documents = archive.map((file) => ({
+		...file,
+		document: parseDocument(file.content)
+	}));
+	const projects = documents.map(({ document }) => document.project);
+	if (projects.some((project) => project.id !== projectId)) throw new HttpError(422, "A document belongs to another project");
+	if (projects.some((project) => project.notebooks.length !== 1)) throw new HttpError(422, "A document must contain exactly one notebook");
+	const current = await readNotebookFiles(dir);
+	if (!options.force) {
+		const { baseModifiedAt, baseContentHash } = options;
+		if (baseModifiedAt && new Date(baseModifiedAt).getTime() !== new Date(projectModifiedAt(current)).getTime()) throw new HttpError(409, "Project structure changed since it was exported.");
+		if (baseContentHash && baseContentHash !== canonicalHash(current)) throw new HttpError(409, "Project content changed since it was exported.");
+	}
+	const imported = new Set(archive.map(({ filename }) => filename));
+	const missing = options.deleteMissingNotebooks ? current.filter(({ filename }) => !imported.has(filename)) : [];
+	const deletedNotebooks = missing.flatMap(({ content }) => importedNotebooks(parseDocument(content), "deleted"));
+	const existing = new Set(current.map(({ filename }) => filename));
+	const notebooks = [];
+	for (const { filename, content, document } of documents) {
+		await node_fs_promises.default.writeFile(node_path.default.join(dir, filename), content);
+		notebooks.push(...importedNotebooks(document, existing.has(filename) ? "overwritten" : "created"));
+	}
+	for (const { filename } of missing) await node_fs_promises.default.rm(node_path.default.join(dir, filename));
+	notebooks.push(...deletedNotebooks);
+	const after = await readNotebookFiles(dir);
+	sendJson(res, 200, {
+		project: {
+			id: projectId,
+			modifiedAt: projectModifiedAt(after),
+			contentHash: canonicalHash(after)
+		},
+		notebooks
+	});
+}
+async function downloadFile({ rootDir, res, requestUrl }) {
+	const { projectId, path: filePath } = parseRequestInput(FileReferenceQuerySchema, Object.fromEntries(requestUrl.searchParams));
+	const target = workingFile(node_path.default.join(rootDir, projectId, FILES_DIR), filePath);
+	const stats = await statIfExists(target);
+	if (!stats) throw new HttpError(404, "File not found");
+	if (!stats.isFile()) throw new HttpError(400, "Path is not a file");
+	sendBytes(res, "application/octet-stream", await node_fs_promises.default.readFile(target));
+}
+async function uploadFile({ rootDir, req, res, requestUrl }) {
+	const body = await (0, node_stream_consumers.buffer)(req);
+	let form;
+	try {
+		form = await new Request(requestUrl, {
+			method: "POST",
+			headers: { "Content-Type": req.headers["content-type"] ?? "" },
+			body
+		}).formData();
+	} catch {
+		throw new HttpError(400, "Expected a multipart upload");
+	}
+	const { projectId, path: requestedPath, overwrite } = parseRequestInput(CreateFileMultipartFieldsSchema, Object.fromEntries([...form].filter(([, value]) => typeof value === "string")));
+	const file = form.get("file");
+	if (file === null || typeof file === "string") throw new HttpError(400, "file is required");
+	const filesDir = node_path.default.join(rootDir, projectId, FILES_DIR);
+	const requested = workingFile(filesDir, requestedPath);
+	await projectDir(rootDir, projectId);
+	const stored = !overwrite && await statIfExists(requested) ? await freeWorkingFile(requested) : requested;
+	await node_fs_promises.default.mkdir(node_path.default.dirname(stored), { recursive: true });
+	await node_fs_promises.default.writeFile(stored, new Uint8Array(await file.arrayBuffer()));
+	const { size, mtime } = await node_fs_promises.default.stat(stored);
+	sendJson(res, 201, { file: {
+		projectId,
+		path: node_path.default.relative(filesDir, stored).split(node_path.default.sep).join("/"),
+		size,
+		updatedAt: mtime.toISOString()
+	} });
+}
+async function deleteFile({ rootDir, res, requestUrl }) {
+	const { projectId, path: filePath } = parseRequestInput(FileReferenceQuerySchema, Object.fromEntries(requestUrl.searchParams));
+	const target = workingFile(node_path.default.join(rootDir, projectId, FILES_DIR), filePath);
+	const stats = await statIfExists(target);
+	if (!stats) throw new HttpError(404, "File not found");
+	if (!stats.isFile()) throw new HttpError(400, "Path is not a file");
+	await node_fs_promises.default.rm(target);
+	res.writeHead(204).end();
+}
+const ROUTES = [
+	{
+		method: "GET",
+		pattern: /^\/v2\/me$/,
+		handle: async ({ res }) => sendJson(res, 200, ME)
+	},
+	{
+		method: "GET",
+		pattern: /^\/v2\/projects$/,
+		handle: listProjects
+	},
+	{
+		method: "POST",
+		pattern: /^\/v2\/projects$/,
+		handle: createProject
+	},
+	{
+		method: "GET",
+		pattern: /^\/v2\/projects\/([^/]+)$/,
+		handle: getProject
+	},
+	{
+		method: "PATCH",
+		pattern: /^\/v2\/projects\/([^/]+)$/,
+		handle: updateProject
+	},
+	{
+		method: "GET",
+		pattern: /^\/v2\/projects\/([^/]+)\/export$/,
+		handle: exportProject
+	},
+	{
+		method: "POST",
+		pattern: /^\/v2\/projects\/([^/]+)\/import$/,
+		handle: importProject
+	},
+	{
+		method: "GET",
+		pattern: /^\/v2\/files\/download$/,
+		handle: downloadFile
+	},
+	{
+		method: "POST",
+		pattern: /^\/v2\/files$/,
+		handle: uploadFile
+	},
+	{
+		method: "DELETE",
+		pattern: /^\/v2\/files$/,
+		handle: deleteFile
+	}
+];
+//#endregion
+//#region src/server.ts
+async function handleRequest(context, { onRequest, onNotFound }, req, res) {
+	if (!req.headers.authorization?.startsWith("Bearer ")) throw new HttpError(401, "Missing API token");
+	const method = req.method ?? "GET";
+	const requestUrl = new URL(req.url ?? "/", context.url);
+	await onRequest?.({
+		method,
+		url: requestUrl
+	});
+	for (const route of ROUTES) {
+		const match = route.method === method ? route.pattern.exec(requestUrl.pathname) : null;
+		if (match) {
+			await route.handle({
+				...context,
+				req,
+				res,
+				requestUrl,
+				pathProjectId: match[1]
+			});
+			return;
+		}
+	}
+	await onNotFound?.(req, res);
+	if (!res.headersSent) throw new HttpError(404, "Not found");
+}
+/** Starts a mock of the Deepnote Cloud API v2 on a free port of `127.0.0.1`. Any Bearer token is accepted. */
+async function startMockDeepnoteCloud(options = {}) {
+	const rootDir = options.rootDir === void 0 ? await node_fs_promises.default.mkdtemp(node_path.default.join(node_os.default.tmpdir(), "deepnote-cloud-")) : node_path.default.resolve(options.rootDir);
+	await node_fs_promises.default.mkdir(rootDir, { recursive: true });
+	const server = (0, node_http.createServer)();
+	server.listen(0, "127.0.0.1");
+	await (0, node_events.once)(server, "listening");
+	const url = `http://127.0.0.1:${server.address().port}`;
+	const context = {
+		rootDir,
+		url,
+		publishedDataApps: /* @__PURE__ */ new Set()
+	};
+	const handling = /* @__PURE__ */ new Set();
+	server.on("request", (req, res) => {
+		res.setHeader("Connection", "close");
+		const handled = handleRequest(context, options, req, res);
+		handling.add(handled);
+		handled.catch((error) => {
+			if (res.headersSent) throw error;
+			sendError(res, error instanceof HttpError ? error.status : 500, error instanceof Error ? error.message : String(error));
+		}).finally(() => handling.delete(handled));
+	});
+	return {
+		rootDir,
+		url,
+		stop: async () => {
+			await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+			await Promise.allSettled(handling);
+			if (options.rootDir === void 0) await node_fs_promises.default.rm(rootDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	};
+}
+//#endregion
+Object.defineProperty(exports, "HttpError", {
+	enumerable: true,
+	get: function() {
+		return HttpError;
+	}
+});
+Object.defineProperty(exports, "MOCK_WORKSPACE_NAME", {
+	enumerable: true,
+	get: function() {
+		return MOCK_WORKSPACE_NAME;
+	}
+});
+Object.defineProperty(exports, "sendBytes", {
+	enumerable: true,
+	get: function() {
+		return sendBytes;
+	}
+});
+Object.defineProperty(exports, "sendError", {
+	enumerable: true,
+	get: function() {
+		return sendError;
+	}
+});
+Object.defineProperty(exports, "sendJson", {
+	enumerable: true,
+	get: function() {
+		return sendJson;
+	}
+});
+Object.defineProperty(exports, "startMockDeepnoteCloud", {
+	enumerable: true,
+	get: function() {
+		return startMockDeepnoteCloud;
+	}
+});