@copilotkit/aimock 1.42.1 → 1.43.0

package/dist/files.js

@@ -0,0 +1,1059 @@
+import { flattenHeaders, generateId, isJsonObject } from "./helpers.js";
+import { applyChaosAsync } from "./chaos.js";
+import { createHash } from "node:crypto";
+
+//#region src/files.ts
+/**
+* OpenAI Files API mock for aimock.
+*
+* Implements the subset of `POST /v1/files`, `GET /v1/files`,
+* `GET /v1/files/{id}`, `GET /v1/files/{id}/content` and
+* `DELETE /v1/files/{id}` that test harnesses need to exercise
+* file-upload flows without touching the real API.
+*
+* Storage is in-memory and per-process (like the video job maps):
+* - metadata lives in `fileStore`
+* - raw bytes live in `fileContents` as `Buffer`s. Bytes are never
+*   round-tripped through a utf8 string, so binary uploads come back
+*   byte-for-byte identical.
+* - `clearFileStore()` wipes both and is wired into the full reset path
+*   (`POST /__aimock/reset` + `LLMock.reset()`)
+*
+* The only memory bound here is per file: {@link FILES_MAX_BYTES} caps one
+* upload. The file COUNT is deliberately unbounded, so total residency grows
+* with the number of uploads until something calls `clearFileStore()` (or the
+* process exits) — a suite that uploads in a loop without resetting will grow
+* this map without limit. That is a real, documented bound, not an OOM defense.
+*
+* The job maps this module otherwise mirrors (fal-audio.ts,
+* openrouter-video.ts, grok-video.ts, byteplus-video.ts) DO cap entry count and
+* FIFO-evict the oldest, and that convention deliberately does NOT apply here.
+* Those hold transient jobs that the real API also expires, so eviction
+* reproduces real behaviour. A file is a durable object: the real API keeps it
+* until the caller deletes it. Silently evicting one would make the mock answer
+* `404 No such file` for a file the caller successfully uploaded and never
+* deleted — an outcome the real API cannot produce, surfacing as an
+* unexplainable flake in the suite under test. Unbounded growth is the honest
+* failure mode; `POST /__aimock/reset` is the lever that reclaims it.
+*
+* Body handling accepts both shapes real SDKs send:
+* - JSON `{ filename, purpose, content }` (test-friendly; `bytes` is an alias
+*   of `content`, and exactly one of the two must be present)
+* - `multipart/form-data` with `purpose` + exactly one payload part named
+*   `file` (or its `content` alias), framed per RFC 2046 §5.1.1 so a payload
+*   containing the boundary token is stored whole rather than truncated at it
+*
+* Both parsers are strict: a malformed body is an OpenAI-shaped
+* `400 invalid_request_error` naming the offending field or part. Nothing is
+* `String()`-coerced and no missing field falls through to a fabricated
+* default, because a mock that quietly stores `"[object Object]"` or a 0-byte
+* file teaches the suite under test that a broken upload succeeded.
+*
+* Every branch journals with `service: "files"` so
+* `GET /__aimock/journal?service=files` selects exactly this traffic, and with
+* `source: "internal"` because — as with fine-tuning — no fixture or proxy
+* ever serves this store. A successful upload journals a SYNTHETIC body
+* describing it (`{ purpose, filename, bytes, content_type, sha256 }`) — never
+* the uploaded octets — exactly as the transcription route journals its
+* multipart audio; a `400` journals the error envelope it answered with, so
+* the reason is readable from the journal; see {@link journalFiles}. Files also
+* honors the inbound API-key boundary via the server dispatch (no bypass),
+* and runs through the chaos gate so retry/backoff suites can inject
+* 500s at the files surface too.
+*/
+/**
+* Purposes accepted on upload — `CreateFileRequest.purpose` in the official
+* `openai/openai-openapi` spec (and the `FilePurpose` type in the SDK).
+* `user_data` is what Responses-API file inputs use, so rejecting it broke the
+* most current flow.
+*/
+const CREATE_PURPOSES = new Set([
+	"assistants",
+	"batch",
+	"fine-tune",
+	"vision",
+	"user_data",
+	"evals"
+]);
+/**
+* Exposed for tests and for callers that want to check a value themselves:
+* the enum this mock enforces on upload.
+*/
+const FILE_CREATE_PURPOSES = [...CREATE_PURPOSES];
+function invalidPurpose(purpose) {
+	return `Invalid purpose '${purpose}'. Expected one of: ${[...CREATE_PURPOSES].join(", ")}`;
+}
+/**
+* `Content-Transfer-Encoding` values that are identity transforms (RFC 2045
+* §6.2): the part body already *is* the file's octets, so storing it verbatim
+* is correct. Everything else (`base64`, `quoted-printable`, …) would have to
+* be decoded before storage, and is rejected instead — see
+* {@link unsupportedPartEncoding}.
+*/
+const IDENTITY_TRANSFER_ENCODINGS = new Set([
+	"7bit",
+	"8bit",
+	"binary",
+	"identity"
+]);
+/**
+* Reject, rather than silently mis-store, a file part that asks for a content
+* encoding this mock does not apply.
+*
+* We deliberately do NOT implement a decoder. RFC 7578 §4.7 deprecates
+* `Content-Transfer-Encoding` in `multipart/form-data` ("Senders SHOULD NOT
+* generate any parts with a Content-Transfer-Encoding header field. Currently,
+* no deployed implementations that send such bodies have been discovered"), and
+* a capture of the clients that actually reach this endpoint — curl `-F`,
+* python `requests`, python `httpx` (the OpenAI Python SDK's transport) and
+* undici `FormData` (the OpenAI Node SDK's transport) — confirms none of them
+* emits one. Storing an encoded body as-is is the harmful outcome: `bytes` and
+* `GET /content` would report the *encoded* form and a hash comparison in a
+* test would fail for a reason the caller cannot see. A loud 400 naming the
+* header is the honest answer for a mock.
+*
+* `identity` counts as a no-op alongside the RFC 2045 §6.2 values: it is the
+* registered `Content-Encoding` for "no transformation", and a client that
+* spells it on `Content-Transfer-Encoding` means the same thing. Rejecting it
+* named a problem that did not exist.
+*
+* Every part is checked, not only the payload part, and the message names the
+* part it came from. While only the payload part was checked, a `base64`
+* `purpose` part slid through to the enum check and 400'd with
+* `Invalid purpose 'YXNzaXN0YW50cw=='`, pointing the caller at the wrong thing.
+*/
+function unsupportedPartEncoding(header, value, partName) {
+	return `Unsupported ${header}: '${value}' on the multipart '${partName}' part. aimock stores part bodies verbatim and does not decode them.${header === "Content-Transfer-Encoding" ? ` RFC 7578 section 4.7 deprecates ${header} in multipart/form-data.` : ""} Send the raw bytes instead.`;
+}
+/**
+* Content types for the handful of extensions test harnesses actually upload.
+* Anything unrecognised falls back to `application/octet-stream` — the safe
+* default for opaque bytes, and what stops a PNG being served (and re-decoded)
+* as UTF-8 text.
+*
+* This is an allowlist of INERT types on purpose. `text/html` is deliberately
+* absent: the mock serves uploaded bytes back from its own origin, so any
+* active type here would let a stored upload script that origin in a browser.
+* HTML uploads round-trip byte-for-byte, they are just served as opaque bytes.
+*/
+const CONTENT_TYPE_BY_EXT = {
+	json: "application/json",
+	jsonl: "application/jsonl",
+	txt: "text/plain; charset=utf-8",
+	md: "text/markdown; charset=utf-8",
+	csv: "text/csv; charset=utf-8",
+	pdf: "application/pdf",
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	webp: "image/webp",
+	wav: "audio/wav",
+	mp3: "audio/mpeg",
+	zip: "application/zip"
+};
+function contentTypeForFilename(filename) {
+	const dot = filename.lastIndexOf(".");
+	if (dot === -1) return "application/octet-stream";
+	return CONTENT_TYPE_BY_EXT[filename.slice(dot + 1).toLowerCase()] ?? "application/octet-stream";
+}
+/**
+* RFC 5987 §3.2.1 `ext-value` percent-encoding for the `filename*` parameter.
+*
+* `encodeURIComponent` leaves `!'()*-._~` unescaped, but `'`, `(`, `)` and `*`
+* are NOT in RFC 5987's `attr-char` set, so they have to be escaped by hand.
+*/
+function encodeExtValue(value) {
+	return encodeURIComponent(value).replace(/['()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+/**
+* `Content-Disposition` for the content route (RFC 6266 §4.1).
+*
+* Always `attachment`. {@link CONTENT_TYPE_BY_EXT} is an allowlist of INERT
+* types precisely so a stored upload cannot execute against the mock's own
+* origin, but `application/pdf` was still being served with no disposition at
+* all, which in every mainstream browser means "render in the built-in PDF
+* viewer" — an active surface on this origin, exactly what the allowlist's
+* comment claims is excluded. `attachment` closes that without touching the
+* allowlist, and it also stops a `.json`/`.txt`/`.csv` body being rendered
+* inline if someone opens a content URL in a tab.
+*
+* What the REAL API sends here is UNVERIFIED: probing
+* `api.openai.com/v1/files/{id}/content` needs a key, and neither
+* `openai/openai-openapi` nor the SDK documents the response headers. So this
+* is chosen for safety, not fidelity — and it is inert for SDK callers: the
+* vendored SDK's `files.content()` (openai@4.104.0,
+* `resources/files.js:82-88`) issues the GET with `Accept: application/binary`
+* and `__binaryResponse: true`, handing back the raw `Response` without ever
+* reading `Content-Disposition`.
+*
+* Both parameters are built from the STORED filename, which is attacker-shaped
+* input: a multipart `filename="..."` can carry CR/LF and would otherwise
+* inject response headers. The ASCII fallback replaces every non-printable and
+* non-ASCII byte with `_` and backslash-escapes `"` and `\` per the
+* quoted-string rule; `filename*` percent-encodes them. Neither can emit a bare
+* CR or LF.
+*/
+function contentDispositionFor(filename) {
+	const base = `attachment; filename="${filename.replace(/[^\x20-\x7e]/g, "_").replace(/(["\\])/g, "\\$1")}"`;
+	if (/^[\x20-\x7e]*$/.test(filename)) return base;
+	return `${base}; filename*=UTF-8''${encodeExtValue(filename)}`;
+}
+/**
+* Per-file content cap. An upload whose decoded content is above this gets a
+* `400` with the usual OpenAI-style error envelope, at every wire size a body
+* can have — see {@link FILES_BODY_MAX_BYTES} for how that is kept true
+* without buffering an unbounded body.
+*/
+const FILES_MAX_BYTES = 10 * 1024 * 1024;
+/**
+* Worst-case wire-to-content expansion of a JSON upload.
+*
+* `content` is a JSON string, so one byte of decoded payload can arrive as as
+* many as six wire bytes: a `\uXXXX` escape is 6 bytes and the cheapest code
+* point one can carry (U+0000–U+007F) is a single UTF-8 byte. Every other
+* code point does better — U+0800–U+FFFF is 3 UTF-8 bytes per 6 wire bytes,
+* a surrogate pair 4 per 12 — and a multipart part is 1:1 plus its envelope.
+* So six is an upper bound on wire → content expansion for both parsers.
+*/
+const FILES_MAX_WIRE_EXPANSION = 6;
+/** Slack for the JSON envelope, or for multipart boundaries and part headers. */
+const FILES_ENVELOPE_HEADROOM_BYTES = 64 * 1024;
+/**
+* How much of a Files upload body the route will BUFFER — derived, not picked.
+*
+* `readBodyBuffer` enforces a limit by destroying the socket: no status line,
+* no body, no CORS headers, just an `ECONNRESET`. That made the `400 File
+* content exceeds ... byte cap` branches below unreachable when the two caps
+* were equal (both the 10 MB `DEFAULT_MAX_BODY_BYTES`), and a fixed slice of
+* headroom above the cap only moved the cliff: a `\u0001`-heavy JSON body or a
+* multipart body far enough over the cap still died on the socket.
+*
+* So the bound is computed from the widest a within-cap payload can be on the
+* wire ({@link FILES_MAX_WIRE_EXPANSION} × the cap, plus envelope headroom).
+* Two consequences, and they are the contract:
+*
+* - No body that could decode to a payload within the cap is ever refused for
+*   its size — it fits here by construction, and is answered on content.
+* - A body larger than this is not buffered. The route stops retaining bytes
+*   (peak memory stays at this bound), drains the rest, and answers a real
+*   `400` with CORS. It is not a socket drop, and it cannot be a false
+*   rejection either, by the point above.
+*
+* The global `readBodyBuffer` default is deliberately left alone — every other
+* route depends on it.
+*/
+const FILES_BODY_MAX_BYTES = FILES_MAX_BYTES * FILES_MAX_WIRE_EXPANSION + FILES_ENVELOPE_HEADROOM_BYTES;
+/**
+* The one documented socket drop on this route: a DoS backstop.
+*
+* Draining an over-size body is what buys the caller a real `400`, but the
+* draining itself is work an attacker can ask for without limit. Past this
+* the request is simply not worth finishing and the socket is destroyed, the
+* same way every other route treats its own limit. It is deliberately far
+* above {@link FILES_BODY_MAX_BYTES}: a client that lands here is not sending
+* a file that was ever going to be accepted.
+*/
+const FILES_BODY_DRAIN_MAX_BYTES = FILES_BODY_MAX_BYTES * 2;
+/**
+* Stands in for an upload body that went past {@link FILES_BODY_MAX_BYTES} and
+* was therefore drained instead of buffered. The route hands this to
+* {@link handleFilesCreate} in place of the bytes, so the over-size answer is
+* the same `400` envelope — journalled, CORS-headed, chaos-gated — as every
+* other rejection here, rather than a second error path in the server.
+*/
+const FILES_BODY_OVERSIZED = Symbol("files-body-oversized");
+/** The `400` for a body too large to be a within-cap upload. */
+function oversizedBody() {
+	return `Request body exceeds the ${FILES_BODY_MAX_BYTES} byte upload limit for this route (the ${FILES_MAX_BYTES} byte content cap plus worst-case wire encoding overhead)`;
+}
+const fileStore = /* @__PURE__ */ new Map();
+const fileContents = /* @__PURE__ */ new Map();
+function clearFileStore() {
+	fileStore.clear();
+	fileContents.clear();
+}
+/**
+* The stored bytes for one file, as the very `Buffer` this module holds — so a
+* test can assert on what it RETAINS (`buffer.byteLength`), not just on what it
+* serves back. `GET /v1/files/{id}/content` copies onto the wire, so it cannot
+* tell an owned buffer from a `subarray` pinning a 60 MB request body.
+*/
+function getStoredFileBytes(id) {
+	return fileContents.get(id)?.bytes;
+}
+/**
+* Register one file in the store and return its wire object. This is the one
+* insert path: `POST /v1/files` uses it, and so do server-side producers of
+* files (the Batches mock minting `output_file_id` / `error_file_id`), so a
+* file minted internally is retrievable through `GET /v1/files/{id}` and
+* `/content` exactly like an upload. `content` must be an OWNED buffer (see
+* {@link ParsedUpload.content}) — it is stored as-is, and it must already be
+* within {@link FILES_MAX_BYTES}: the cap the upload route enforces holds for
+* every file in the store, so a producer that cannot fit under it fails its
+* own operation instead of storing the file.
+*/
+function storeFile(file) {
+	if (file.content.length > FILES_MAX_BYTES) throw new RangeError(`File content exceeds ${FILES_MAX_BYTES} byte cap`);
+	const id = generateId("file");
+	const obj = {
+		id,
+		object: "file",
+		bytes: file.content.length,
+		created_at: Math.floor(Date.now() / 1e3),
+		filename: file.filename,
+		purpose: file.purpose,
+		status: "processed"
+	};
+	fileStore.set(id, obj);
+	fileContents.set(id, { bytes: file.content });
+	return obj;
+}
+/**
+* Synthetic journal body for an upload — the SAME convention
+* {@link handleTranscription} uses for `multipart/form-data` audio: the entry
+* carries a small object describing the upload that was parsed out of the
+* body, never the body itself. Raw file octets are NEVER journalled, in any
+* encoding: they can be megabytes of binary, they would blow the journal's
+* 64 KB body cap on anything real, and a base64 round-trip of them is not
+* something a test wants to diff. `sha256` is the byte identity a caller
+* asserts on instead.
+*
+* `content_type` is derived from the stored filename via
+* {@link contentTypeForFilename} — the same decision `GET /v1/files/{id}/content`
+* serves the bytes back with — rather than from the client-declared part
+* header, which this mock deliberately ignores everywhere else.
+*
+* `model`/`messages` are the inert `ChatCompletionRequest` floor the journal's
+* body type requires (the same `{ model: "", messages: [] }` the server uses
+* for its own bodyless synthetic entries); `_endpointType` names the surface.
+*/
+function filesUploadBody(upload) {
+	return {
+		model: "",
+		messages: [],
+		_endpointType: "files",
+		purpose: upload.purpose,
+		filename: upload.filename,
+		bytes: upload.content.length,
+		content_type: contentTypeForFilename(upload.filename),
+		sha256: createHash("sha256").update(upload.content).digest("hex")
+	};
+}
+/**
+* Journal one files-route request.
+*
+* The rule for `body`: an entry carries the {@link filesUploadBody} descriptor
+* exactly when a request had an upload payload that parsed — i.e. a successful
+* `POST /v1/files` — and the {@link invalidRequest} envelope exactly when the
+* request was rejected with a `400` (see {@link rejectFiles}), so the reason
+* is readable from the journal without the wire response. Every other files
+* entry (GET one, GET content, list, DELETE, a chaos-faulted request, a 404)
+* has no payload to describe and stays `null`, matching the bodyless routes in
+* {@link handleTranscription}. Raw uploaded bytes never appear.
+*
+* `service: "files"` is set on every branch so
+* `GET /__aimock/journal?service=files` selects exactly this traffic, and
+* `source: "internal"` because this store is aimock's own — the same tag every
+* fine-tuning entry carries, success and error alike.
+*
+* Call it AFTER the response has been written: a `writeHead` that throws must
+* not leave behind an entry for a response the client never received.
+*/
+function journalFiles(journal, method, path, headers, status, body = null) {
+	journal.add({
+		method,
+		path,
+		headers,
+		body,
+		service: "files",
+		response: {
+			status,
+			fixture: null,
+			source: "internal"
+		}
+	});
+}
+/** Keep the entire warning bounded and on one physical line, including the URL. */
+function filesRejectionWarning(message) {
+	const maxLength = 1024;
+	let safe = "";
+	for (const character of message) {
+		const code = character.charCodeAt(0);
+		const escaped = code < 32 || code >= 127 && code <= 159 || code === 8232 || code === 8233 ? `\\u${code.toString(16).padStart(4, "0")}` : character;
+		if (safe.length + escaped.length > maxLength - 3) return `${safe}...`;
+		safe += escaped;
+	}
+	return safe;
+}
+/**
+* Answer a files-route `400`: log it at `warn` (the level the server uses for
+* a request it refused), journal the {@link invalidRequest} envelope as the
+* entry's body so the reason survives in the journal, and write that same
+* envelope to the wire. One helper so the three can never disagree.
+*/
+function rejectFiles(res, journal, logger, method, path, headers, message, setCorsHeaders) {
+	const envelope = invalidRequest(message);
+	logger.warn(filesRejectionWarning(`Files mock: rejected ${method} ${path} with 400: ${message}`));
+	writeJson(res, 400, envelope, setCorsHeaders);
+	journalFiles(journal, method, path, headers, 400, envelope);
+}
+function writeJson(res, status, payload, setCorsHeaders) {
+	setCorsHeaders(res);
+	res.writeHead(status, { "Content-Type": "application/json" });
+	res.end(JSON.stringify(payload));
+}
+function invalidRequest(message) {
+	return { error: {
+		message,
+		type: "invalid_request_error"
+	} };
+}
+/**
+* Name a rejected value's JSON type for the 400 message. The point is that the
+* caller sees *what* they sent instead of silently getting `String(value)`
+* stored as the file's content.
+*
+* The listed cases are exhaustive for the one caller. `JSON.parse` only ever
+* yields null, boolean, number, string, array or plain object — never
+* `undefined`, `function`, `symbol` or `bigint` — and the caller has already
+* excluded `string` (it is the accepted type) and `undefined` (that is the
+* separate "required" 400). So everything reaching the last line is an object.
+*/
+function jsonTypeOf(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "an array";
+	if (typeof value === "number") return "a number";
+	if (typeof value === "boolean") return "a boolean";
+	return "an object";
+}
+/**
+* A high surrogate not followed by a low one, or a low surrogate not preceded
+* by a high one — i.e. a JS string that is not well-formed UTF-16 and therefore
+* has no UTF-8 encoding.
+*
+* `Buffer.from(s, "utf8")` does not fail on these: it substitutes U+FFFD (EF BF
+* BD), silently and permanently. That breaks the one guarantee an upload mock
+* owes its caller — `GET /v1/files/{id}/content` returns what was uploaded — and
+* it breaks it invisibly, three bytes at a time, in a test whose hash
+* comparison then fails for no visible reason. The byte-for-byte promise this
+* module documents is made for the multipart path (which is scanned as latin1
+* and never decoded); the JSON path carries *text*, so text that cannot be
+* encoded is a 400, not a lossy store.
+*/
+const LONE_SURROGATE_RE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+/**
+* Longest `filename` this mock will store, in UTF-8 bytes.
+*
+* NOT the real API's limit: `openai/openai-openapi` gives `OpenAIFile.filename`
+* as a bare `type: string` with no `maxLength`, and `CreateFileRequest` has no
+* `filename` property at all. So the bound comes from the one thing here a
+* filename can break: `GET /v1/files/{id}/content` echoes the stored name into
+* `Content-Disposition` twice — quoted ASCII (where `"` and `\` double) and
+* percent-encoded per RFC 5987 (where a byte can triple) — so ~5 bytes of
+* header per byte of name. 1024 bytes of name is ~5 KiB of header, well inside
+* Node's 16 KiB default `--max-http-header-size`.
+*
+* Unbounded, a 20 KB filename uploaded `200` and then made the content route
+* unreadable by undici: `UND_ERR_HEADERS_OVERFLOW`, no status, no envelope, no
+* CORS — the OpenAI SDK could not fetch a file it had just uploaded.
+*/
+const FILES_MAX_FILENAME_BYTES = 1024;
+/**
+* The filename rules, in one place because both parsers must answer the same.
+*
+* They used to disagree: a name carrying NUL, CR or LF was a `400` as a
+* multipart parameter and a `200` as a JSON field, stored and echoed back
+* verbatim. Returns an error message, or `undefined` if the name is fine.
+*/
+function filenameError(filename) {
+	if (CONTROL_CHARS.test(filename)) return "Invalid parameter: 'filename' must not contain control characters";
+	if (LONE_SURROGATE_RE.test(filename)) return "Invalid parameter: 'filename' must not contain an unpaired UTF-16 surrogate";
+	const byteLength = Buffer.byteLength(filename, "utf8");
+	if (byteLength > FILES_MAX_FILENAME_BYTES) return `Invalid parameter: 'filename' is ${byteLength} UTF-8 bytes, above the ${FILES_MAX_FILENAME_BYTES} byte cap (a longer name makes GET /v1/files/{id}/content unfetchable: its Content-Disposition header would exceed the HTTP header limit)`;
+}
+/** The deterministic name given to an upload that arrived without one. */
+function synthesizedFilename(content) {
+	return `upload-${createHash("sha256").update(content).digest("hex").slice(0, 24)}.bin`;
+}
+function parseJsonUpload(raw) {
+	let text;
+	try {
+		text = new TextDecoder("utf-8", { fatal: true }).decode(raw);
+	} catch {
+		return { error: "Invalid request: body is not valid UTF-8" };
+	}
+	let body;
+	try {
+		body = JSON.parse(text);
+	} catch (err) {
+		return { error: `Malformed JSON: ${err instanceof Error ? err.message : "unknown"}` };
+	}
+	if (!isJsonObject(body)) return { error: "Request body must be a JSON object" };
+	const rawFilename = body["filename"];
+	const purpose = body["purpose"];
+	if (typeof rawFilename !== "string") return { error: "Invalid parameter: 'filename' must be a string" };
+	const filenameProblem = filenameError(rawFilename);
+	if (filenameProblem !== void 0) return { error: filenameProblem };
+	const filename = rawFilename.trim() === "" ? void 0 : rawFilename;
+	if (typeof purpose !== "string" || purpose.length === 0) return { error: "Invalid parameter: 'purpose' must be a non-empty string" };
+	if (!CREATE_PURPOSES.has(purpose)) return { error: invalidPurpose(purpose) };
+	const hasContent = body["content"] !== void 0;
+	const hasBytesAlias = body["bytes"] !== void 0;
+	if (hasContent && hasBytesAlias) return { error: "Invalid parameter: 'content' and its alias 'bytes' are mutually exclusive; send exactly one" };
+	const field = hasContent ? "content" : "bytes";
+	const content = hasContent ? body["content"] : body["bytes"];
+	if (content === void 0) return { error: "Invalid parameter: 'content' is required (or its alias 'bytes')" };
+	if (typeof content !== "string") return { error: `Invalid parameter: '${field}' must be a string, got ${jsonTypeOf(content)}` };
+	if (LONE_SURROGATE_RE.test(content)) return { error: `Invalid parameter: '${field}' contains an unpaired UTF-16 surrogate and is not valid text. aimock would have to store it as U+FFFD, so the bytes served back by GET /v1/files/{id}/content would not be the bytes you sent. Send binary as a multipart/form-data upload, which is stored verbatim.` };
+	const bytes = Buffer.from(content, "utf8");
+	if (bytes.length > FILES_MAX_BYTES) return { error: `File content exceeds ${FILES_MAX_BYTES} byte cap` };
+	return {
+		filename: filename ?? synthesizedFilename(bytes),
+		purpose,
+		content: bytes
+	};
+}
+const HEADER_TERMINATOR = Buffer.from("\r\n\r\n");
+/** RFC 9110 `token` characters — the legal set for a header field name. */
+const TOKEN_CHAR = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+/** C0 controls plus DEL — never legitimate in a filename we echo back. */
+const CONTROL_CHARS = /[-]/;
+/**
+* Is this request body `multipart/form-data`?
+*
+* Compares the media type's *essence* (RFC 9110 §8.3.1: everything before the
+* first `;`), not a substring of the whole header. A substring test routed
+* `application/json; note="multipart/form-data"` — and anything else that
+* merely mentions the token in a parameter — into the multipart parser, which
+* then 400'd about a missing `boundary` directive on a perfectly good JSON
+* body.
+*/
+function isMultipartFormData(contentType) {
+	if (contentType === void 0) return false;
+	const semi = contentType.indexOf(";");
+	return (semi === -1 ? contentType : contentType.slice(0, semi)).trim().toLowerCase() === "multipart/form-data";
+}
+/**
+* Locate the next *boundary delimiter line* at or after `from`.
+*
+* RFC 2046 §5.1.1 defines the delimiter as `CRLF "--" boundary` followed by
+* either transport-padding + CRLF (another part follows) or `--` (the close
+* delimiter). Both halves matter:
+*
+* - The **leading CRLF is part of the delimiter**, not of the preceding body.
+*   The previous implementation split on a bare `--boundary`, so a payload
+*   whose bytes happened to contain that sequence was truncated at it and
+*   stored short — with a 200, silently, which is the worst possible answer
+*   from a module whose contract is byte-for-byte storage.
+* - An occurrence **not followed by** CRLF or `--` is not a delimiter line at
+*   all, so it is ordinary body content and the scan continues past it. That
+*   is what keeps a payload containing `CRLF--boundary` plus arbitrary bytes
+*   byte-exact. (undici's `Response.formData()` rejects such a body outright;
+*   see the note on {@link parseMultipartUpload}.)
+*/
+function nextDelimiter(buf, delimiter, from) {
+	let at = buf.indexOf(delimiter, from);
+	while (at !== -1) {
+		const tail = delimiterTail(buf, at + delimiter.length);
+		if (tail) return {
+			at,
+			...tail
+		};
+		at = buf.indexOf(delimiter, at + 1);
+	}
+}
+/**
+* Classify what follows a `CRLF "--" boundary` match: transport-padding + CRLF
+* (another part follows), `--` (the close delimiter), or neither — in which
+* case the match is not a delimiter line at all and the caller keeps scanning.
+* Split out of {@link nextDelimiter} so {@link parseMultipartUpload} can apply
+* the same rule to an opening delimiter whose leading CRLF is not present.
+*/
+function delimiterTail(buf, after) {
+	if (buf[after] === 45 && buf[after + 1] === 45) return {
+		next: after + 2,
+		closing: true
+	};
+	let j = after;
+	while (buf[j] === 32 || buf[j] === 9) j += 1;
+	if (buf[j] === 13 && buf[j + 1] === 10) return {
+		next: j + 2,
+		closing: false
+	};
+}
+function parseHeaderParams(value) {
+	const params = /* @__PURE__ */ new Map();
+	const semi = value.indexOf(";");
+	const head = (semi === -1 ? value : value.slice(0, semi)).trim();
+	let i = semi === -1 ? value.length : semi;
+	while (i < value.length) {
+		i += 1;
+		while (value[i] === " " || value[i] === "	") i += 1;
+		if (i >= value.length) break;
+		const eq = value.indexOf("=", i);
+		if (eq === -1) return MALFORMED_HEADER;
+		const attr = value.slice(i, eq).trim().toLowerCase();
+		if (!TOKEN_CHAR.test(attr)) return MALFORMED_HEADER;
+		if (params.has(attr)) return {
+			error: "duplicate",
+			param: attr
+		};
+		i = eq + 1;
+		if (value[i] === "\"") {
+			i += 1;
+			let out = "";
+			for (;;) {
+				if (i >= value.length) return MALFORMED_HEADER;
+				const ch = value[i];
+				if (ch === "\\" && i + 1 < value.length) {
+					out += value[i + 1];
+					i += 2;
+					continue;
+				}
+				if (ch === "\"") {
+					i += 1;
+					break;
+				}
+				out += ch;
+				i += 1;
+			}
+			params.set(attr, out);
+			while (value[i] === " " || value[i] === "	") i += 1;
+			if (i < value.length && value[i] !== ";") return MALFORMED_HEADER;
+		} else {
+			const end = value.indexOf(";", i);
+			params.set(attr, (end === -1 ? value.slice(i) : value.slice(i, end)).trim());
+			i = end === -1 ? value.length : end;
+		}
+	}
+	return {
+		value: head,
+		params
+	};
+}
+const MALFORMED_HEADER = { error: "malformed" };
+/** Render a {@link parseHeaderParams} failure as a 400 message naming the header. */
+function headerParamError(err, header, where) {
+	return err.error === "duplicate" ? `Invalid request: duplicate '${err.param}' parameter on the ${header} header in ${where}` : `Invalid request: malformed ${header} header in ${where}`;
+}
+/**
+* Decode an RFC 5987 `ext-value` (`charset'language'pct-encoded`), the form a
+* `filename*` parameter takes. RFC 6266 §4.3 says a recipient that understands
+* it SHOULD prefer it over the plain `filename`, so {@link parsePart} does.
+* A client that sends only `filename*=` therefore keeps the name it sent
+* instead of receiving a synthesized one.
+*/
+function decodeExtValue(raw) {
+	const first = raw.indexOf("'");
+	const second = raw.indexOf("'", first + 1);
+	if (first === -1 || second === -1) return void 0;
+	const charset = raw.slice(0, first).toLowerCase();
+	if (charset !== "utf-8" && charset !== "iso-8859-1") return void 0;
+	const octets = [];
+	const pct = raw.slice(second + 1);
+	for (let i = 0; i < pct.length; i += 1) if (pct[i] === "%") {
+		const hex = pct.slice(i + 1, i + 3);
+		if (!/^[0-9A-Fa-f]{2}$/.test(hex)) return void 0;
+		octets.push(parseInt(hex, 16));
+		i += 2;
+	} else {
+		const code = pct.charCodeAt(i);
+		if (code > 127) return void 0;
+		octets.push(code);
+	}
+	const bytes = Buffer.from(octets);
+	if (charset === "iso-8859-1") return bytes.toString("latin1");
+	try {
+		return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+	} catch {
+		return;
+	}
+}
+/** Turn one part's raw octets into headers + body, or name why it is malformed. */
+function parsePart(partBytes, index) {
+	const where = `multipart part #${index + 1}`;
+	let headerText;
+	let bodyStart;
+	if (partBytes[0] === 13 && partBytes[1] === 10) {
+		headerText = "";
+		bodyStart = 2;
+	} else {
+		const end = partBytes.indexOf(HEADER_TERMINATOR);
+		if (end === -1) return { error: `Invalid request: malformed ${where} — its headers are not terminated by a blank line` };
+		headerText = partBytes.subarray(0, end).toString("utf8");
+		bodyStart = end + 4;
+	}
+	const headers = /* @__PURE__ */ new Map();
+	if (headerText !== "") for (const line of headerText.split("\r\n")) {
+		const colon = line.indexOf(":");
+		const fieldName = colon === -1 ? "" : line.slice(0, colon);
+		if (!TOKEN_CHAR.test(fieldName)) return { error: `Invalid request: malformed header line in ${where}` };
+		const field = fieldName.toLowerCase();
+		if (headers.has(field)) return { error: `Invalid request: duplicate '${fieldName.trim()}' header in ${where}` };
+		headers.set(field, line.slice(colon + 1).trim());
+	}
+	const disposition = headers.get("content-disposition");
+	if (disposition === void 0) return { error: `Invalid request: ${where} has no Content-Disposition header` };
+	const parsed = parseHeaderParams(disposition);
+	if ("error" in parsed) return { error: headerParamError(parsed, "Content-Disposition", where) };
+	if (parsed.value.toLowerCase() !== "form-data") return { error: `Invalid request: ${where} has Content-Disposition type '${parsed.value}'; RFC 7578 section 4.2 requires 'form-data'` };
+	const name = parsed.params.get("name");
+	if (name === void 0) return { error: `Invalid request: ${where} has no 'name' parameter on its Content-Disposition header` };
+	const star = parsed.params.get("filename*");
+	const filename = star !== void 0 ? decodeExtValue(star) : parsed.params.get("filename");
+	if (star !== void 0 && filename === void 0) return { error: `Invalid request: malformed 'filename*' parameter in ${where}` };
+	return {
+		name,
+		filename,
+		headers,
+		body: partBytes.subarray(bodyStart)
+	};
+}
+/**
+* Read a part's content encoding header. An empty value reads as absent: the
+* old regex used `\s*` after the colon, which matches a CRLF, so an empty
+* `Content-Transfer-Encoding:` captured the *next* header line and 400'd
+* naming `content-type: image/png` as the unsupported encoding.
+*/
+function partEncoding(part, header) {
+	const value = part.headers.get(header)?.trim().toLowerCase();
+	return value === void 0 || value === "" ? void 0 : value;
+}
+/**
+* Parse a `multipart/form-data` upload body.
+*
+* ## Why this is not `Response.formData()`
+*
+* Node's built-in (undici) `Response.formData()` is a spec-compliant multipart
+* parser and was evaluated first, per the "use the platform, do not hand-roll
+* a codec" rule. It fails three of this module's requirements:
+*
+* 1. **Byte fidelity.** It throws `expected CRLF` on any body whose payload
+*    contains the boundary token, including the RFC-legal bare `--boundary`
+*    with no preceding CRLF. Those bytes are storable and this module promises
+*    to store them.
+* 2. **Filename-less payload parts.** A part with no `filename` parameter comes
+*    back as a *string*, decoded as UTF-8, so binary octets are destroyed
+*    (`00 ff fe ...` becomes `00 efbfbd efbfbd ...`). Such a part is legal
+*    input here and already round-tripped byte-exact.
+* 3. **Part headers.** `File` exposes only `name`, `type` and `size`. There is
+*    no way to see a part's `Content-Transfer-Encoding`, so the "reject an
+*    encoding we do not apply" contract above could not be implemented at all
+*    and a `base64` part would be stored in its encoded form — the exact bug
+*    that contract exists to prevent.
+*
+* So the framing stays local, but it is written to RFC 2046 §5.1.1 and
+* RFC 7578 rather than to a `split()`: see {@link nextDelimiter} for the
+* delimiter rule and {@link parsePart} for the header rule.
+*
+* Bytes never round-trip through a string. Part bodies are `subarray`s of the
+* request buffer, so what is parsed is literally what arrived on the wire — but
+* the payload part is COPIED out of that view before it is returned, because a
+* `subarray` retains its whole backing buffer (see the copy below). The scan
+* itself never copies the body either, so peak residency during a parse is one
+* request body, not two.
+*/
+function parseMultipartUpload(rawBytes, contentType) {
+	const parsedType = parseHeaderParams(contentType ?? "");
+	if ("error" in parsedType) return { error: headerParamError(parsedType, "Content-Type", "the request") };
+	const boundary = parsedType.params.get("boundary");
+	if (!boundary) return { error: "Invalid request: multipart/form-data Content-Type is missing a 'boundary' directive" };
+	const buf = rawBytes;
+	const delimiter = Buffer.from(`\r\n--${boundary}`, "latin1");
+	const dashBoundary = Buffer.from(`--${boundary}`, "latin1");
+	const opening = buf.subarray(0, dashBoundary.length).equals(dashBoundary) ? delimiterTail(buf, dashBoundary.length) : void 0;
+	let delim = opening ? {
+		at: 0,
+		...opening
+	} : nextDelimiter(buf, delimiter, 0);
+	if (!delim) return { error: "Invalid request: multipart body contains no boundary delimiter" };
+	const parts = [];
+	while (!delim.closing) {
+		const start = delim.next;
+		const following = nextDelimiter(buf, delimiter, start);
+		if (!following) return { error: "Invalid request: multipart body ended before its closing boundary delimiter" };
+		const part = parsePart(buf.subarray(start, following.at), parts.length);
+		if ("error" in part) return part;
+		parts.push(part);
+		delim = following;
+	}
+	for (const part of parts) {
+		const transfer = partEncoding(part, "content-transfer-encoding");
+		if (transfer !== void 0 && !IDENTITY_TRANSFER_ENCODINGS.has(transfer)) return { error: unsupportedPartEncoding("Content-Transfer-Encoding", transfer, part.name) };
+		const encoding = partEncoding(part, "content-encoding");
+		if (encoding !== void 0 && encoding !== "identity") return { error: unsupportedPartEncoding("Content-Encoding", encoding, part.name) };
+	}
+	const purposeParts = parts.filter((p) => p.name === "purpose");
+	if (purposeParts.length > 1) return { error: "Invalid request: multipart body has more than one 'purpose' part; send exactly one" };
+	const payloadParts = parts.filter((p) => p.name === "file" || p.name === "content");
+	if (payloadParts.length > 1) {
+		const [first, second] = payloadParts;
+		return { error: `Invalid request: multipart body has more than one payload part ('${first.name}' and '${second.name}'); send exactly one 'file' or 'content' part` };
+	}
+	const purpose = purposeParts[0]?.body.toString("utf8");
+	if (!purpose) return { error: "Invalid parameter: multipart 'purpose' field is required" };
+	if (!CREATE_PURPOSES.has(purpose)) return { error: invalidPurpose(purpose) };
+	const payload = payloadParts[0];
+	if (payload === void 0) return { error: "Invalid request: multipart body must include a 'file' part (or its 'content' alias)" };
+	if (payload.body.length > FILES_MAX_BYTES) return { error: `File content exceeds ${FILES_MAX_BYTES} byte cap` };
+	const content = Buffer.alloc(payload.body.length);
+	payload.body.copy(content);
+	let filename = payload.filename;
+	if (filename !== void 0) {
+		const problem = filenameError(filename);
+		if (problem !== void 0) return { error: problem };
+	}
+	if (filename !== void 0 && filename.trim() === "") filename = void 0;
+	if (filename === void 0) filename = synthesizedFilename(content);
+	return {
+		filename,
+		purpose,
+		content
+	};
+}
+async function handleFilesCreate(req, res, raw, journal, defaults, setCorsHeaders) {
+	const path = req.url ?? "/v1/files";
+	const method = req.method ?? "POST";
+	setCorsHeaders(res);
+	if (await applyChaosAsync(res, null, defaults.chaos, req.headers, req.url, journal, {
+		method,
+		path,
+		headers: flattenHeaders(req.headers),
+		body: null,
+		service: "files"
+	}, "internal", defaults.registry, defaults.logger)) return;
+	if (raw === FILES_BODY_OVERSIZED) {
+		rejectFiles(res, journal, defaults.logger, method, path, flattenHeaders(req.headers), oversizedBody(), setCorsHeaders);
+		return;
+	}
+	const contentType = Array.isArray(req.headers["content-type"]) ? req.headers["content-type"][0] : req.headers["content-type"];
+	const parsed = isMultipartFormData(contentType) ? parseMultipartUpload(raw, contentType) : parseJsonUpload(raw);
+	if ("error" in parsed) {
+		rejectFiles(res, journal, defaults.logger, method, path, flattenHeaders(req.headers), parsed.error, setCorsHeaders);
+		return;
+	}
+	const obj = storeFile(parsed);
+	const { id, bytes } = obj;
+	defaults.logger.debug(`Files mock: stored ${id} (${parsed.filename}, ${bytes} bytes)`);
+	writeJson(res, 200, obj, setCorsHeaders);
+	journalFiles(journal, method, path, flattenHeaders(req.headers), 200, filesUploadBody(parsed));
+}
+/**
+* `GET /v1/files` paging bounds, taken from the `openai/openai-openapi` spec
+* (`operationId: listFiles`): "Limit can range between 1 and 10,000, and the
+* default is 10,000." Files is the odd one out among the list surfaces — most
+* default to 20 — so the default is spelled out here rather than shared.
+*/
+const FILES_LIST_MAX_LIMIT = 1e4;
+const FILES_LIST_DEFAULT_LIMIT = FILES_LIST_MAX_LIMIT;
+/**
+* An unsigned decimal integer literal and nothing else — no sign, no exponent,
+* no radix prefix, no surrounding whitespace. See {@link parseListQuery} for
+* what each of those would otherwise be silently accepted as.
+*
+* A long digit run is still safe to hand to `Number()`: it stays finite and
+* integral, so it fails the range check below rather than the type check.
+*/
+const DECIMAL_INTEGER_RE = /^[0-9]+$/;
+/**
+* The single non-empty value of a list query parameter, or the 400 it earns.
+*
+* ONE rule for all four of `limit`, `order`, `after` and `purpose`, because the
+* three ways of reading them used to disagree on the same URL:
+*
+*   - REPEATED is a 400. `URLSearchParams.get` answers with the FIRST of a
+*     repeated parameter and launders the rest, so `?limit=1&limit=abc` paged
+*     at 1 and never looked at `abc` — a caller that built its URL twice over
+*     got a silent success for a value it never meant. `listFiles` declares
+*     each of the four as a single scalar and gives no combining rule for a
+*     repeat, so a repeat is a caller error. Matches the multipart body, where
+*     two `purpose` parts are already a 400 rather than a last-one-wins.
+*   - PRESENT-BUT-EMPTY is a 400. `?order=` was already one (no member of the
+*     enum is ""), but `?after=` meant "no cursor" and `?purpose=` meant "no
+*     filter" and handed back the WHOLE store — the exact opposite of the
+*     narrowing the caller asked for. An empty string is not an object id and
+*     not a purpose any stored file can carry, and `?x=` is what building a
+*     URL from a partly-undefined params object emits, which is a bug worth
+*     showing. Omitting the parameter is how you say "no filter".
+*   - ABSENT is `null`, and each caller applies its own default.
+*
+* Both 400s are OURS, not the vendor's: the spec states neither. They are the
+* mock's standing bias towards failing loudly over answering a question the
+* caller did not ask.
+*/
+function singleParam(params, name) {
+	const all = params.getAll(name);
+	if (all.length > 1) return {
+		ok: false,
+		error: `Invalid parameter: '${name}' was given ${all.length} times; it takes a single value`
+	};
+	if (all.length === 0) return {
+		ok: true,
+		value: null
+	};
+	if (all[0] === "") return {
+		ok: false,
+		error: `Invalid parameter: '${name}' was given an empty value; omit it instead`
+	};
+	return {
+		ok: true,
+		value: all[0]
+	};
+}
+/**
+* Parse the `limit` / `order` / `after` / `purpose` parameters off a list URL.
+*
+* Shapes come from `operationId: listFiles` in `openai/openai-openapi` and from
+* `FileListParams extends CursorPageParams` in the vendored SDK (openai
+* 4.104.0 — `resources/files.d.ts` gives `order?: 'asc' | 'desc'` and
+* `purpose?: string`; `pagination.d.ts` gives `after?: string` and
+* `limit?: number`). `order` defaults to `desc`, so the newest file comes back
+* first.
+*
+* All four are read here, through {@link singleParam}, so there is exactly one
+* place that decides what a repeated or empty list parameter means. `purpose`
+* used to be read separately in `src/server.ts` and passed in already parsed,
+* which is how it ended up with neither rule.
+*/
+function parseListQuery(rawUrl) {
+	const queryStart = rawUrl.indexOf("?");
+	const params = new URLSearchParams(queryStart === -1 ? "" : rawUrl.slice(queryStart + 1));
+	const rawOrder = singleParam(params, "order");
+	if (!rawOrder.ok) return { error: rawOrder.error };
+	const orderRaw = rawOrder.value;
+	if (orderRaw !== null && orderRaw !== "asc" && orderRaw !== "desc") return { error: "Invalid parameter: 'order' must be one of: asc, desc" };
+	const rawLimit = singleParam(params, "limit");
+	if (!rawLimit.ok) return { error: rawLimit.error };
+	let limit = FILES_LIST_DEFAULT_LIMIT;
+	if (rawLimit.value !== null) {
+		const parsed = DECIMAL_INTEGER_RE.test(rawLimit.value) ? Number(rawLimit.value) : NaN;
+		if (!Number.isInteger(parsed) || parsed < 1 || parsed > FILES_LIST_MAX_LIMIT) return { error: `Invalid parameter: 'limit' must be an integer between 1 and ${FILES_LIST_MAX_LIMIT}` };
+		limit = parsed;
+	}
+	const rawAfter = singleParam(params, "after");
+	if (!rawAfter.ok) return { error: rawAfter.error };
+	const rawPurpose = singleParam(params, "purpose");
+	if (!rawPurpose.ok) return { error: rawPurpose.error };
+	return {
+		limit,
+		order: orderRaw ?? "desc",
+		after: rawAfter.value ?? void 0,
+		purpose: rawPurpose.value ?? void 0
+	};
+}
+async function handleFilesList(req, res, journal, defaults, setCorsHeaders) {
+	const path = req.url ?? "/v1/files";
+	const method = req.method ?? "GET";
+	setCorsHeaders(res);
+	if (await applyChaosAsync(res, null, defaults.chaos, req.headers, req.url, journal, {
+		method,
+		path,
+		headers: flattenHeaders(req.headers),
+		body: null,
+		service: "files"
+	}, "internal", defaults.registry, defaults.logger)) return;
+	const query = parseListQuery(path);
+	if ("error" in query) {
+		rejectFiles(res, journal, defaults.logger, method, path, flattenHeaders(req.headers), query.error, setCorsHeaders);
+		return;
+	}
+	let data = [...fileStore.values()];
+	if (query.purpose !== void 0) data = data.filter((f) => f.purpose === query.purpose);
+	data.sort((a, b) => a.created_at - b.created_at);
+	if (query.order === "desc") data.reverse();
+	let start = 0;
+	if (query.after !== void 0) {
+		const idx = data.findIndex((f) => f.id === query.after);
+		if (idx === -1) {
+			rejectFiles(res, journal, defaults.logger, method, path, flattenHeaders(req.headers), `Invalid parameter: 'after' cursor '${query.after}' does not match any file in this listing`, setCorsHeaders);
+			return;
+		}
+		start = idx + 1;
+	}
+	const page = data.slice(start, start + query.limit);
+	writeJson(res, 200, {
+		object: "list",
+		data: page,
+		first_id: page[0]?.id ?? null,
+		last_id: page[page.length - 1]?.id ?? null,
+		has_more: start + page.length < data.length
+	}, setCorsHeaders);
+	journalFiles(journal, method, path, flattenHeaders(req.headers), 200);
+}
+async function handleFilesRetrieve(req, res, fileId, journal, defaults, setCorsHeaders) {
+	const path = req.url ?? `/v1/files/${fileId}`;
+	const method = req.method ?? "GET";
+	setCorsHeaders(res);
+	if (await applyChaosAsync(res, null, defaults.chaos, req.headers, req.url, journal, {
+		method,
+		path,
+		headers: flattenHeaders(req.headers),
+		body: null,
+		service: "files"
+	}, "internal", defaults.registry, defaults.logger)) return;
+	const found = fileStore.get(fileId);
+	if (!found) {
+		writeJson(res, 404, invalidRequest(`No such file: ${fileId}`), setCorsHeaders);
+		journalFiles(journal, method, path, flattenHeaders(req.headers), 404);
+		return;
+	}
+	writeJson(res, 200, found, setCorsHeaders);
+	journalFiles(journal, method, path, flattenHeaders(req.headers), 200);
+}
+async function handleFilesContent(req, res, fileId, journal, defaults, setCorsHeaders) {
+	const path = req.url ?? `/v1/files/${fileId}/content`;
+	const method = req.method ?? "GET";
+	setCorsHeaders(res);
+	if (await applyChaosAsync(res, null, defaults.chaos, req.headers, req.url, journal, {
+		method,
+		path,
+		headers: flattenHeaders(req.headers),
+		body: null,
+		service: "files"
+	}, "internal", defaults.registry, defaults.logger)) return;
+	const found = fileStore.get(fileId);
+	const content = fileContents.get(fileId);
+	if (!found || content === void 0) {
+		writeJson(res, 404, invalidRequest(`No such file: ${fileId}`), setCorsHeaders);
+		journalFiles(journal, method, path, flattenHeaders(req.headers), 404);
+		return;
+	}
+	res.writeHead(200, {
+		"Content-Type": contentTypeForFilename(found.filename),
+		"Content-Length": String(content.bytes.length),
+		"X-Content-Type-Options": "nosniff",
+		"Content-Disposition": contentDispositionFor(found.filename)
+	});
+	res.end(content.bytes);
+	journalFiles(journal, method, path, flattenHeaders(req.headers), 200);
+}
+async function handleFilesDelete(req, res, fileId, journal, defaults, setCorsHeaders) {
+	const path = req.url ?? `/v1/files/${fileId}`;
+	const method = req.method ?? "DELETE";
+	setCorsHeaders(res);
+	if (await applyChaosAsync(res, null, defaults.chaos, req.headers, req.url, journal, {
+		method,
+		path,
+		headers: flattenHeaders(req.headers),
+		body: null,
+		service: "files"
+	}, "internal", defaults.registry, defaults.logger)) return;
+	if (!fileStore.get(fileId)) {
+		writeJson(res, 404, invalidRequest(`No such file: ${fileId}`), setCorsHeaders);
+		journalFiles(journal, method, path, flattenHeaders(req.headers), 404);
+		return;
+	}
+	fileStore.delete(fileId);
+	fileContents.delete(fileId);
+	writeJson(res, 200, {
+		id: fileId,
+		object: "file",
+		deleted: true
+	}, setCorsHeaders);
+	journalFiles(journal, method, path, flattenHeaders(req.headers), 200);
+}
+
+//#endregion
+export { FILES_BODY_DRAIN_MAX_BYTES, FILES_BODY_MAX_BYTES, FILES_BODY_OVERSIZED, FILES_MAX_BYTES, clearFileStore, getStoredFileBytes, handleFilesContent, handleFilesCreate, handleFilesDelete, handleFilesList, handleFilesRetrieve, storeFile };
+//# sourceMappingURL=files.js.map