@copilotkit/aimock 1.40.0 → 1.42.0

package/dist/byteplus-video.js

@@ -0,0 +1,947 @@
+import { flattenHeaders, getContext, getTestId, isErrorResponse, isJSONResponse, resolveResponse, resolveStrictMode, serializeErrorResponse, strictNoMatchLogLine, strictNoMatchMessage, strictOverrideField } from "./helpers.js";
+import { matchFixtureDiagnostic } from "./router.js";
+import { writeErrorResponse } from "./sse-writer.js";
+import { applyChaos } from "./chaos.js";
+import { resolveUpstreamUrl } from "./url.js";
+import { buildFixtureMatch, persistFixture, prepareEgressHeaders, sanitizeHeaderValue } from "./recorder.js";
+import { resolveProgression } from "./fal.js";
+import { readEnvelopeText, upstreamTimeoutSignal } from "./video-proxy-shared.js";
+import crypto from "node:crypto";
+
+//#region src/byteplus-video.ts
+/**
+* BytePlus Ark (ModelArk / Seedance) async video task lifecycle mock. Submit
+* `POST /api/v3/contents/generations/tasks` returns `{ id }`; status
+* `GET /api/v3/contents/generations/tasks/{id}` polls
+* `queued → running → <recorded terminal status>`.
+*
+* THE FIXTURE FORMAT IS THE ARK TASK ENVELOPE ITSELF, stored as a
+* `RawJSONResponse` (`{ response: { json: … } }`) — NOT a `VideoResponse`. That
+* is the central decision of this surface and it is what lets `cancelled` and
+* `expired` (terminal states with no representation in `VideoResponse.status`)
+* record and replay natively, lets a recorded `error` object replay without
+* inventing a code, and lets `usage`, `framespersecond`, `draft_task_id` and any
+* field the vendor adds later survive because they were recorded rather than
+* enumerated.
+*
+* PROVENANCE OF EVERY WIRE FACT IN THIS FILE. One source for the TASK shapes —
+* create, poll, the `succeeded`/`failed` envelopes, the status tokens, the
+* unknown-task 404: the client library `@tanstack/ai-byteplus@0.3.4` — its
+* `wire-types.ts`, its request builders, and its author's note of live calls
+* made on 2026-07-31. That is a SECONDARY source. BytePlus's own documentation
+* is a client-rendered SPA and was never read. Exactly one layer is firsthand:
+* the keyless canary in `src/__tests__/drift/byteplus-video.drift.ts` does call
+* live Ark, and observed its AUTH-layer 401 error envelope on 2026-09-10 (see
+* the `OBSERVED_*` constants there). No SUCCESS or resource-layer response from
+* Ark has ever been observed here — the authenticated unknown-task canary is
+* still `skipIf`-gated for want of an `ARK_API_KEY` in repo secrets. So "the
+* client library's six status tokens" is a claim this repo can back, and "the
+* vendor's documented six" is not — comments below say the former. Where a fact is not even secondhand, it is named as unverified
+* rather than softened. A verification nobody performed is worse than an
+* admitted gap: it stops the next person from looking.
+*
+* The governing rule: THE MOCK NEVER AUTHORS A WIRE VALUE IT DID NOT OBSERVE.
+* On replay exactly three things are synthesized — the `id` rewrite, the
+* `queued`/`running` token on a NON-terminal poll, and withholding
+* `content`/`error`/`usage` until terminal. Nothing else. There is no default
+* error code, no default error message, no fabricated `usage`, and no
+* placeholder video url: a terminal fixture missing `content.video_url` gets a
+* named warn, not a substituted URL, because the consumer's error naming the
+* real problem beats a download of a URL aimock made up.
+*
+* `video.url` is served AS-IS — aimock does NOT proxy or capture video bytes.
+* Ark's `content.video_url` expires 24h after `updated_at`; replay warns once
+* when a fixture is served past that instant and still serves it.
+*
+* A fixture for this surface MUST carry `match.endpoint: "video"`. Without it
+* `router.ts`'s endpoint/response compatibility gate skips it (a `{ json }`
+* response is not a `VideoResponse`) before this handler ever sees it.
+*/
+/**
+* Ark's data plane lives under an `/api/v3` prefix ON THE ORIGIN, so
+* `record.providers.byteplus` is configured as an ORIGIN ONLY
+* (`https://ark.ap-southeast.bytepluses.com`) and this handler owns the whole
+* path — the same split `openrouter-video.ts` uses with `OPENROUTER_VIDEOS_PATH`.
+*/
+const BYTEPLUS_VIDEO_TASKS_PATH = "/api/v3/contents/generations/tasks";
+/**
+* The two NON-terminal task states, per `@tanstack/ai-byteplus@0.3.4`'s
+* `wire-types.ts:38-44` — the client library's status union, not a BytePlus
+* document. This is the primitive: "terminal" is derived as everything else,
+* so a status token the client library does not list (whether BytePlus added
+* it or the library simply never had it) records instead of proxying forever.
+* See `isBytePlusTerminalStatus`.
+*/
+const BYTEPLUS_NON_TERMINAL_STATUSES = new Set(["queued", "running"]);
+/**
+* The six task states the client library declares. Anything outside this set is
+* a surprise — an authoring error, or a token the library does not cover.
+*/
+const BYTEPLUS_TASK_STATUSES = new Set([
+	...BYTEPLUS_NON_TERMINAL_STATUSES,
+	"succeeded",
+	"failed",
+	"cancelled",
+	"expired"
+]);
+/**
+* Terminal is the COMPLEMENT of the two non-terminal tokens, never a second
+* hardcoded list of the four terminal ones. An unrecognized status is treated
+* as terminal deliberately: a status absent from the client library's union is
+* far more likely to be an end state than an intermediate one, and guessing wrong
+* in that direction costs a captured fixture the operator can inspect, while
+* guessing wrong the other way costs a record run that polls until the client
+* times out and writes nothing.
+*/
+function isBytePlusTerminalStatus(status) {
+	return !BYTEPLUS_NON_TERMINAL_STATUSES.has(status);
+}
+/** Ark output URLs expire 24h after the task produced them, anchored on `updated_at`. */
+const BYTEPLUS_URL_TTL_SECONDS = 1440 * 60;
+const BYTEPLUS_VIDEO_MAX_ENTRIES = 1e4;
+const BYTEPLUS_VIDEO_TTL_MS = 36e5;
+/**
+* Warn latches keyed on the ENVELOPE OBJECT, not the job. A suite that replays
+* one aged fixture across a hundred tests mints a hundred jobs off the SAME
+* envelope object (the fixture's `response.json`), and a per-job latch would
+* emit a hundred identical lines — noise, not signal. The envelope is the thing
+* being complained about, so it owns the latch. WeakMap so a fixtures reset
+* drops the latches with the fixtures.
+*/
+const bytePlusWarnLatches = /* @__PURE__ */ new WeakMap();
+function warnLatchesFor(envelope) {
+	const existing = bytePlusWarnLatches.get(envelope);
+	if (existing !== void 0) return existing;
+	const fresh = {};
+	bytePlusWarnLatches.set(envelope, fresh);
+	return fresh;
+}
+/**
+* Per-testId job state. Mirrors GrokVideoJobMap / OpenRouterVideoJobMap: lazy
+* TTL eviction on `get`, FIFO eviction of the oldest entries on `set` when over
+* capacity, delete-before-set TTL refresh, monotonic world-generation counter
+* for reset-mid-flight detection, no background sweep timer.
+* Keys are `${testId}:${id}`.
+*/
+var BytePlusVideoJobMap = class {
+	entries = /* @__PURE__ */ new Map();
+	worldGeneration = 0;
+	get generation() {
+		return this.worldGeneration;
+	}
+	get(key) {
+		const entry = this.entries.get(key);
+		if (!entry) return void 0;
+		if (Date.now() - entry.createdAt > BYTEPLUS_VIDEO_TTL_MS) {
+			this.entries.delete(key);
+			return;
+		}
+		return entry.job;
+	}
+	set(key, job) {
+		this.entries.delete(key);
+		this.entries.set(key, {
+			job,
+			createdAt: Date.now()
+		});
+		if (this.entries.size > BYTEPLUS_VIDEO_MAX_ENTRIES) {
+			const excess = this.entries.size - BYTEPLUS_VIDEO_MAX_ENTRIES;
+			const iter = this.entries.keys();
+			for (let i = 0; i < excess; i++) {
+				const next = iter.next();
+				if (!next.done) this.entries.delete(next.value);
+			}
+		}
+	}
+	delete(key) {
+		return this.entries.delete(key);
+	}
+	clear() {
+		this.entries.clear();
+		this.worldGeneration++;
+	}
+	get size() {
+		return this.entries.size;
+	}
+};
+/** The `{ url }` wrapper each media part carries, keyed by the part's `type`. */
+function mediaUrlOf(part) {
+	const holder = part.type === "image_url" ? part.image_url : part.type === "video_url" ? part.video_url : part.type === "audio_url" ? part.audio_url : void 0;
+	if (holder === null || typeof holder !== "object") return void 0;
+	const url = holder.url;
+	return typeof url === "string" ? url : void 0;
+}
+function digest12(value) {
+	return crypto.createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+/** Stable-enough serialisation of a part the media table could not resolve. */
+function unresolvedPartToken(raw) {
+	if (raw === null || typeof raw !== "object") return `part:${digest12(String(raw))}`;
+	const part = raw;
+	const role = typeof part.type === "string" && part.type ? part.type : "part";
+	let serialised;
+	try {
+		serialised = JSON.stringify(raw) ?? String(raw);
+	} catch {
+		serialised = String(raw);
+	}
+	return `${role}:${digest12(serialised)}`;
+}
+/**
+* The synthetic user message a submit is matched on.
+*
+* Concatenated text of every `type: "text"` part, then ALWAYS
+* `[media: <role>:<sha256 first 12 hex>, …]` — one entry per non-text part in
+* array order, `[media: ]` when there are none. The separating newline is
+* present only when there IS text: a key with no text part is the bare
+* `[media: …]` suffix, unprefixed.
+*
+* WHY the digest: a Seedance image-to-video job carries NO text part, so a
+* text-only key would record `{ endpoint, model }` — a wildcard matching every
+* image-to-video job in the suite for that model. `persistFixture`'s
+* defective-fixture guard would not catch it either, because its `isEmptyMatch`
+* requires `endpoint` to be undefined too. Image-to-video, last-frame and
+* reference-media are first-class Seedance modes, so two recordings with the
+* same prompt and different first frames must stay distinguishable.
+*
+* WHY the marker is UNCONDITIONAL: this key lands in `match.userMessage`, which
+* the router SUBSTRING-matches by default (`useExactMatch = !!requestTransform`).
+* A conditional suffix makes the text-only key `"a guitar"` a prefix of the
+* image-to-video key `"a guitar\n[media: …]"`, so a t2v recording silently
+* serves its own video_url to an i2v request that shares the prompt — a 200
+* with the wrong bytes. Emitting `[media: ]` for the text-only case makes
+* neither key a substring of the other. Prefixing would NOT fix it: the plain
+* text is still contained in the prefixed form.
+*
+* WHY every unrecognised part still contributes: `mediaUrlOf` resolves exactly
+* `image_url` / `video_url` / `audio_url` with a `{ url: string }` wrapper, and
+* the whole wire contract here is unverified against BytePlus. Dropping the
+* parts it cannot resolve reopened both failures above — an all-unrecognised
+* content array returned `""` and minted the very wildcard this key exists to
+* prevent, and two different unrecognised parts collapsed onto one key. They
+* are digested over their own JSON instead, so they stay distinguishable
+* without the key ever carrying the part's payload.
+*
+* The digest is taken over the url string whether that is a public URL or a
+* multi-megabyte `data:` URI, and only 12 hex are kept — the match key stays
+* short and the fixture never grows a data URI.
+*
+* `role` is the declared role, else `first_frame` for an image (the default
+* `@tanstack/ai-byteplus@0.3.4` applies when a request omits the role — not a
+* BytePlus-documented default; nothing here was read from BytePlus), else the
+* part's `type` token, which is read off the request rather than drawn from any
+* role vocabulary.
+*/
+function buildBytePlusMatchText(content) {
+	const texts = [];
+	const media = [];
+	for (const raw of content) {
+		const part = raw !== null && typeof raw === "object" ? raw : void 0;
+		if (part?.type === "text") {
+			if (typeof part.text === "string" && part.text) texts.push(part.text);
+			continue;
+		}
+		const url = part === void 0 ? void 0 : mediaUrlOf(part);
+		if (part === void 0 || url === void 0) {
+			media.push(unresolvedPartToken(raw));
+			continue;
+		}
+		const role = typeof part.role === "string" && part.role ? part.role : part.type === "image_url" ? "first_frame" : String(part.type);
+		media.push(`${role}:${digest12(url)}`);
+	}
+	const suffix = `[media: ${media.join(", ")}]`;
+	const text = texts.join("\n");
+	return text ? `${text}\n${suffix}` : suffix;
+}
+/**
+* Advance a replay job one poll. `queued → running → terminal` on poll-count
+* thresholds; no-op once terminal, which is what makes the extra post-terminal
+* poll the client library makes (getVideoStatus then getVideoUrl both hit this
+* endpoint) byte-identical to the one before it.
+*/
+function advanceJob(job) {
+	if (job.phase === "terminal") return;
+	job.pollCount += 1;
+	if (job.phase === "queued" && job.pollCount >= job.pollsBeforeRunning) job.phase = "running";
+	if (job.pollCount >= job.pollsBeforeTerminal) job.phase = "terminal";
+}
+/**
+* Ark's error envelope SHAPE, carrying a message only — never an invented code.
+*
+* KNOWN, DELIBERATE, UNRESOLVED DIVERGENCE. The live canary in
+* `src/__tests__/drift/byteplus-video.drift.ts` asserts that real Ark supplies a
+* string `error.code`, so a consumer that reads `error.code` off an aimock-
+* authored error (404 unknown task, 404 no fixture, 400 validation, 502 bad
+* envelope, 503 strict) sees `undefined` where live Ark would give it a token.
+*
+* We omit it rather than close the gap because we do not know the value FOR
+* THESE CLASSES. The canary is keyless and does run — it observed Ark's
+* AUTH-layer error body live on 2026-09-10 (`code: "AuthenticationError"`,
+* `type: "Unauthorized"`, `param: ""`; see the `OBSERVED_*` constants in the
+* drift file). None of the five error classes above is an auth error, so that
+* observation does not supply their codes, and `@tanstack/ai-byteplus` is not
+* installed here, so nobody has verified what the client does with a missing
+* `code` either. Minting one would put an aimock-authored token into a consumer's
+* assertions and into any fixture recorded past it, which is the failure this
+* module exists to avoid; the governing rule is that the mock never authors a
+* wire value it did not observe, and an honest absence beats a plausible
+* invention. Recorded fixtures are unaffected: a real `error.code` captured
+* from upstream replays verbatim.
+*
+* Also omitted, for the same reason and on the same terms: `type` and `param`.
+* Both ARE observed on the auth envelope, and neither is known for the five
+* classes above.
+*
+* To close it: observe a real Ark 404/400/5xx for each class (a real key is
+* needed to reach them), then carry the OBSERVED code per error class. Do not
+* guess one.
+*/
+function arkErrorBody(message) {
+	return JSON.stringify({ error: { message } });
+}
+function asRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+/**
+* Build the poll body for a replay job.
+*
+* Non-terminal: `{ id, model?, status, created_at? }` — the status token is the
+* ONLY synthesized value, and `content`/`error`/`usage`/`updated_at` are
+* withheld. `created_at` is a property of the task and is true at every phase;
+* `updated_at` on a recorded envelope is the timestamp of the TERMINAL
+* transition, so emitting it mid-flight would assert a field COMBINATION this
+* design has never seen from Ark and cannot source from the client library
+* either (and a consumer diffing it across polls would see it constant).
+*
+* Terminal: the stored envelope VERBATIM with `id` rewritten. Its status is
+* whatever was recorded, including `cancelled` / `expired`.
+*
+* Returns `null` when the envelope cannot produce a poll body at all (not an
+* object, or no `status`) — an authoring error the caller answers with a 502.
+*/
+function serializeBytePlusVideoTask(job, logger) {
+	const envelope = job.envelope;
+	const status = envelope.status;
+	if (typeof status !== "string" || !status) return null;
+	if (job.phase !== "terminal") {
+		const body = {
+			id: job.id,
+			status: job.phase
+		};
+		if (envelope.model !== void 0) body.model = envelope.model;
+		if (envelope.created_at !== void 0) body.created_at = envelope.created_at;
+		return body;
+	}
+	const warned = warnLatchesFor(envelope);
+	if (!isBytePlusTerminalStatus(status) && !warned.nonTerminalEnvelope) {
+		warned.nonTerminalEnvelope = true;
+		logger.warn(`BytePlus video fixture for job ${job.id} has reached its terminal poll but its envelope carries the NON-TERMINAL status "${status}" — every later poll returns this same body, so the client will poll it forever and fail on its own timeout. Re-record the fixture, or author a terminal status (succeeded, failed, cancelled, expired)`);
+	}
+	if (!BYTEPLUS_TASK_STATUSES.has(status) && !warned.unknownStatus) {
+		warned.unknownStatus = true;
+		logger.warn(`BytePlus video fixture for job ${job.id} carries status "${status}", which is not one of the six the BytePlus client library declares (queued, running, succeeded, failed, cancelled, expired) — serving it as authored, but that library's mapStatus() THROWS on a status it does not recognize`);
+	}
+	const videoUrl = asRecord(envelope.content)?.video_url;
+	if (status === "succeeded" && typeof videoUrl !== "string" && !warned.missingUrl) {
+		warned.missingUrl = true;
+		logger.warn(`BytePlus video fixture for job ${job.id} reports status "succeeded" but carries no content.video_url — the client will throw "Video is not ready for download. Check status first." Add content.video_url to the fixture envelope`);
+	}
+	const updatedAt = envelope.updated_at;
+	if (status === "succeeded" && typeof videoUrl === "string" && typeof updatedAt === "number" && Number.isFinite(updatedAt) && !warned.expiredUrl) {
+		const expiresAt = updatedAt + BYTEPLUS_URL_TTL_SECONDS;
+		if (expiresAt * 1e3 < Date.now()) {
+			warned.expiredUrl = true;
+			logger.warn(`BytePlus video fixture for job ${job.id} has a content.video_url that expired at ${(/* @__PURE__ */ new Date(expiresAt * 1e3)).toISOString()} (Ark output urls live 24h from updated_at) — serving it anyway; re-record the fixture to get a live url`);
+		}
+	}
+	return {
+		...envelope,
+		id: job.id
+	};
+}
+/**
+* Structurally valid journal body for a field-validation 400. Mirrors
+* grok-video / openrouter-video: `model` stays a string and `messages` is an
+* empty array; underscore-prefixed keys are stripped so a request cannot spoof
+* handler-set discriminators.
+*/
+function validationJournalBody(videoReq) {
+	const rawModel = videoReq.model;
+	const model = typeof rawModel === "string" ? rawModel : rawModel === void 0 ? "" : JSON.stringify(rawModel);
+	return {
+		...Object.fromEntries(Object.entries(videoReq).filter(([key]) => !key.startsWith("_"))),
+		model,
+		messages: []
+	};
+}
+async function handleBytePlusVideoCreate(req, res, raw, fixtures, journal, defaults, setCorsHeaders, jobs) {
+	setCorsHeaders(res);
+	const path = req.url ?? BYTEPLUS_VIDEO_TASKS_PATH;
+	const method = req.method ?? "POST";
+	const fail = (status, message, body) => {
+		journal.add({
+			method,
+			path,
+			headers: flattenHeaders(req.headers),
+			body,
+			response: {
+				status,
+				fixture: null
+			}
+		});
+		writeErrorResponse(res, status, arkErrorBody(message));
+	};
+	let videoReq;
+	try {
+		videoReq = JSON.parse(raw);
+	} catch (parseErr) {
+		fail(400, `Malformed JSON: ${parseErr instanceof Error ? parseErr.message : "unknown"}`, null);
+		return;
+	}
+	if (videoReq === null || typeof videoReq !== "object" || Array.isArray(videoReq)) {
+		fail(400, "Request body must be a JSON object", null);
+		return;
+	}
+	const parsedBody = validationJournalBody(videoReq);
+	if (typeof videoReq.model !== "string" || !videoReq.model) {
+		fail(400, videoReq.model === void 0 ? "Missing required parameter: 'model'" : "Invalid type for parameter: 'model' must be a non-empty string", parsedBody);
+		return;
+	}
+	if (!Array.isArray(videoReq.content) || videoReq.content.length === 0) {
+		fail(400, videoReq.content === void 0 ? "Missing required parameter: 'content'" : "Invalid type for parameter: 'content' must be a non-empty array", parsedBody);
+		return;
+	}
+	const syntheticReq = {
+		model: videoReq.model,
+		messages: [{
+			role: "user",
+			content: buildBytePlusMatchText(videoReq.content)
+		}],
+		_endpointType: "video",
+		_videoProvider: "byteplus",
+		_context: getContext(req)
+	};
+	const testId = getTestId(req);
+	const { fixture, skippedBySequenceOrTurn } = matchFixtureDiagnostic(fixtures, syntheticReq, journal.getFixtureMatchCountsForTest(testId), defaults.requestTransform);
+	if (fixture) {
+		journal.incrementFixtureMatchCount(fixture, fixtures, testId);
+		defaults.logger.debug(`Fixture matched: ${JSON.stringify(fixture.match).slice(0, 120)}`);
+	}
+	if (applyChaos(res, fixture, defaults.chaos, req.headers, req.url, journal, {
+		method,
+		path,
+		headers: flattenHeaders(req.headers),
+		body: syntheticReq
+	}, fixture ? "fixture" : resolveStrictMode(defaults.strict, req.headers) ? "internal" : defaults.record?.providers.byteplus ? "proxy" : "internal", defaults.registry, defaults.logger)) return;
+	if (!fixture) {
+		if (resolveStrictMode(defaults.strict, req.headers)) {
+			const strictMessage = strictNoMatchMessage(skippedBySequenceOrTurn);
+			defaults.logger.error(strictNoMatchLogLine(method, path, skippedBySequenceOrTurn));
+			journal.add({
+				method,
+				path,
+				headers: flattenHeaders(req.headers),
+				body: syntheticReq,
+				response: {
+					status: 503,
+					fixture: null,
+					...strictOverrideField(defaults.strict, req.headers)
+				}
+			});
+			writeErrorResponse(res, 503, arkErrorBody(strictMessage));
+			return;
+		}
+		if (defaults.record) {
+			if (await proxyBytePlusVideoSubmit({
+				req,
+				res,
+				raw,
+				syntheticReq,
+				record: defaults.record,
+				journal,
+				defaults,
+				jobs,
+				method,
+				path
+			}) === "handled") return;
+		}
+		journal.add({
+			method,
+			path,
+			headers: flattenHeaders(req.headers),
+			body: syntheticReq,
+			response: {
+				status: 404,
+				fixture: null,
+				...strictOverrideField(defaults.strict, req.headers)
+			}
+		});
+		writeErrorResponse(res, 404, arkErrorBody("No byteplus fixture matched. A byteplus video fixture must carry match.endpoint: \"video\" and a { json: <Ark task envelope> } response"));
+		return;
+	}
+	const worldGeneration = jobs.generation;
+	const response = await resolveResponse(fixture, syntheticReq);
+	if (isErrorResponse(response)) {
+		if (res.destroyed || res.writableEnded) return;
+		const status = response.status ?? 500;
+		journal.add({
+			method,
+			path,
+			headers: flattenHeaders(req.headers),
+			body: syntheticReq,
+			response: {
+				status,
+				fixture
+			}
+		});
+		writeErrorResponse(res, status, serializeErrorResponse(response), { retryAfter: response.retryAfter });
+		return;
+	}
+	if (!isJSONResponse(response)) {
+		if (res.destroyed || res.writableEnded) return;
+		defaults.logger.warn("BytePlus video fixture matched but its response is not a { json: … } payload — this surface stores the Ark task envelope verbatim, NOT a VideoResponse. Treating it as a no-match");
+		journal.add({
+			method,
+			path,
+			headers: flattenHeaders(req.headers),
+			body: syntheticReq,
+			response: {
+				status: 404,
+				fixture: null
+			}
+		});
+		writeErrorResponse(res, 404, arkErrorBody("Matched byteplus fixture has a non-JSON response; expected { json: <Ark task envelope> }"));
+		return;
+	}
+	const envelope = asRecord(response.json);
+	if (!envelope) {
+		if (res.destroyed || res.writableEnded) return;
+		defaults.logger.warn("BytePlus video fixture's json payload is not a JSON object — expected an Ark task envelope");
+		journal.add({
+			method,
+			path,
+			headers: flattenHeaders(req.headers),
+			body: syntheticReq,
+			response: {
+				status: 404,
+				fixture: null
+			}
+		});
+		writeErrorResponse(res, 404, arkErrorBody("Matched byteplus fixture's json is not an object"));
+		return;
+	}
+	if (res.destroyed || res.writableEnded) return;
+	journal.add({
+		method,
+		path,
+		headers: flattenHeaders(req.headers),
+		body: syntheticReq,
+		response: {
+			status: 200,
+			fixture
+		}
+	});
+	const id = `cgt-${crypto.randomUUID()}`;
+	const progression = resolveProgression(defaults.bytePlusVideo);
+	const job = {
+		kind: "replay",
+		id,
+		phase: "queued",
+		pollCount: 0,
+		pollsBeforeRunning: progression.pollsBeforeInProgress,
+		pollsBeforeTerminal: progression.pollsBeforeCompleted,
+		envelope
+	};
+	if (progression.pollsBeforeCompleted === 0) job.phase = "terminal";
+	if (jobs.generation === worldGeneration) jobs.set(`${testId}:${id}`, job);
+	else defaults.logger.warn(`BytePlus video submit resolved after a fixtures reset — not inserting job ${id} into the new world (its polls will 404)`);
+	res.writeHead(200, { "Content-Type": "application/json" });
+	res.end(JSON.stringify({ id }));
+}
+async function handleBytePlusVideoStatus(req, res, id, fixtures, journal, defaults, setCorsHeaders, jobs) {
+	setCorsHeaders(res);
+	const path = req.url ?? `${BYTEPLUS_VIDEO_TASKS_PATH}/${id}`;
+	const method = req.method ?? "GET";
+	const testId = getTestId(req);
+	const key = `${testId}:${id}`;
+	if (applyChaos(res, null, defaults.chaos, req.headers, req.url, journal, {
+		method,
+		path,
+		headers: flattenHeaders(req.headers),
+		body: null
+	}, "internal", defaults.registry, defaults.logger)) return;
+	const job = jobs.get(key);
+	if (!job) {
+		journal.add({
+			method,
+			path,
+			headers: flattenHeaders(req.headers),
+			body: null,
+			response: {
+				status: 404,
+				fixture: null
+			}
+		});
+		writeErrorResponse(res, 404, arkErrorBody(`Unknown video task id "${id}" — no such job for this test scope. It was never created, it belongs to a different x-test-id, or it aged out of aimock's 1h job TTL`));
+		return;
+	}
+	if (job.kind === "record") {
+		if (resolveStrictMode(defaults.strict, req.headers)) {
+			defaults.logger.error(`STRICT: video task ${id} is proxied live upstream (record mode) — refusing the upstream poll`);
+			journal.add({
+				method,
+				path,
+				headers: flattenHeaders(req.headers),
+				body: null,
+				response: {
+					status: 503,
+					fixture: null,
+					...strictOverrideField(defaults.strict, req.headers)
+				}
+			});
+			writeErrorResponse(res, 503, arkErrorBody(`Strict mode: video task ${id} is proxied live upstream (record mode) — nothing reaches an upstream under strict mode`));
+			return;
+		}
+		await proxyBytePlusVideoRecordPoll({
+			req,
+			res,
+			job,
+			key,
+			testId,
+			fixtures,
+			journal,
+			defaults,
+			jobs,
+			method,
+			path
+		});
+		return;
+	}
+	if (res.destroyed || res.writableEnded) return;
+	advanceJob(job);
+	jobs.set(key, job);
+	const body = serializeBytePlusVideoTask(job, defaults.logger);
+	if (!body) {
+		defaults.logger.warn(`BytePlus video fixture for job ${id} has an envelope that is not a usable Ark task body (missing or non-string "status") — a fixture that cannot produce a poll body is an authoring error`);
+		journal.add({
+			method,
+			path,
+			headers: flattenHeaders(req.headers),
+			body: null,
+			response: {
+				status: 502,
+				fixture: null
+			}
+		});
+		writeErrorResponse(res, 502, arkErrorBody(`Fixture envelope for video task ${id} carries no "status" — expected an Ark task envelope`));
+		return;
+	}
+	journal.add({
+		method,
+		path,
+		headers: flattenHeaders(req.headers),
+		body: null,
+		response: {
+			status: 200,
+			fixture: null
+		}
+	});
+	res.writeHead(200, { "Content-Type": "application/json" });
+	res.end(JSON.stringify(body));
+}
+/**
+* Proxy an unmatched submit to the configured upstream and answer the client
+* with a mock-rewritten `{ id }`. The upstream lifecycle is then driven
+* interactively by the client's own polls. Returns "no_upstream" when record
+* mode has no byteplus provider URL — the caller falls through to 404.
+*/
+async function proxyBytePlusVideoSubmit(args) {
+	const { req, res, raw, syntheticReq, record, journal, defaults, jobs, method, path } = args;
+	const upstreamBase = record.providers.byteplus;
+	if (!upstreamBase) {
+		defaults.logger.warn(`No upstream URL configured for provider "byteplus" — cannot proxy`);
+		return "no_upstream";
+	}
+	const proxyError = (msg) => {
+		defaults.logger.error(`BytePlus video submit proxy failed: ${msg}`);
+		if (res.destroyed || res.writableEnded) return "handled";
+		journal.add({
+			method,
+			path,
+			headers: flattenHeaders(req.headers),
+			body: syntheticReq,
+			response: {
+				status: 502,
+				fixture: null,
+				source: "proxy",
+				...strictOverrideField(defaults.strict, req.headers)
+			}
+		});
+		writeErrorResponse(res, 502, arkErrorBody(`Proxy to upstream failed: ${msg}`));
+		return "handled";
+	};
+	let submitUrl;
+	try {
+		submitUrl = resolveUpstreamUrl(upstreamBase, BYTEPLUS_VIDEO_TASKS_PATH);
+	} catch (err) {
+		return proxyError(`Invalid upstream URL: ${upstreamBase} (${err instanceof Error ? err.message : String(err)})`);
+	}
+	defaults.logger.warn(`NO FIXTURE MATCH — proxying video submit to ${submitUrl.toString()}`);
+	const worldGeneration = jobs.generation;
+	let fetched;
+	try {
+		const headers = prepareEgressHeaders(req, submitUrl, "byteplus", record.providerKeys?.byteplus);
+		if (!headers) return proxyError("No configured provider credential");
+		const upstreamRes = await fetch(submitUrl, {
+			method: "POST",
+			headers,
+			body: raw,
+			signal: upstreamTimeoutSignal(record)
+		});
+		fetched = {
+			status: upstreamRes.status,
+			contentType: upstreamRes.headers.get("content-type"),
+			text: await readEnvelopeText(upstreamRes, record)
+		};
+	} catch (err) {
+		return proxyError(err instanceof Error ? err.message : "Unknown proxy error");
+	}
+	if (fetched.status === 401 || fetched.status === 403) {
+		defaults.logger.warn(`Upstream rejected the video submit (${fetched.status}) — relaying the upstream status`);
+		if (res.destroyed || res.writableEnded) return "handled";
+		journal.add({
+			method,
+			path,
+			headers: flattenHeaders(req.headers),
+			body: syntheticReq,
+			response: {
+				status: fetched.status,
+				fixture: null,
+				source: "proxy",
+				...strictOverrideField(defaults.strict, req.headers)
+			}
+		});
+		res.writeHead(fetched.status, { "Content-Type": fetched.contentType ?? "application/json" });
+		res.end(fetched.text);
+		return "handled";
+	}
+	if (fetched.status < 200 || fetched.status >= 300) return proxyError(`Submit ${fetched.status}: ${fetched.text.slice(0, 200)}`);
+	let upstreamTaskId;
+	{
+		let parsed;
+		try {
+			parsed = JSON.parse(fetched.text);
+		} catch {
+			return proxyError(`Submit returned non-JSON: ${fetched.text.slice(0, 200)}`);
+		}
+		const envelope = asRecord(parsed);
+		if (!envelope) return proxyError("Submit response is not a JSON object");
+		upstreamTaskId = String(envelope.id ?? "").trim();
+		if (!upstreamTaskId) return proxyError("Submit response missing id");
+	}
+	const upstreamPollingUrl = resolveUpstreamUrl(upstreamBase, `${BYTEPLUS_VIDEO_TASKS_PATH}/${encodeURIComponent(upstreamTaskId)}`).toString();
+	const testId = getTestId(req);
+	const matchRequest = defaults.requestTransform ? defaults.requestTransform(syntheticReq) : syntheticReq;
+	const id = `cgt-${crypto.randomUUID()}`;
+	const job = {
+		kind: "record",
+		id,
+		upstreamTaskId,
+		upstreamPollingUrl,
+		match: buildFixtureMatch(matchRequest, record)
+	};
+	if (jobs.generation === worldGeneration) jobs.set(`${testId}:${id}`, job);
+	else defaults.logger.warn(`BytePlus video submit for upstream task ${upstreamTaskId} completed after a fixtures reset — not inserting the job into the new world (its polls will 404)`);
+	if (res.destroyed || res.writableEnded) return "handled";
+	journal.add({
+		method,
+		path,
+		headers: flattenHeaders(req.headers),
+		body: syntheticReq,
+		response: {
+			status: 200,
+			fixture: null,
+			source: "proxy",
+			...strictOverrideField(defaults.strict, req.headers)
+		}
+	});
+	res.writeHead(200, { "Content-Type": "application/json" });
+	res.end(JSON.stringify({ id }));
+	return "handled";
+}
+/**
+* Proxy a status poll 1:1 and relay the result with the mock id substituted.
+*
+* An upstream 4xx is RELAYED VERBATIM rather than converted to 502 — a 404 in
+* particular, because the client has a deliberate 404 branch that keeps Ark's
+* own code/message on purpose, and converting it would make record mode behave
+* differently from live Ark for exactly the case that branch exists to serve.
+* 5xx and transport failures become 502.
+*
+* On ANY terminal status the rewritten body is relayed immediately and the
+* envelope is captured. All four terminal states are captured identically:
+* there is no warn-and-drop branch, so a task cancelled from the Ark console
+* mid-record yields an artifact rather than a warning and an empty directory.
+*/
+async function proxyBytePlusVideoRecordPoll(args) {
+	const { req, res, job, key, testId, fixtures, journal, defaults, jobs, method, path } = args;
+	const logger = defaults.logger;
+	const journalProxy = (status) => {
+		journal.add({
+			method,
+			path,
+			headers: flattenHeaders(req.headers),
+			body: null,
+			response: {
+				status,
+				fixture: null,
+				source: "proxy",
+				...strictOverrideField(defaults.strict, req.headers)
+			}
+		});
+	};
+	const proxyError = (msg) => {
+		logger.error(`BytePlus video poll proxy failed: ${msg}`);
+		if (res.destroyed || res.writableEnded) return;
+		journalProxy(502);
+		writeErrorResponse(res, 502, arkErrorBody(`Proxy to upstream failed: ${msg}`));
+	};
+	const record = defaults.record;
+	if (!record) {
+		proxyError("record mode is no longer configured for an in-flight record job");
+		return;
+	}
+	let fetched;
+	try {
+		const headers = prepareEgressHeaders(req, new URL(job.upstreamPollingUrl), "byteplus", record.providerKeys?.byteplus);
+		if (!headers) {
+			proxyError("No configured provider credential");
+			return;
+		}
+		const upstreamRes = await fetch(job.upstreamPollingUrl, {
+			headers,
+			signal: upstreamTimeoutSignal(record)
+		});
+		fetched = {
+			status: upstreamRes.status,
+			contentType: upstreamRes.headers.get("content-type"),
+			text: await readEnvelopeText(upstreamRes, record)
+		};
+	} catch (err) {
+		proxyError(err instanceof Error ? err.message : "Unknown proxy error");
+		return;
+	}
+	if (fetched.status >= 400 && fetched.status < 500) {
+		logger.warn(`Upstream returned ${fetched.status} for video task ${job.upstreamTaskId} — relaying it verbatim`);
+		if (res.destroyed || res.writableEnded) return;
+		journalProxy(fetched.status);
+		res.writeHead(fetched.status, { "Content-Type": fetched.contentType ?? "application/json" });
+		res.end(fetched.text);
+		return;
+	}
+	if (fetched.status < 200 || fetched.status >= 300) {
+		proxyError(`Status ${fetched.status}: ${fetched.text.slice(0, 200)}`);
+		return;
+	}
+	let upstreamBody;
+	{
+		let parsed;
+		try {
+			parsed = JSON.parse(fetched.text);
+		} catch {
+			proxyError(`Status returned non-JSON: ${fetched.text.slice(0, 200)}`);
+			return;
+		}
+		const envelope = asRecord(parsed);
+		if (!envelope) {
+			proxyError("Status response is not a JSON object");
+			return;
+		}
+		upstreamBody = envelope;
+	}
+	const relayBody = {
+		...upstreamBody,
+		id: job.id
+	};
+	const relayJson = (body) => {
+		if (res.destroyed || res.writableEnded) return;
+		journalProxy(200);
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(JSON.stringify(body));
+	};
+	const rawStatus = upstreamBody.status;
+	const upstreamStatus = typeof rawStatus === "string" ? rawStatus : "";
+	if (!upstreamStatus || !isBytePlusTerminalStatus(upstreamStatus)) {
+		if (jobs.get(key) === job) jobs.set(key, job);
+		relayJson(relayBody);
+		return;
+	}
+	if (record.proxyOnly) {
+		if (jobs.get(key) === job) jobs.set(key, job);
+		relayJson(relayBody);
+		return;
+	}
+	if (jobs.get(key) !== job) {
+		relayJson(relayBody);
+		return;
+	}
+	captureBytePlusVideoRecordFixture({
+		job,
+		key,
+		testId,
+		fixtures,
+		defaults,
+		jobs,
+		record,
+		upstreamBody,
+		res
+	});
+	relayJson(relayBody);
+}
+/**
+* Capture a terminal record job into a fixture (PERSIST only — NO byte
+* download) and mutate the map entry into a terminal replay job.
+*
+* Runs BEFORE the caller relays, and is fully synchronous, so a persist failure
+* still reaches the client as an `X-AIMock-Record-Error` header rather than
+* only as a log line behind a 200 the client cannot distinguish from a clean
+* record.
+*
+* The upstream `id` is REMOVED at capture: replay stamps its own, and keeping a
+* real Ark task id in a committed artifact leaks it for no benefit.
+*/
+function captureBytePlusVideoRecordFixture(args) {
+	const { job, key, testId, fixtures, defaults, jobs, record, upstreamBody, res } = args;
+	const logger = defaults.logger;
+	try {
+		const { id: _discardedUpstreamId, ...envelope } = upstreamBody;
+		const persistResult = persistFixture({
+			record,
+			providerKey: "byteplus",
+			testId,
+			fixture: {
+				match: job.match,
+				response: { json: envelope }
+			},
+			fixtures,
+			logger
+		});
+		if (persistResult.kind === "failed" && !res.headersSent) res.setHeader("X-AIMock-Record-Error", sanitizeHeaderValue(persistResult.error));
+		jobs.set(key, {
+			kind: "replay",
+			id: job.id,
+			phase: "terminal",
+			pollCount: 0,
+			pollsBeforeRunning: 0,
+			pollsBeforeTerminal: 0,
+			envelope
+		});
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		logger.error(`BytePlus video capture for task ${job.upstreamTaskId} failed unexpectedly (${msg}) — fixture not persisted; the job keeps proxying live`);
+	}
+}
+
+//#endregion
+export { BYTEPLUS_VIDEO_MAX_ENTRIES, BYTEPLUS_VIDEO_TASKS_PATH, BytePlusVideoJobMap, buildBytePlusMatchText, handleBytePlusVideoCreate, handleBytePlusVideoStatus };
+//# sourceMappingURL=byteplus-video.js.map