emdash 0.31.1 → 0.33.0

package/src/api/handlers/content.ts

@@ -15,6 +15,7 @@ import { RevisionRepository } from "../../database/repositories/revision.js";
 import { SeoRepository } from "../../database/repositories/seo.js";
 import { TaxonomyRepository } from "../../database/repositories/taxonomy.js";
 import {
+	ContentMutationConflictError,
 	EmDashValidationError,
 	ScheduledNotDueError,
 	InvalidCursorError,
@@ -376,6 +377,15 @@ async function createSlugChangeRedirect(
 	newSlug: string,
 	contentId: string,
 ): Promise<void> {
+	// A URL pattern has no locale token, so every locale variant of an entry
+	// generates the same URL, and slugs are unique per (slug, locale) — a
+	// translation may still hold the old slug. Redirecting away from a URL
+	// another row still answers on would take that page down: the redirect
+	// middleware runs `order: "pre"`, so routing never gets a chance.
+	// Any surviving row counts, published or not: a draft that publishes later
+	// would otherwise be shadowed by the redirect.
+	if (await slugStillTaken(db, collection, oldSlug, contentId)) return;
+
 	const collectionRow = await db
 		.selectFrom("_emdash_collections")
 		.select("url_pattern")
@@ -393,6 +403,24 @@ async function createSlugChangeRedirect(
 	invalidateRedirectCache();
 }
 
+/** Whether a row other than `contentId` still holds `slug` in this collection. */
+async function slugStillTaken(
+	db: Kysely<Database>,
+	collection: string,
+	slug: string,
+	contentId: string,
+): Promise<boolean> {
+	validateIdentifier(collection, "collection slug");
+	const result = await sql<{ id: string }>`
+		SELECT id FROM ${sql.ref(`ec_${collection}`)}
+		WHERE slug = ${slug}
+		AND id != ${contentId}
+		AND deleted_at IS NULL
+		LIMIT 1
+	`.execute(db);
+	return result.rows.length > 0;
+}
+
 /** Matches a date-only `YYYY-MM-DD` bound (no time component). */
 const DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
 
@@ -1450,15 +1478,18 @@ export async function handleContentUnschedule(
 /**
  * Publish content immediately.
  *
- * Wrapped in a transaction because publish performs multiple writes
- * (syncDataColumns, slug sync, status/revision update) that must
- * be atomic to prevent FTS shadow table corruption on crash.
+ * Publication is one atomic content-row statement. On databases that support
+ * transactions, the existing slug-redirect side write remains grouped with it.
  */
 export async function handleContentPublish(
 	db: Kysely<Database>,
 	collection: string,
 	id: string,
-	options: { publishedAt?: string; requireScheduledDue?: boolean } = {},
+	options: {
+		publishedAt?: string;
+		requireScheduledDue?: boolean;
+		expectedScheduledAt?: string;
+	} = {},
 ): Promise<ApiResult<ContentResponse>> {
 	try {
 		const item = await withTransaction(db, async (trx) => {
@@ -1477,6 +1508,7 @@ export async function handleContentPublish(
 				resolvedId,
 				options.publishedAt,
 				options.requireScheduledDue,
+				options.expectedScheduledAt,
 			);
 
 			// Leave a 301 behind when publishing changed the slug of an entry that
@@ -1502,6 +1534,15 @@ export async function handleContentPublish(
 			data: { item },
 		};
 	} catch (error) {
+		if (error instanceof ContentMutationConflictError) {
+			return {
+				success: false,
+				error: {
+					code: "CONFLICT",
+					message: error.message,
+				},
+			};
+		}
 		// The scheduled sweep gates publish on the row still being due; a row
 		// unscheduled in the meantime is a silent skip, not a failure.
 		if (error instanceof ScheduledNotDueError) {

package/src/api/handlers/marketplace.ts

@@ -24,6 +24,10 @@ import {
 } from "../../plugins/marketplace.js";
 import type { SandboxRunner } from "../../plugins/sandbox/types.js";
 import { PluginStateRepository } from "../../plugins/state.js";
+import {
+	removeAllPluginIndexes,
+	syncDeclaredStorageIndexes,
+} from "../../plugins/storage-indexes.js";
 import { normalizeCapabilities } from "../../plugins/types.js";
 import type { PluginManifest } from "../../plugins/types.js";
 import { EmDashStorageError } from "../../storage/types.js";
@@ -475,6 +479,8 @@ export async function handleMarketplaceInstall(
 			description: pluginDetail.description ?? undefined,
 		});
 
+		await syncDeclaredStorageIndexes(db, [bundle.manifest]);
+
 		// Fire-and-forget install stat
 		client.reportInstall(pluginId, version).catch(() => {
 			// Intentional: never fails the install
@@ -713,6 +719,8 @@ export async function handleMarketplaceUpdate(
 			mcpToolsConsent: null,
 		});
 
+		await syncDeclaredStorageIndexes(db, [bundle.manifest]);
+
 		// Clean up old bundle from R2 (best-effort)
 		deleteBundleFromR2(storage, pluginId, oldVersion).catch(() => {});
 
@@ -786,6 +794,12 @@ export async function handleMarketplaceUninstall(
 			}
 		}
 
+		try {
+			await removeAllPluginIndexes(db, pluginId);
+		} catch {
+			// Nothing to drop, or tracking table predates the feature
+		}
+
 		// Delete state row
 		await stateRepo.delete(pluginId);
 

package/src/api/handlers/media.ts

@@ -185,12 +185,12 @@ export async function handleMediaUpdate(
 export async function handleMediaDelete(
 	db: Kysely<Database>,
 	id: string,
-): Promise<ApiResult<{ deleted: true }>> {
+): Promise<ApiResult<{ deleted: true; storageKey: string }>> {
 	try {
 		const repo = new MediaRepository(db);
-		const deleted = await repo.delete(id);
+		const storageKey = await repo.deleteWithStorageKey(id);
 
-		if (!deleted) {
+		if (!storageKey) {
 			return {
 				success: false,
 				error: {
@@ -202,7 +202,7 @@ export async function handleMediaDelete(
 
 		return {
 			success: true,
-			data: { deleted: true },
+			data: { deleted: true, storageKey },
 		};
 	} catch {
 		return {

package/src/api/handlers/registry.ts

@@ -49,6 +49,10 @@ import { extractBundle } from "../../plugins/marketplace.js";
 import type { PluginBundle } from "../../plugins/marketplace.js";
 import type { SandboxRunner } from "../../plugins/sandbox/types.js";
 import { PluginStateRepository } from "../../plugins/state.js";
+import {
+	removeAllPluginIndexes,
+	syncDeclaredStorageIndexes,
+} from "../../plugins/storage-indexes.js";
 import { declaredAccessToCapabilities } from "../../plugins/types.js";
 import type { DeclaredAccess } from "../../plugins/types.js";
 import {
@@ -1181,6 +1185,8 @@ export async function handleRegistryInstall(
 			throw stateErr;
 		}
 
+		await syncDeclaredStorageIndexes(db, [bundle.manifest]);
+
 		return {
 			success: true,
 			data: {
@@ -1288,6 +1294,12 @@ export async function handleRegistryUninstall(
 			await deleteBundleFromR2(storage, pluginId, version, "registry");
 		}
 
+		try {
+			await removeAllPluginIndexes(db, pluginId);
+		} catch {
+			// Nothing to drop, or tracking table predates the feature
+		}
+
 		await stateRepo.delete(pluginId);
 
 		return { success: true, data: { pluginId, dataDeleted } };
@@ -1646,6 +1658,8 @@ export async function handleRegistryUpdate(
 			mcpToolsConsent: null,
 		});
 
+		await syncDeclaredStorageIndexes(db, [bundle.manifest]);
+
 		// Best-effort cleanup of the old bundle. Failures here don't roll
 		// back the upgrade (the new bundle is already stored and committed
 		// in the state row); the orphan is just storage we'll pay for.

package/src/api/handlers/revision.ts

@@ -4,6 +4,7 @@
 
 import type { Kysely } from "kysely";
 
+import { after } from "../../after.js";
 import { ContentRepository } from "../../database/repositories/content.js";
 import { RevisionRepository, type Revision } from "../../database/repositories/revision.js";
 import { withTransaction } from "../../database/transaction.js";
@@ -115,7 +116,7 @@ export async function handleRevisionRestore(
 		// Atomically update content and create a new revision to record the restore.
 		// If either operation fails, neither is committed (on engines that support
 		// transactions; on D1, withTransaction falls back to sequential execution).
-		const item = await withTransaction(db, async (trx) => {
+		const { item, queuedRevisionId } = await withTransaction(db, async (trx) => {
 			const trxContentRepo = new ContentRepository(trx);
 			const trxRevisionRepo = new RevisionRepository(trx);
 
@@ -124,19 +125,32 @@ export async function handleRevisionRestore(
 				slug: typeof _slug === "string" ? _slug : undefined,
 			});
 
-			await trxRevisionRepo.create({
+			const queuedRevision = await trxRevisionRepo.create({
 				collection: revision.collection,
 				entryId: revision.entryId,
 				data: revision.data,
 				authorId: callerUserId,
 			});
 
-			return updated;
+			return { item: updated, queuedRevisionId: queuedRevision.id };
 		});
 
-		// Fire-and-forget: prune old revisions to prevent unbounded growth
 		const pruneRepo = new RevisionRepository(db);
-		void pruneRepo.pruneOldRevisions(revision.collection, revision.entryId, 50).catch(() => {});
+		after(async () => {
+			try {
+				await pruneRepo.pruneQueuedEntry(
+					revision.collection,
+					revision.entryId,
+					queuedRevisionId,
+					50,
+				);
+			} catch (error) {
+				console.error(
+					`[revisions] Failed to prune revisions for ${revision.collection}/${revision.entryId}:`,
+					error,
+				);
+			}
+		});
 
 		return {
 			success: true,

package/src/api/handlers/schema.ts

@@ -423,6 +423,43 @@ export async function handleSchemaFieldDelete(
 	}
 }
 
+/**
+ * Reorder collections in the admin sidebar
+ */
+export async function handleSchemaCollectionReorder(
+	db: Kysely<Database>,
+	slugs: string[],
+): Promise<ApiResult<{ success: boolean }>> {
+	try {
+		const registry = new SchemaRegistry(db);
+		await registry.reorderCollections(slugs);
+
+		return {
+			success: true,
+			data: { success: true },
+		};
+	} catch (error) {
+		if (error instanceof SchemaError) {
+			return {
+				success: false,
+				error: {
+					code: error.code,
+					message: error.message,
+					details: error.details,
+				},
+			};
+		}
+		console.error("[emdash] Failed to reorder collections:", error);
+		return {
+			success: false,
+			error: {
+				code: "SCHEMA_COLLECTION_REORDER_ERROR",
+				message: "Failed to reorder collections",
+			},
+		};
+	}
+}
+
 /**
  * Reorder fields
  */

package/src/api/handlers/snapshot.ts

@@ -312,7 +312,7 @@ export async function generateSnapshot(
 						await sql<Record<string, unknown>>`
 						SELECT * FROM ${sql.raw(`"${tableName}"`)}
 						WHERE deleted_at IS NULL
-						AND (status = 'published' OR (status = 'scheduled' AND scheduled_at <= strftime('%Y-%m-%dT%H:%M:%fZ', 'now')))
+						AND status = 'published'
 					`.execute(db)
 					).rows;
 				}

package/src/api/handlers/taxonomies.ts

@@ -10,7 +10,7 @@
 import type { Kysely, Selectable } from "kysely";
 import { ulid } from "ulidx";
 
-import { TaxonomyRepository } from "../../database/repositories/taxonomy.js";
+import { TaxonomyRepository, type SiblingPosition } from "../../database/repositories/taxonomy.js";
 import type { Database, TaxonomyDefTable } from "../../database/types.js";
 import { resolveConfiguredLocale } from "../../i18n/config.js";
 import { invalidateTaxonomyDefsCache, invalidateTermCache } from "../../taxonomies/index.js";
@@ -50,7 +50,8 @@ export interface TermData {
 }
 
 export interface TermWithCount extends TermData {
-	count: number;
+	/** Absent when the caller opted out of counts (`includeCounts: false`). */
+	count?: number;
 	children: TermWithCount[];
 }
 
@@ -58,6 +59,10 @@ export interface TermListResponse {
 	terms: TermWithCount[];
 }
 
+export interface TermReorderResponse {
+	reordered: true;
+}
+
 export interface TermResponse {
 	term: TermData;
 }
@@ -384,7 +389,7 @@ export async function handleTaxonomyDefTranslations(
 export async function handleTermList(
 	db: Kysely<Database>,
 	taxonomyName: string,
-	options: { locale?: string } = {},
+	options: { locale?: string; includeCounts?: boolean } = {},
 ): Promise<ApiResult<TermListResponse>> {
 	try {
 		// Definitions are per-locale but terms aren't bound to the def's locale —
@@ -401,11 +406,10 @@ export async function handleTermList(
 		// taxonomy's declared collections — one query for the whole list.
 		// content_taxonomies.taxonomy_id stores the translation_group, so we
 		// look up by group and map back to each term's id.
-		const countsByGroup = await fetchVisibleTermCounts(
-			db,
-			taxonomyName,
-			defCollections(lookup.def),
-		);
+		const includeCounts = options.includeCounts ?? true;
+		const countsByGroup = includeCounts
+			? await fetchVisibleTermCounts(db, taxonomyName, defCollections(lookup.def))
+			: undefined;
 
 		const termData: TermWithCount[] = terms.map((term) => ({
 			id: term.id,
@@ -415,7 +419,7 @@ export async function handleTermList(
 			parentId: term.parentId,
 			description: typeof term.data?.description === "string" ? term.data.description : undefined,
 			children: [],
-			count: countsByGroup.get(term.translationGroup ?? term.id) ?? 0,
+			...(countsByGroup && { count: countsByGroup.get(term.translationGroup ?? term.id) ?? 0 }),
 			locale: term.locale,
 			translationGroup: term.translationGroup,
 		}));
@@ -423,7 +427,8 @@ export async function handleTermList(
 		const isHierarchical = lookup.def.hierarchical === 1;
 		const result = isHierarchical ? buildTree(termData) : termData;
 		return { success: true, data: { terms: result } };
-	} catch {
+	} catch (error) {
+		console.error("[taxonomies] term list failed:", error);
 		return {
 			success: false,
 			error: { code: "TERM_LIST_ERROR", message: "Failed to list terms" },
@@ -431,6 +436,102 @@ export async function handleTermList(
 	}
 }
 
+/**
+ * Set the manual order of one sibling group.
+ *
+ * `ids` names the terms to move, in the desired order; each is a row id or a
+ * translation_group and resolves to the latter, because a position belongs to a
+ * term rather than to one of its locales. Reordering never reparents — moving a
+ * term under a different parent is a term update.
+ *
+ * The group is `(taxonomy, parentId)` and has no locale: `parentId` is the
+ * parent's translation_group (a row id is accepted and resolved), and `null`
+ * selects the top level — which for a flat taxonomy is every term.
+ *
+ * `ids` may be a *subset* of the group, and the listed terms are permuted
+ * within the positions they already occupy. A locale only renders the terms
+ * translated into it, so a caller often cannot name every member; a member left
+ * out keeps its place, which is also what makes a stale list harmless.
+ */
+export async function handleTermReorder(
+	db: Kysely<Database>,
+	taxonomyName: string,
+	input: { parentId?: string | null; ids: string[] },
+): Promise<ApiResult<TermReorderResponse>> {
+	try {
+		const lookup = await requireTaxonomyDef(db, taxonomyName);
+		if (!lookup.success) return lookup;
+
+		const repo = new TaxonomyRepository(db);
+
+		let parentId = input.parentId ?? null;
+		if (parentId !== null) {
+			// Children store the parent's translation_group, so a caller passing a
+			// row id still addresses the right group. A parent whose anchor row is
+			// gone keeps the value as given (see TaxonomyRepository.resolveParentRef).
+			const parent = await repo.findById(parentId);
+			if (parent) parentId = parent.translationGroup ?? parent.id;
+		}
+
+		// Every locale's rows: membership is locale-agnostic, and a term the
+		// caller can't see still holds its slot.
+		// The order carries into how ties are resolved, so it must be stable
+		// across calls; with locales interleaved a tie falls to whichever
+		// locale's label sorts first, not to the order the caller rendered.
+		const members = await repo.findByName(taxonomyName, { parentId });
+		const siblings: SiblingPosition[] = [];
+		const seen = new Set<string>();
+		const resolve = new Map<string, string>();
+		for (const term of members) {
+			const group = term.translationGroup ?? term.id;
+			if (!seen.has(group)) {
+				seen.add(group);
+				siblings.push({ group, position: term.sortOrder });
+			}
+			// Both spellings resolve to the group: a row id, and the group itself for
+			// a caller that already holds one — including when its anchor row is gone
+			// and no member's id matches it.
+			resolve.set(group, group);
+			resolve.set(term.id, group);
+		}
+
+		const groups: string[] = [];
+		for (const id of input.ids) {
+			const group = resolve.get(id);
+			if (!group) {
+				return {
+					success: false,
+					error: {
+						code: "REORDER_MISMATCH",
+						message: `Term "${id}" is not in the sibling group being reordered`,
+					},
+				};
+			}
+			if (groups.includes(group)) {
+				return {
+					success: false,
+					error: {
+						code: "REORDER_MISMATCH",
+						message: `Term "${id}" is listed more than once`,
+					},
+				};
+			}
+			groups.push(group);
+		}
+
+		await repo.reorder(groups, siblings);
+		invalidateTermCache();
+
+		return { success: true, data: { reordered: true } };
+	} catch (error) {
+		console.error("[taxonomies] term reorder failed:", error);
+		return {
+			success: false,
+			error: { code: "TERM_REORDER_ERROR", message: "Failed to reorder terms" },
+		};
+	}
+}
+
 /**
  * Validate a parent term reference for create/update.
  *

package/src/api/openapi/document.ts

@@ -54,6 +54,7 @@ import {
 	mediaListResponseSchema,
 	mediaReadResponseSchema,
 	mediaResponseSchema,
+	mediaStreamUploadResponseSchema,
 	mediaUpdateBody,
 	mediaUploadUrlBody,
 	mediaUploadUrlResponseSchema,
@@ -87,6 +88,7 @@ import {
 	createCollectionBody,
 	createFieldBody,
 	fieldListResponseSchema,
+	collectionReorderBody,
 	fieldReorderBody,
 	fieldResponseSchema,
 	orphanedTableListResponseSchema,
@@ -111,9 +113,12 @@ import {
 import { settingsUpdateBody, siteSettingsSchema } from "../schemas/settings.js";
 import {
 	createTermBody,
+	reorderTermsBody,
 	taxonomyListResponseSchema,
 	termGetResponseSchema,
+	termListQuery,
 	termListResponseSchema,
+	termReorderResponseSchema,
 	termResponseSchema,
 	updateTermBody,
 } from "../schemas/taxonomies.js";
@@ -788,9 +793,9 @@ function buildMediaPaths(maxUploadSize: number) {
 		"/_emdash/api/media/upload-url": {
 			post: {
 				operationId: "getMediaUploadUrl",
-				summary: "Get a signed URL for direct upload",
+				summary: "Get a media upload target",
 				description:
-					"Returns a signed URL for direct-to-storage upload. Creates a pending media record.",
+					"Returns either a signed direct-to-storage URL or a same-origin streaming target. Creates a pending media record.",
 				tags: ["Media"],
 				requestBody: { content: { [JSON_CONTENT]: { schema: mediaUploadUrlBody(maxUploadSize) } } },
 				responses: {
@@ -827,7 +832,37 @@ function buildMediaPaths(maxUploadSize: number) {
 						},
 					},
 					...authErrors,
-					...standardErrors(400, 404, 500),
+					...standardErrors(400, 404, 409, 500),
+				},
+			},
+		},
+		"/_emdash/api/media/{id}/upload": {
+			put: {
+				operationId: "uploadPendingMedia",
+				summary: "Upload a pending media file through EmDash",
+				description:
+					"Streams a file to storage when the configured adapter cannot provide a signed upload URL. The Content-Type and byte count must match the pending media item.",
+				tags: ["Media"],
+				requestParams: {
+					path: z.object({ id: z.string().meta({ description: "Media ID" }) }),
+				},
+				requestBody: {
+					required: true,
+					content: {
+						"*/*": {
+							schema: z.string().meta({ format: "binary" }),
+						},
+					},
+				},
+				responses: {
+					"200": {
+						description: "File uploaded and ready for confirmation",
+						content: {
+							[JSON_CONTENT]: { schema: successEnvelope(mediaStreamUploadResponseSchema) },
+						},
+					},
+					...authErrors,
+					...standardErrors(400, 404, 413, 500),
 				},
 			},
 		},
@@ -1030,6 +1065,28 @@ const schemaPaths = {
 			},
 		},
 	},
+	"/_emdash/api/schema/collections/reorder": {
+		post: {
+			operationId: "reorderCollections",
+			summary: "Reorder collections in the admin sidebar",
+			description:
+				"Sets the sidebar order. Collections omitted from the list lose their explicit position and fall back to alphabetical order after the ordered ones.",
+			tags: ["Schema"],
+			requestBody: { content: { [JSON_CONTENT]: { schema: collectionReorderBody } } },
+			responses: {
+				"200": {
+					description: "Reordered",
+					content: {
+						[JSON_CONTENT]: {
+							schema: successEnvelope(z.object({ success: z.literal(true) })),
+						},
+					},
+				},
+				...authErrors,
+				...standardErrors(400, 404, 500),
+			},
+		},
+	},
 	"/_emdash/api/schema/collections/{slug}/fields/reorder": {
 		post: {
 			operationId: "reorderFields",
@@ -1288,6 +1345,29 @@ const taxonomyPaths = {
 			},
 		},
 	},
+	"/_emdash/api/taxonomies/{name}/reorder": {
+		post: {
+			operationId: "reorderTerms",
+			summary: "Set the manual order of one sibling group of terms",
+			description:
+				"`ids` names the terms to move, in the desired order, and may be a subset of the group — the listed terms are permuted within the positions they already occupy. A position belongs to a term across every locale, so there is no `locale` parameter. Ordering never reparents — use the term update endpoint to change a parent.",
+			tags: ["Taxonomies"],
+			requestParams: {
+				path: z.object({ name: z.string().meta({ description: "Taxonomy name" }) }),
+			},
+			requestBody: { content: { [JSON_CONTENT]: { schema: reorderTermsBody } } },
+			responses: {
+				"200": {
+					description: "The group in its new order",
+					content: {
+						[JSON_CONTENT]: { schema: successEnvelope(termReorderResponseSchema) },
+					},
+				},
+				...authErrors,
+				...standardErrors(400, 404, 500),
+			},
+		},
+	},
 	"/_emdash/api/taxonomies/{name}/terms": {
 		get: {
 			operationId: "listTerms",
@@ -1296,6 +1376,7 @@ const taxonomyPaths = {
 			tags: ["Taxonomies"],
 			requestParams: {
 				path: z.object({ name: z.string().meta({ description: "Taxonomy name" }) }),
+				query: termListQuery,
 			},
 			responses: {
 				"200": {

package/src/api/public-url.ts

@@ -10,7 +10,7 @@
  */
 
 /** Minimal config shape — avoids importing the full EmDashConfig type tree. */
-interface SiteUrlConfig {
+export interface SiteUrlConfig {
 	siteUrl?: string;
 }
 
@@ -74,7 +74,19 @@ function getEnvSiteUrl(): string | undefined {
  * @returns Origin string, e.g. `"https://mysite.example.com"`
  */
 export function getPublicOrigin(url: URL, config?: SiteUrlConfig): string {
-	return config?.siteUrl || getEnvSiteUrl() || url.origin;
+	return getConfiguredOrigin(config) || url.origin;
+}
+
+/**
+ * Return the operator-configured public origin, if any.
+ *
+ * The first two steps of {@link getPublicOrigin}'s resolution —
+ * `config.siteUrl`, then the `EMDASH_SITE_URL`/`SITE_URL` env vars — without
+ * the request-URL fallback. For callers that have a more trustworthy fallback
+ * than the request (e.g. the stored setup origin used for outbound emails).
+ */
+export function getConfiguredOrigin(config?: SiteUrlConfig): string | undefined {
+	return config?.siteUrl || getEnvSiteUrl() || undefined;
 }
 
 /**

package/src/api/schemas/media.ts

@@ -74,7 +74,7 @@ export function mediaUploadUrlBody(maxSize: number) {
 			size: z
 				.number()
 				.int()
-				.positive()
+				.nonnegative()
 				.max(maxSize, `File size must not exceed ${formatFileSize(maxSize)}`),
 			contentHash: z.string().optional(),
 			fieldId: z.string().optional(),
@@ -84,7 +84,7 @@ export function mediaUploadUrlBody(maxSize: number) {
 
 export const mediaConfirmBody = z
 	.object({
-		size: z.number().int().positive().optional(),
+		size: z.number().int().nonnegative().optional(),
 		width: z.number().int().positive().optional(),
 		height: z.number().int().positive().optional(),
 	})
@@ -178,3 +178,10 @@ export const mediaConfirmResponseSchema = z
 		item: mediaItemSchema.extend({ url: z.string() }),
 	})
 	.meta({ id: "MediaConfirmResponse" });
+
+export const mediaStreamUploadResponseSchema = z
+	.object({
+		uploaded: z.literal(true),
+		size: z.number().int().nonnegative(),
+	})
+	.meta({ id: "MediaStreamUploadResponse" });