@headless-lms/core 0.4.0 → 0.6.0

package/dist/content/service.js

@@ -2,6 +2,8 @@ import { spaceSettingsDefaults } from "../types/schemas/content.js";
 import { ConflictError, ForbiddenError, InvalidInputError, NotFoundError } from "../shared/errors.js";
 import { noopLogger } from "../shared/logger.js";
 import { contentEvents } from "./events.js";
+import { EVENT_LEADS, EVENT_STARTING_SOON_JOB } from "./jobs.js";
+import { isDeepStrictEqual } from "node:util";
 //#region src/content/service.ts
 /** URL-safe slug derived from a title. Domain rule owned by the service. */
 function slugify(title) {
@@ -11,10 +13,35 @@ function isPublishedActivity(settings) {
 	return settings?.published !== false;
 }
 function actorMetadata(actor) {
-	return { actorOrgUserId: actor.id };
+	return { actorId: actor.id };
 }
-function assertConfigurator(actor) {
-	if (actor.role !== "owner" && actor.role !== "admin") throw new ForbiddenError("Only an owner or an admin can configure a community");
+const COMMUNITY_READERS = ["communities:read", "communities:moderate"];
+function eventChange(actor, previous, next) {
+	return {
+		actorId: actor.id,
+		previousStatus: previous.status,
+		previousType: previous.settings.type,
+		previousStartsAt: previous.startsAt.toISOString(),
+		previousEndsAt: previous.endsAt.toISOString(),
+		locationChanged: !isDeepStrictEqual(previous.location, next.location)
+	};
+}
+function assertEventTimes(startsAt, endsAt) {
+	if (endsAt.getTime() <= startsAt.getTime()) throw new InvalidInputError("An event must end after it starts");
+}
+function startingSoonKey(eventId, lead) {
+	return `${eventId}:${lead}`;
+}
+const EVENT_LEAD_KEYS = Object.keys(EVENT_LEADS);
+function shownPublicly(item) {
+	return item.status === "published" || item.type === "event" && item.status === "canceled";
+}
+function spaceImageIds(space) {
+	return [
+		space.coverAssetId,
+		space.backgroundAssetId,
+		space.iconAssetId
+	].filter((id) => id !== null);
 }
 function sameIdSet(current, requested) {
 	if (current.length !== requested.length) return false;
@@ -27,6 +54,7 @@ var ContentService = class {
 	libraryAssets;
 	files;
 	fileUrls;
+	scheduler;
 	logger;
 	constructor(params) {
 		this.repo = params.repo;
@@ -34,14 +62,67 @@ var ContentService = class {
 		this.libraryAssets = params.libraryAssets;
 		this.files = params.files;
 		this.fileUrls = params.fileUrls;
+		this.scheduler = params.scheduler;
 		this.logger = params.logger ?? noopLogger;
 	}
+	require(actor, permission, on) {
+		this.requireAny(actor, [permission], on);
+	}
+	requireAny(actor, permissions, on) {
+		if (!permissions.some((permission) => actor.permissions.has(permission, on))) {
+			this.logger.warn("content action refused", {
+				orgId: actor.orgId,
+				actorId: actor.id,
+				permission: permissions.join(" or "),
+				contentId: on
+			});
+			throw new ForbiddenError(`You need ${permissions.join(" or ")}`);
+		}
+	}
+	visibleIds(actor, permissions, what) {
+		const wheres = permissions.map((permission) => actor.permissions.where(permission));
+		if (wheres.some((where) => where.org)) return;
+		const ids = [...new Set(wheres.flatMap((where) => where.content))];
+		if (ids.length === 0) {
+			this.logger.warn("content list refused", {
+				orgId: actor.orgId,
+				actorId: actor.id,
+				permission: permissions.join(" or ")
+			});
+			throw new ForbiddenError(`You cannot see ${what}`);
+		}
+		return ids;
+	}
 	withThumbnail(item) {
 		return {
 			...item,
-			thumbnailUrl: item.thumbnailAssetId ? this.fileUrls.thumbnail(item.type, item.id) : null
+			thumbnailUrl: !item.thumbnailAssetId ? null : shownPublicly(item) ? this.fileUrls.publicImage(item.orgId, item.id, item.thumbnailAssetId) : this.fileUrls.thumbnail(item.type, item.id)
 		};
 	}
+	syncThumbnail(item) {
+		return this.files.syncPublicImages(item.orgId, item.id, shownPublicly(item) && item.thumbnailAssetId ? [item.thumbnailAssetId] : []);
+	}
+	withdrawThumbnail(orgId, id) {
+		return this.files.syncPublicImages(orgId, id, []);
+	}
+	spaceView(space, published) {
+		const url = (image, assetId) => !assetId ? null : published ? this.fileUrls.publicImage(space.orgId, space.id, assetId) : this.fileUrls.spaceImage(space.id, image);
+		return {
+			...space,
+			coverUrl: url("cover", space.coverAssetId),
+			backgroundUrl: url("background", space.backgroundAssetId),
+			iconUrl: url("icon", space.iconAssetId)
+		};
+	}
+	async communityPublished(orgId, communityId) {
+		return (await this.repo.findCommunityById(orgId, communityId))?.status === "published";
+	}
+	async oneSpaceView(space) {
+		return this.spaceView(space, await this.communityPublished(space.orgId, space.communityId));
+	}
+	syncSpaceImages(space, published) {
+		return this.files.syncPublicImages(space.orgId, space.id, published ? spaceImageIds(space) : []);
+	}
 	pageWithThumbnails(page) {
 		return {
 			...page,
@@ -59,14 +140,76 @@ var ContentService = class {
 			}] : [];
 		});
 	}
-	async listCourses(orgId, query) {
-		return this.pageWithThumbnails(await this.repo.listCourses(orgId, query));
+	async eventFiles(orgId, links) {
+		const ready = await this.files.readyFiles(orgId, links.map((link) => link.assetId));
+		return links.flatMap((link) => {
+			const file = ready[link.assetId];
+			return file ? [{
+				...link,
+				...file,
+				url: this.fileUrls.eventFile(link.eventId, link.assetId)
+			}] : [];
+		});
+	}
+	async assertAttachable(actor, itemId, requested, attached, user) {
+		const ids = [...new Set(requested.filter((id) => typeof id === "string"))];
+		if (ids.length === 0) return;
+		const held = new Set(await attached());
+		const added = ids.filter((id) => !held.has(id));
+		if (added.length === 0) return;
+		const orgId = actor.orgId;
+		const found = new Map((await this.libraryAssets.libraryAssetsFor(orgId, added)).map((asset) => [asset.id, asset]));
+		const missing = added.filter((id) => !found.has(id));
+		if (missing.length > 0) {
+			this.logger.warn("library assets refused", {
+				orgId,
+				contentId: itemId,
+				assetIds: missing
+			});
+			throw new ConflictError(`${user} can only use ready files from the media library. Not available: ${missing.join(", ")}`);
+		}
+		if (actor.permissions.has("media:read")) return;
+		const foreign = added.filter((id) => found.get(id)?.contentId !== itemId);
+		if (foreign.length > 0) {
+			this.logger.warn("library assets refused — not uploaded for this item", {
+				orgId,
+				actorId: actor.id,
+				contentId: itemId,
+				assetIds: foreign
+			});
+			throw new ForbiddenError(`You need media:read to use files that were not uploaded for this item: ${foreign.join(", ")}`);
+		}
+	}
+	async courseAssetIds(orgId, courseId) {
+		const [course, links] = await Promise.all([this.repo.findCourseById(orgId, courseId), this.repo.listActivityAssetsForCourse(orgId, courseId)]);
+		return [course?.thumbnailAssetId ?? null, ...links.map((link) => link.assetId)];
+	}
+	async downloadAssetIds(orgId, downloadId) {
+		const [download, links] = await Promise.all([this.repo.getDownload(orgId, downloadId), this.repo.listDownloadAssets(orgId, downloadId)]);
+		return [download?.thumbnailAssetId ?? null, ...links.map((link) => link.assetId)];
+	}
+	async eventAssetIds(orgId, eventId) {
+		const [event, links] = await Promise.all([this.repo.findEventById(orgId, eventId), this.repo.listEventAssets(orgId, eventId)]);
+		if (!event) throw new NotFoundError("Event", eventId);
+		return [event.thumbnailAssetId, ...links.map((link) => link.assetId)];
+	}
+	async listCourses(query, actor) {
+		const ids = this.visibleIds(actor, ["courses:read"], "courses");
+		return this.pageWithThumbnails(await this.repo.listCourses(actor.orgId, query, ids));
+	}
+	async getCourse(id, actor) {
+		const course = await this.findCourse(id, actor);
+		if (!course) throw new NotFoundError("Course", id);
+		return course;
 	}
-	async getCourse(orgId, id) {
-		const course = await this.repo.findCourseById(orgId, id);
+	async findCourse(id, actor) {
+		this.require(actor, "courses:read", id);
+		const course = await this.repo.findCourseById(actor.orgId, id);
 		return course ? this.withThumbnail(course) : null;
 	}
-	async createCourse(orgId, input) {
+	async createCourse(input, actor) {
+		this.require(actor, "courses:write");
+		const orgId = actor.orgId;
 		const course = await this.uow.run(async ({ content, outbox }) => {
 			const created = await content.createCourse(orgId, input, slugify(input.title));
 			await outbox.append([contentEvents.courseCreated.make({
@@ -78,12 +221,15 @@ var ContentService = class {
 		this.logger.info("course created", {
 			orgId,
 			courseId: course.id,
-			title: course.title
+			title: course.title,
+			actorId: actor.id
 		});
 		return this.withThumbnail(course);
 	}
-	async updateCourse(orgId, id, patch) {
-		await this.assertLibraryAssets(orgId, [patch.thumbnailAssetId], "A course");
+	async updateCourse(id, patch, actor) {
+		this.require(actor, "courses:write", id);
+		const orgId = actor.orgId;
+		await this.assertAttachable(actor, id, [patch.thumbnailAssetId], () => this.courseAssetIds(orgId, id), "A course");
 		const course = await this.uow.run(async ({ content, outbox }) => {
 			const updated = await content.updateCourse(orgId, id, patch);
 			if (!updated) {
@@ -102,11 +248,15 @@ var ContentService = class {
 		this.logger.info("course updated", {
 			orgId,
 			courseId: id,
-			fields: Object.keys(patch)
+			fields: Object.keys(patch),
+			actorId: actor.id
 		});
+		await this.syncThumbnail(course);
 		return this.withThumbnail(course);
 	}
-	async patchCourseSettings(orgId, id, value) {
+	async patchCourseSettings(id, value, actor) {
+		this.require(actor, "courses:write", id);
+		const orgId = actor.orgId;
 		const merged = await this.uow.run(async ({ content, outbox }) => {
 			const course = await content.findCourseById(orgId, id);
 			if (!course) {
@@ -129,11 +279,14 @@ var ContentService = class {
 		this.logger.info("course settings patched", {
 			orgId,
 			courseId: id,
-			value
+			value,
+			actorId: actor.id
 		});
 		return merged;
 	}
-	async deleteCourse(orgId, id, actor) {
+	async deleteCourse(id, actor) {
+		this.require(actor, "courses:delete", id);
+		const orgId = actor.orgId;
 		await this.uow.run(async ({ content, outbox }) => {
 			const course = await content.findCourseById(orgId, id);
 			if (!course) {
@@ -152,32 +305,44 @@ var ContentService = class {
 		});
 		this.logger.info("course deleted", {
 			orgId,
-			courseId: id
+			courseId: id,
+			actorId: actor.id
 		});
+		await this.withdrawThumbnail(orgId, id);
 	}
-	listCourseModules(orgId, courseId) {
-		return this.repo.listCourseModules(orgId, courseId);
+	async listCourseModules(courseId, actor) {
+		this.require(actor, "courses:read", courseId);
+		return this.repo.listCourseModules(actor.orgId, courseId);
 	}
-	listCourseActivities(orgId, courseId) {
-		return this.repo.listActivitiesForCourse(orgId, courseId);
+	async listCourseActivities(courseId, actor) {
+		this.require(actor, "courses:read", courseId);
+		return this.repo.listActivitiesForCourse(actor.orgId, courseId);
 	}
-	async listCourseActivityViews(orgId, courseId) {
-		const [activities, links] = await Promise.all([this.repo.listActivitiesForCourse(orgId, courseId), this.repo.listActivityAssetsForCourse(orgId, courseId)]);
+	async listCourseActivityViews(courseId, actor) {
+		this.require(actor, "courses:read", courseId);
+		const [activities, links] = await Promise.all([this.repo.listActivitiesForCourse(actor.orgId, courseId), this.repo.listActivityAssetsForCourse(actor.orgId, courseId)]);
 		return activities.map((activity) => ({
 			...activity,
 			assetUrls: Object.fromEntries(links.filter((link) => link.activityId === activity.id).map((link) => [link.assetId, this.fileUrls.activityAsset(activity.id, link.assetId)]))
 		}));
 	}
-	listCourseActivityAssets(orgId, courseId) {
-		return this.repo.listActivityAssetsForCourse(orgId, courseId);
+	async listCourseActivityAssets(courseId, actor) {
+		this.require(actor, "courses:read", courseId);
+		return this.repo.listActivityAssetsForCourse(actor.orgId, courseId);
 	}
-	getActivity(orgId, activityId) {
-		return this.repo.findActivity(orgId, activityId);
+	async getActivity(activityId, actor) {
+		const activity = await this.repo.findActivity(actor.orgId, activityId);
+		if (activity) this.require(actor, "courses:read", activity.courseId);
+		return activity;
 	}
-	getModule(orgId, moduleId) {
-		return this.repo.findModule(orgId, moduleId);
+	async getModule(moduleId, actor) {
+		const module = await this.repo.findModule(actor.orgId, moduleId);
+		if (module) this.require(actor, "courses:read", module.courseId);
+		return module;
 	}
-	async reorderModules(orgId, courseId, orderedIds) {
+	async reorderModules(courseId, orderedIds, actor) {
+		this.require(actor, "courses:write", courseId);
+		const orgId = actor.orgId;
 		const modules = await this.uow.run(async ({ content, outbox }) => {
 			const reordered = await content.reorderModules(orgId, courseId, orderedIds);
 			await outbox.append([contentEvents.modulesReordered.make({
@@ -193,7 +358,9 @@ var ContentService = class {
 		});
 		return modules;
 	}
-	async createModule(orgId, courseId, title) {
+	async createModule(courseId, title, actor) {
+		this.require(actor, "courses:write", courseId);
+		const orgId = actor.orgId;
 		const { modules, created } = await this.uow.run(async ({ content, outbox }) => {
 			const all = await content.createModule(orgId, courseId, title);
 			const module = all.at(-1);
@@ -211,11 +378,14 @@ var ContentService = class {
 			orgId,
 			courseId,
 			moduleId: created.id,
-			title
+			title,
+			actorId: actor.id
 		});
 		return modules;
 	}
-	async updateModule(orgId, courseId, moduleId, title) {
+	async updateModule(courseId, moduleId, title, actor) {
+		this.require(actor, "courses:write", courseId);
+		const orgId = actor.orgId;
 		const modules = await this.uow.run(async ({ content, outbox }) => {
 			const existing = await content.findModule(orgId, moduleId);
 			if (!existing || existing.courseId !== courseId) {
@@ -239,11 +409,14 @@ var ContentService = class {
 			orgId,
 			courseId,
 			moduleId,
-			title
+			title,
+			actorId: actor.id
 		});
 		return modules;
 	}
-	async deleteModule(orgId, courseId, moduleId) {
+	async deleteModule(courseId, moduleId, actor) {
+		this.require(actor, "courses:write", courseId);
+		const orgId = actor.orgId;
 		const modules = await this.uow.run(async ({ content, outbox }) => {
 			const module = await content.findModule(orgId, moduleId);
 			if (!module || module.courseId !== courseId) {
@@ -264,11 +437,14 @@ var ContentService = class {
 		this.logger.info("module deleted", {
 			orgId,
 			courseId,
-			moduleId
+			moduleId,
+			actorId: actor.id
 		});
 		return modules;
 	}
-	async reorderActivities(orgId, courseId, moduleId, orderedIds) {
+	async reorderActivities(courseId, moduleId, orderedIds, actor) {
+		this.require(actor, "courses:write", courseId);
+		const orgId = actor.orgId;
 		const modules = await this.uow.run(async ({ content, outbox }) => {
 			const reordered = await content.reorderActivities(orgId, courseId, moduleId, orderedIds);
 			const module = reordered.find((m) => m.id === moduleId);
@@ -286,21 +462,10 @@ var ContentService = class {
 		});
 		return modules;
 	}
-	async assertLibraryAssets(orgId, assetIds, user = "An activity") {
-		const ids = assetIds.filter((id) => typeof id === "string");
-		if (ids.length === 0) return;
-		const library = new Set(await this.libraryAssets.libraryAssetsAmong(orgId, ids));
-		const refused = ids.filter((id) => !library.has(id));
-		if (refused.length > 0) {
-			this.logger.warn("library assets refused", {
-				orgId,
-				assetIds: refused
-			});
-			throw new ConflictError(`${user} can only use ready files from the media library. Not available: ${refused.join(", ")}`);
-		}
-	}
-	async saveActivity(orgId, courseId, moduleId, input, activityId) {
-		await this.assertLibraryAssets(orgId, input.assetIds ?? []);
+	async saveActivity(courseId, moduleId, input, activityId, actor) {
+		this.require(actor, "courses:write", courseId);
+		const orgId = actor.orgId;
+		await this.assertAttachable(actor, courseId, input.assetIds ?? [], () => this.courseAssetIds(orgId, courseId), "An activity");
 		const { modules, activity } = await this.uow.run(async ({ content, outbox }) => {
 			let wasPublished = false;
 			if (activityId) {
@@ -326,7 +491,7 @@ var ContentService = class {
 					throw new NotFoundError("Module", moduleId);
 				}
 			}
-			const { modules: all, activity: saved } = await content.saveActivity(orgId, courseId, moduleId, input, activityId);
+			const { modules: all, activity: saved } = await content.saveActivity(orgId, courseId, moduleId, input, activityId ?? void 0);
 			const events = [activityId ? contentEvents.activityUpdated.make({
 				orgId,
 				data: saved
@@ -354,11 +519,14 @@ var ContentService = class {
 			orgId,
 			courseId,
 			moduleId,
-			activityId: activity.id
+			activityId: activity.id,
+			actorId: actor.id
 		});
 		return modules;
 	}
-	async deleteActivity(orgId, courseId, moduleId, activityId) {
+	async deleteActivity(courseId, moduleId, activityId, actor) {
+		this.require(actor, "courses:write", courseId);
+		const orgId = actor.orgId;
 		const modules = await this.uow.run(async ({ content, outbox }) => {
 			const activity = await content.findActivity(orgId, activityId);
 			if (!activity || activity.moduleId !== moduleId || activity.courseId !== courseId) {
@@ -381,18 +549,28 @@ var ContentService = class {
 			orgId,
 			courseId,
 			moduleId,
-			activityId
+			activityId,
+			actorId: actor.id
 		});
 		return modules;
 	}
-	async listDownloads(orgId, query) {
-		return this.pageWithThumbnails(await this.repo.listDownloads(orgId, query));
+	async listDownloads(query, actor) {
+		const ids = this.visibleIds(actor, ["downloads:read"], "downloads");
+		return this.pageWithThumbnails(await this.repo.listDownloads(actor.orgId, query, ids));
+	}
+	async getDownload(id, actor) {
+		const download = await this.findDownload(id, actor);
+		if (!download) throw new NotFoundError("Download", id);
+		return download;
 	}
-	async getDownload(orgId, id) {
-		const download = await this.repo.getDownload(orgId, id);
+	async findDownload(id, actor) {
+		this.require(actor, "downloads:read", id);
+		const download = await this.repo.getDownload(actor.orgId, id);
 		return download ? this.withThumbnail(download) : null;
 	}
-	async createDownload(orgId, input) {
+	async createDownload(input, actor) {
+		this.require(actor, "downloads:write");
+		const orgId = actor.orgId;
 		const download = await this.uow.run(async ({ content, outbox }) => {
 			const created = await content.createDownload(orgId, input, slugify(input.title));
 			await outbox.append([contentEvents.downloadCreated.make({
@@ -404,12 +582,15 @@ var ContentService = class {
 		this.logger.info("download created", {
 			orgId,
 			downloadId: download.id,
-			title: download.title
+			title: download.title,
+			actorId: actor.id
 		});
 		return this.withThumbnail(download);
 	}
-	async updateDownload(orgId, id, patch) {
-		await this.assertLibraryAssets(orgId, [patch.thumbnailAssetId], "A download");
+	async updateDownload(id, patch, actor) {
+		this.require(actor, "downloads:write", id);
+		const orgId = actor.orgId;
+		await this.assertAttachable(actor, id, [patch.thumbnailAssetId], () => this.downloadAssetIds(orgId, id), "A download");
 		const download = await this.uow.run(async ({ content, outbox }) => {
 			const updated = await content.updateDownload(orgId, id, patch);
 			if (!updated) {
@@ -428,11 +609,15 @@ var ContentService = class {
 		this.logger.info("download updated", {
 			orgId,
 			downloadId: id,
-			fields: Object.keys(patch)
+			fields: Object.keys(patch),
+			actorId: actor.id
 		});
+		await this.syncThumbnail(download);
 		return this.withThumbnail(download);
 	}
-	async removeDownload(orgId, id, actor) {
+	async removeDownload(id, actor) {
+		this.require(actor, "downloads:delete", id);
+		const orgId = actor.orgId;
 		await this.uow.run(async ({ content, outbox }) => {
 			const download = await content.getDownload(orgId, id);
 			if (!download) {
@@ -451,14 +636,19 @@ var ContentService = class {
 		});
 		this.logger.info("download deleted", {
 			orgId,
-			downloadId: id
+			downloadId: id,
+			actorId: actor.id
 		});
+		await this.withdrawThumbnail(orgId, id);
 	}
-	async listDownloadAssets(orgId, downloadId) {
-		return this.downloadFiles(orgId, await this.repo.listDownloadAssets(orgId, downloadId));
+	async listDownloadAssets(downloadId, actor) {
+		this.require(actor, "downloads:read", downloadId);
+		return this.downloadFiles(actor.orgId, await this.repo.listDownloadAssets(actor.orgId, downloadId));
 	}
-	async addDownloadAsset(orgId, downloadId, input) {
-		await this.assertLibraryAssets(orgId, [input.assetId], "A download");
+	async addDownloadAsset(downloadId, input, actor) {
+		this.require(actor, "downloads:write", downloadId);
+		const orgId = actor.orgId;
+		await this.assertAttachable(actor, downloadId, [input.assetId], () => this.downloadAssetIds(orgId, downloadId), "A download");
 		const assets = await this.uow.run(async ({ content, outbox }) => {
 			const assets = await content.addDownloadAsset(orgId, downloadId, input);
 			await outbox.append([contentEvents.downloadAssetAdded.make({
@@ -473,11 +663,14 @@ var ContentService = class {
 		this.logger.info("download asset added", {
 			orgId,
 			downloadId,
-			assetId: input.assetId
+			assetId: input.assetId,
+			actorId: actor.id
 		});
 		return this.downloadFiles(orgId, assets);
 	}
-	async removeDownloadAsset(orgId, downloadId, assetId) {
+	async removeDownloadAsset(downloadId, assetId, actor) {
+		this.require(actor, "downloads:write", downloadId);
+		const orgId = actor.orgId;
 		const assets = await this.uow.run(async ({ content, outbox }) => {
 			const assets = await content.removeDownloadAsset(orgId, downloadId, assetId);
 			await outbox.append([contentEvents.downloadAssetRemoved.make({
@@ -492,11 +685,14 @@ var ContentService = class {
 		this.logger.info("download asset removed", {
 			orgId,
 			downloadId,
-			assetId
+			assetId,
+			actorId: actor.id
 		});
 		return this.downloadFiles(orgId, assets);
 	}
-	async renameDownloadAsset(orgId, downloadId, assetId, displayName) {
+	async renameDownloadAsset(downloadId, assetId, displayName, actor) {
+		this.require(actor, "downloads:write", downloadId);
+		const orgId = actor.orgId;
 		const assets = await this.uow.run(async ({ content, outbox }) => {
 			const assets = await content.renameDownloadAsset(orgId, downloadId, assetId, displayName);
 			await outbox.append([contentEvents.downloadAssetRenamed.make({
@@ -511,13 +707,16 @@ var ContentService = class {
 		this.logger.info("download asset renamed", {
 			orgId,
 			downloadId,
-			assetId
+			assetId,
+			actorId: actor.id
 		});
 		return this.downloadFiles(orgId, assets);
 	}
 	/** The caller must send the COMPLETE ordered set — a partial list would
 	*  silently unlink whatever it omitted. */
-	async reorderDownloadAssets(orgId, downloadId, assetIds) {
+	async reorderDownloadAssets(downloadId, assetIds, actor) {
+		this.require(actor, "downloads:write", downloadId);
+		const orgId = actor.orgId;
 		const assets = await this.uow.run(async ({ content, outbox }) => {
 			const current = await content.listDownloadAssets(orgId, downloadId);
 			const currentIds = new Set(current.map((a) => a.assetId));
@@ -547,13 +746,330 @@ var ContentService = class {
 		});
 		return this.downloadFiles(orgId, assets);
 	}
-	listBundles(orgId, query) {
-		return this.repo.listBundles(orgId, query);
+	async listEvents(query, actor) {
+		const ids = this.visibleIds(actor, ["events:read"], "events");
+		return this.pageWithThumbnails(await this.repo.listEvents(actor.orgId, query, ids));
+	}
+	async getEvent(id, actor) {
+		const event = await this.findEvent(id, actor);
+		if (!event) throw new NotFoundError("Event", id);
+		return event;
+	}
+	async findEvent(id, actor) {
+		this.require(actor, "events:read", id);
+		const event = await this.repo.findEventById(actor.orgId, id);
+		return event ? this.withThumbnail(event) : null;
+	}
+	async findEvents(ids, actor) {
+		for (const id of ids) this.require(actor, "events:read", id);
+		if (ids.length === 0) return [];
+		return (await this.repo.findEventsByIds(actor.orgId, ids)).map((event) => this.withThumbnail(event));
+	}
+	async createEvent(input, actor) {
+		this.require(actor, "events:write");
+		assertEventTimes(input.startsAt, input.endsAt);
+		const orgId = actor.orgId;
+		const { settings, ...fields } = input;
+		const event = await this.uow.run(async ({ content, outbox }) => {
+			const created = await content.createEvent(orgId, fields);
+			const event = settings ? {
+				...created,
+				settings: await content.patchEventSettings(orgId, created.id, settings)
+			} : created;
+			await outbox.append([contentEvents.eventCreated.make({
+				orgId,
+				data: event,
+				metadata: actorMetadata(actor)
+			})]);
+			return event;
+		});
+		this.logger.info("event created", {
+			orgId,
+			eventId: event.id,
+			title: event.title,
+			actorId: actor.id
+		});
+		return this.withThumbnail(event);
+	}
+	async updateEvent(id, patch, actor) {
+		this.require(actor, "events:write", id);
+		const orgId = actor.orgId;
+		await this.assertAttachable(actor, id, [patch.thumbnailAssetId], () => this.eventAssetIds(orgId, id), "An event");
+		const { settings, ...fields } = patch;
+		const { previous, event } = await this.uow.run(async ({ content, outbox }) => {
+			const previous = await content.findEventById(orgId, id);
+			if (!previous) {
+				this.logger.warn("event update rejected — not found", {
+					orgId,
+					eventId: id
+				});
+				throw new NotFoundError("Event", id);
+			}
+			if (previous.status === "canceled") {
+				this.logger.warn("event update rejected — canceled", {
+					orgId,
+					eventId: id
+				});
+				throw new ConflictError("The event is canceled", "canceled");
+			}
+			assertEventTimes(fields.startsAt ?? previous.startsAt, fields.endsAt ?? previous.endsAt);
+			const updated = await content.updateEvent(orgId, id, fields);
+			if (!updated) throw new NotFoundError("Event", id);
+			const event = settings ? {
+				...updated,
+				settings: await content.patchEventSettings(orgId, id, settings)
+			} : updated;
+			await outbox.append([contentEvents.eventUpdated.make({
+				orgId,
+				data: event,
+				metadata: eventChange(actor, previous, event)
+			})]);
+			return {
+				previous,
+				event
+			};
+		});
+		this.logger.info("event updated", {
+			orgId,
+			eventId: id,
+			fields: Object.keys(patch),
+			actorId: actor.id
+		});
+		await this.scheduleStartingSoon(orgId, previous, event);
+		await this.syncThumbnail(event);
+		return this.withThumbnail(event);
+	}
+	async cancelEvent(id, actor) {
+		this.require(actor, "events:write", id);
+		const orgId = actor.orgId;
+		const event = await this.uow.run(async ({ content, outbox }) => {
+			const previous = await content.findEventById(orgId, id);
+			if (!previous) {
+				this.logger.warn("event cancel rejected — not found", {
+					orgId,
+					eventId: id
+				});
+				throw new NotFoundError("Event", id);
+			}
+			if (previous.status === "canceled") {
+				this.logger.warn("event cancel rejected — already canceled", {
+					orgId,
+					eventId: id
+				});
+				throw new ConflictError("The event is already canceled", "canceled");
+			}
+			const updated = await content.updateEvent(orgId, id, { status: "canceled" });
+			if (!updated) throw new NotFoundError("Event", id);
+			await outbox.append([contentEvents.eventUpdated.make({
+				orgId,
+				data: updated,
+				metadata: eventChange(actor, previous, updated)
+			})]);
+			return updated;
+		});
+		this.logger.info("event canceled", {
+			orgId,
+			eventId: id,
+			actorId: actor.id
+		});
+		await this.cancelStartingSoon(orgId, id);
+		await this.syncThumbnail(event);
+		return this.withThumbnail(event);
+	}
+	async deleteEvent(id, actor) {
+		this.require(actor, "events:delete", id);
+		const orgId = actor.orgId;
+		await this.uow.run(async ({ content, outbox }) => {
+			const event = await content.findEventById(orgId, id);
+			if (!event) {
+				this.logger.warn("event delete rejected — not found", {
+					orgId,
+					eventId: id
+				});
+				throw new NotFoundError("Event", id);
+			}
+			const linked = await content.spacesLinkingContent(orgId, id);
+			if (!await content.deleteEvent(orgId, id)) throw new NotFoundError("Event", id);
+			await content.deleteEventSettings(orgId, id);
+			await outbox.append([contentEvents.eventDeleted.make({
+				orgId,
+				data: event,
+				metadata: actorMetadata(actor)
+			}), ...await this.spaceUpdates(content, orgId, linked, actor)]);
+		});
+		this.logger.info("event deleted", {
+			orgId,
+			eventId: id,
+			actorId: actor.id
+		});
+		await this.withdrawThumbnail(orgId, id);
+		await this.cancelStartingSoon(orgId, id);
+	}
+	async startingSoon(orgId, eventId, lead, now) {
+		const event = await this.repo.findEventById(orgId, eventId);
+		if (!event || event.status !== "published") {
+			this.logger.debug("event no longer published", {
+				orgId,
+				eventId,
+				lead
+			});
+			return;
+		}
+		const due = new Date(event.startsAt.getTime() - EVENT_LEADS[lead]);
+		if (due > now) {
+			await this.scheduler.at(EVENT_STARTING_SOON_JOB, due, startingSoonKey(eventId, lead), {
+				orgId,
+				eventId,
+				lead
+			});
+			this.logger.info("event starting soon timer moved", {
+				orgId,
+				eventId,
+				lead,
+				due: due.toISOString()
+			});
+			return;
+		}
+		await this.uow.run(({ outbox }) => outbox.append([contentEvents.eventStartingSoon.make({
+			orgId,
+			data: {
+				eventId,
+				lead,
+				startsAt: event.startsAt
+			}
+		})]));
+		this.logger.info("event starting soon", {
+			orgId,
+			eventId,
+			lead
+		});
+	}
+	async scheduleStartingSoon(orgId, previous, event) {
+		if (event.status !== "published") {
+			if (previous.status === "published") await this.cancelStartingSoon(orgId, event.id);
+			return;
+		}
+		if (previous.status === "published" && previous.startsAt.getTime() === event.startsAt.getTime()) return;
+		const now = Date.now();
+		for (const lead of EVENT_LEAD_KEYS) {
+			const key = startingSoonKey(event.id, lead);
+			const runAt = new Date(event.startsAt.getTime() - EVENT_LEADS[lead]);
+			try {
+				if (runAt.getTime() > now) await this.scheduler.at(EVENT_STARTING_SOON_JOB, runAt, key, {
+					orgId,
+					eventId: event.id,
+					lead
+				});
+				else await this.scheduler.cancel(EVENT_STARTING_SOON_JOB, key);
+			} catch (err) {
+				this.logger.error("event starting soon timer not set", {
+					orgId,
+					eventId: event.id,
+					lead,
+					err
+				});
+			}
+		}
 	}
-	getBundle(orgId, id) {
-		return this.repo.findBundleById(orgId, id);
+	async cancelStartingSoon(orgId, eventId) {
+		for (const lead of EVENT_LEAD_KEYS) try {
+			await this.scheduler.cancel(EVENT_STARTING_SOON_JOB, startingSoonKey(eventId, lead));
+		} catch (err) {
+			this.logger.warn("event starting soon timer not cancelled", {
+				orgId,
+				eventId,
+				lead,
+				err
+			});
+		}
+	}
+	async listEventAssets(eventId, actor) {
+		this.require(actor, "events:read", eventId);
+		const orgId = actor.orgId;
+		if (!await this.repo.findEventById(orgId, eventId)) throw new NotFoundError("Event", eventId);
+		return this.eventFiles(orgId, await this.repo.listEventAssets(orgId, eventId));
+	}
+	async eventFilesFor(eventIds, actor) {
+		for (const id of eventIds) this.require(actor, "events:read", id);
+		const byEvent = Object.fromEntries(eventIds.map((id) => [id, []]));
+		if (eventIds.length === 0) return byEvent;
+		const files = await this.eventFiles(actor.orgId, await this.repo.listEventAssetsFor(actor.orgId, eventIds));
+		for (const file of files) byEvent[file.eventId]?.push(file);
+		return byEvent;
+	}
+	async addEventAsset(eventId, input, actor) {
+		this.require(actor, "events:write", eventId);
+		const orgId = actor.orgId;
+		await this.assertAttachable(actor, eventId, [input.assetId], () => this.eventAssetIds(orgId, eventId), "An event");
+		const assets = await this.uow.run(({ content }) => content.addEventAsset(orgId, eventId, input));
+		this.logger.info("event asset added", {
+			orgId,
+			eventId,
+			assetId: input.assetId,
+			actorId: actor.id
+		});
+		return this.eventFiles(orgId, assets);
+	}
+	async removeEventAsset(eventId, assetId, actor) {
+		this.require(actor, "events:write", eventId);
+		const orgId = actor.orgId;
+		const assets = await this.uow.run(({ content }) => content.removeEventAsset(orgId, eventId, assetId));
+		this.logger.info("event asset removed", {
+			orgId,
+			eventId,
+			assetId,
+			actorId: actor.id
+		});
+		return this.eventFiles(orgId, assets);
+	}
+	async renameEventAsset(eventId, assetId, displayName, actor) {
+		this.require(actor, "events:write", eventId);
+		const orgId = actor.orgId;
+		const assets = await this.uow.run(({ content }) => content.renameEventAsset(orgId, eventId, assetId, displayName));
+		this.logger.info("event asset renamed", {
+			orgId,
+			eventId,
+			assetId,
+			actorId: actor.id
+		});
+		return this.eventFiles(orgId, assets);
+	}
+	async reorderEventAssets(eventId, assetIds, actor) {
+		this.require(actor, "events:write", eventId);
+		const orgId = actor.orgId;
+		const assets = await this.uow.run(async ({ content }) => {
+			if (!sameIdSet((await content.listEventAssets(orgId, eventId)).map((link) => link.assetId), assetIds)) {
+				this.logger.warn("event asset reorder rejected — id set mismatch", {
+					orgId,
+					eventId,
+					assetIds
+				});
+				throw new ConflictError("Ordered asset ids does not match the event's current assets");
+			}
+			return content.reorderEventAssets(orgId, eventId, assetIds);
+		});
+		this.logger.debug("event assets reordered", {
+			orgId,
+			eventId
+		});
+		return this.eventFiles(orgId, assets);
+	}
+	async listBundles(query, actor) {
+		this.require(actor, "bundles:read");
+		return this.repo.listBundles(actor.orgId, query);
 	}
-	async createBundle(orgId, input) {
+	async getBundle(id, actor) {
+		const bundle = await this.findBundle(id, actor);
+		if (!bundle) throw new NotFoundError("Bundle", id);
+		return bundle;
+	}
+	async findBundle(id, actor) {
+		this.require(actor, "bundles:read");
+		return this.repo.findBundleById(actor.orgId, id);
+	}
+	async createBundle(input, actor) {
+		this.require(actor, "bundles:write");
+		const orgId = actor.orgId;
 		const { bundle, items } = await this.uow.run(async ({ content, outbox }) => {
 			const created = await content.createBundle(orgId, input);
 			const initial = input.contentIds?.length ? await content.listBundleItems(orgId, created.id) : [];
@@ -576,11 +1092,14 @@ var ContentService = class {
 			orgId,
 			bundleId: bundle.id,
 			name: bundle.name,
-			itemCount: items.length
+			itemCount: items.length,
+			actorId: actor.id
 		});
 		return bundle;
 	}
-	async updateBundle(orgId, id, patch) {
+	async updateBundle(id, patch, actor) {
+		this.require(actor, "bundles:write");
+		const orgId = actor.orgId;
 		const bundle = await this.uow.run(async ({ content, outbox }) => {
 			const updated = await content.updateBundle(orgId, id, patch);
 			if (!updated) {
@@ -599,11 +1118,14 @@ var ContentService = class {
 		this.logger.info("bundle updated", {
 			orgId,
 			bundleId: id,
-			fields: Object.keys(patch)
+			fields: Object.keys(patch),
+			actorId: actor.id
 		});
 		return bundle;
 	}
-	async deleteBundle(orgId, id) {
+	async deleteBundle(id, actor) {
+		this.require(actor, "bundles:delete");
+		const orgId = actor.orgId;
 		await this.uow.run(async ({ content, outbox }) => {
 			const bundle = await content.findBundleById(orgId, id);
 			if (!bundle) {
@@ -621,13 +1143,17 @@ var ContentService = class {
 		});
 		this.logger.info("bundle deleted", {
 			orgId,
-			bundleId: id
+			bundleId: id,
+			actorId: actor.id
 		});
 	}
-	listBundleItems(orgId, bundleId) {
-		return this.repo.listBundleItems(orgId, bundleId);
+	async listBundleItems(bundleId, actor) {
+		this.require(actor, "bundles:read");
+		return this.repo.listBundleItems(actor.orgId, bundleId);
 	}
-	async addBundleItem(orgId, bundleId, contentId) {
+	async addBundleItem(bundleId, contentId, actor) {
+		this.require(actor, "bundles:write");
+		const orgId = actor.orgId;
 		const items = await this.uow.run(async ({ content, outbox }) => {
 			const all = await content.addBundleItem(orgId, bundleId, contentId);
 			await outbox.append([contentEvents.bundleItemAdded.make({
@@ -642,11 +1168,14 @@ var ContentService = class {
 		this.logger.info("bundle item added", {
 			orgId,
 			bundleId,
-			contentId
+			contentId,
+			actorId: actor.id
 		});
 		return items;
 	}
-	async removeBundleItem(orgId, bundleId, contentId) {
+	async removeBundleItem(bundleId, contentId, actor) {
+		this.require(actor, "bundles:write");
+		const orgId = actor.orgId;
 		const items = await this.uow.run(async ({ content, outbox }) => {
 			const all = await content.removeBundleItem(orgId, bundleId, contentId);
 			await outbox.append([contentEvents.bundleItemRemoved.make({
@@ -661,7 +1190,8 @@ var ContentService = class {
 		this.logger.info("bundle item removed", {
 			orgId,
 			bundleId,
-			contentId
+			contentId,
+			actorId: actor.id
 		});
 		return items;
 	}
@@ -694,35 +1224,60 @@ var ContentService = class {
 			settings
 		};
 	}
-	async listCommunities(orgId, query) {
-		return this.pageWithThumbnails(await this.repo.listCommunities(orgId, query));
+	async listCommunities(query, actor) {
+		const ids = this.visibleIds(actor, COMMUNITY_READERS, "communities");
+		return this.pageWithThumbnails(await this.repo.listCommunities(actor.orgId, query, ids));
 	}
-	async getCommunity(orgId, id) {
-		const community = await this.repo.findCommunityById(orgId, id);
+	async getCommunity(id, actor) {
+		const community = await this.findCommunity(id, actor);
+		if (!community) throw new NotFoundError("Community", id);
+		return community;
+	}
+	async findCommunity(id, actor) {
+		this.requireAny(actor, COMMUNITY_READERS, id);
+		const community = await this.repo.findCommunityById(actor.orgId, id);
 		return community ? this.withThumbnail(community) : null;
 	}
 	communitiesWithDigest() {
 		return this.repo.communitiesWithDigest();
 	}
-	listCommunitiesById(orgId, ids) {
-		return ids.length ? this.repo.findCommunitiesByIds(orgId, ids) : Promise.resolve([]);
-	}
-	getSpace(orgId, spaceId) {
-		return this.repo.findSpace(orgId, spaceId);
-	}
-	async getCommunitySpace(orgId, communityId, spaceId) {
-		const space = await this.repo.findSpace(orgId, spaceId);
-		return space?.communityId === communityId ? space : null;
-	}
-	async listSpaces(orgId, communityId) {
-		if (!await this.getCommunity(orgId, communityId)) throw new NotFoundError("Community", communityId);
-		return this.repo.listSpaces(orgId, communityId);
-	}
-	async getDmSettings(orgId, communityId) {
-		return (await this.repo.findCommunityById(orgId, communityId))?.settings.dm ?? null;
-	}
-	async createCommunity(orgId, input, actor) {
-		assertConfigurator(actor);
+	async listCommunitiesById(ids, actor) {
+		if (!actor.permissions.anywhere("communities:read")) {
+			this.logger.warn("content list refused", {
+				orgId: actor.orgId,
+				actorId: actor.id,
+				permission: "communities:read"
+			});
+			throw new ForbiddenError("You cannot see communities");
+		}
+		const visible = ids.filter((id) => actor.permissions.has("communities:read", id));
+		return visible.length ? this.repo.findCommunitiesByIds(actor.orgId, visible) : [];
+	}
+	async getSpace(spaceId, actor) {
+		const space = await this.repo.findSpace(actor.orgId, spaceId);
+		if (!space) return null;
+		this.require(actor, "communities:read", space.communityId);
+		return this.oneSpaceView(space);
+	}
+	async getCommunitySpace(communityId, spaceId, actor) {
+		this.require(actor, "communities:read", communityId);
+		const space = await this.repo.findSpace(actor.orgId, spaceId);
+		if (space?.communityId !== communityId) throw new NotFoundError("Space", spaceId);
+		return this.oneSpaceView(space);
+	}
+	async listSpaces(communityId, actor) {
+		this.requireAny(actor, COMMUNITY_READERS, communityId);
+		const community = await this.repo.findCommunityById(actor.orgId, communityId);
+		if (!community) throw new NotFoundError("Community", communityId);
+		return (await this.repo.listSpaces(actor.orgId, communityId)).map((space) => this.spaceView(space, community.status === "published"));
+	}
+	async getDmSettings(communityId, actor) {
+		this.require(actor, "communities:read", communityId);
+		return (await this.repo.findCommunityById(actor.orgId, communityId))?.settings.dm ?? null;
+	}
+	async createCommunity(input, actor) {
+		this.require(actor, "communities:write");
+		const orgId = actor.orgId;
 		const community = await this.uow.run(async ({ content, outbox }) => {
 			const created = await content.createCommunity(orgId, input, slugify(input.title));
 			await outbox.append([contentEvents.communityCreated.make({
@@ -739,9 +1294,10 @@ var ContentService = class {
 		});
 		return this.withThumbnail(community);
 	}
-	async updateCommunity(orgId, id, patch, actor) {
-		assertConfigurator(actor);
-		await this.assertLibraryAssets(orgId, [patch.thumbnailAssetId], "A community");
+	async updateCommunity(id, patch, actor) {
+		this.require(actor, "communities:write", id);
+		const orgId = actor.orgId;
+		await this.assertAttachable(actor, id, [patch.thumbnailAssetId], async () => [(await this.repo.findCommunityById(orgId, id))?.thumbnailAssetId ?? null], "A community");
 		const community = await this.uow.run(async ({ content, outbox }) => {
 			const updated = await content.updateCommunity(orgId, id, patch);
 			if (!updated) {
@@ -764,17 +1320,23 @@ var ContentService = class {
 			communityId: id,
 			actorId: actor.id
 		});
+		await this.syncThumbnail(community);
+		if (patch.status !== void 0) {
+			const spaces = await this.repo.listSpaces(orgId, id);
+			await Promise.all(spaces.map((space) => this.syncSpaceImages(space, community.status === "published")));
+		}
 		return this.withThumbnail(community);
 	}
-	publishCommunity(orgId, id, actor) {
-		return this.updateCommunity(orgId, id, { status: "published" }, actor);
+	publishCommunity(id, actor) {
+		return this.updateCommunity(id, { status: "published" }, actor);
 	}
-	unpublishCommunity(orgId, id, actor) {
-		return this.updateCommunity(orgId, id, { status: "draft" }, actor);
+	unpublishCommunity(id, actor) {
+		return this.updateCommunity(id, { status: "draft" }, actor);
 	}
-	async deleteCommunity(orgId, id, actor) {
-		assertConfigurator(actor);
-		await this.uow.run(async ({ content, outbox }) => {
+	async deleteCommunity(id, actor) {
+		this.require(actor, "communities:delete", id);
+		const orgId = actor.orgId;
+		const spaceIds = await this.uow.run(async ({ content, outbox }) => {
 			const community = await content.findCommunityById(orgId, id);
 			if (!community) {
 				this.logger.warn("community delete rejected — not found", {
@@ -785,6 +1347,7 @@ var ContentService = class {
 				throw new NotFoundError("Community", id);
 			}
 			const linked = await content.spacesLinkingContent(orgId, id);
+			const own = await content.listSpaces(orgId, id);
 			if (!await content.deleteCommunity(orgId, id)) throw new NotFoundError("Community", id);
 			await content.deleteCommunitySettings(orgId, id);
 			await outbox.append([contentEvents.communityDeleted.make({
@@ -792,15 +1355,19 @@ var ContentService = class {
 				data: community,
 				metadata: actorMetadata(actor)
 			}), ...await this.spaceUpdates(content, orgId, linked, actor)]);
+			return own.map((space) => space.id);
 		});
 		this.logger.info("community deleted", {
 			orgId,
 			communityId: id,
 			actorId: actor.id
 		});
+		await this.withdrawThumbnail(orgId, id);
+		await Promise.all(spaceIds.map((spaceId) => this.files.syncPublicImages(orgId, spaceId, [])));
 	}
-	async patchCommunitySettings(orgId, id, patch, actor) {
-		assertConfigurator(actor);
+	async patchCommunitySettings(id, patch, actor) {
+		this.require(actor, "communities:write", id);
+		const orgId = actor.orgId;
 		const community = await this.uow.run(async ({ content, outbox }) => {
 			const updated = await content.patchCommunitySettings(orgId, id, patch);
 			if (!updated) {
@@ -825,8 +1392,9 @@ var ContentService = class {
 		});
 		return this.withThumbnail(community);
 	}
-	async createSpace(orgId, communityId, input, actor) {
-		assertConfigurator(actor);
+	async createSpace(communityId, input, actor) {
+		this.require(actor, "communities:write", communityId);
+		const orgId = actor.orgId;
 		const resolved = this.resolvedSpace(input);
 		const space = await this.uow.run(async ({ content, outbox }) => {
 			if (!await content.findCommunityById(orgId, communityId)) {
@@ -856,10 +1424,19 @@ var ContentService = class {
 			spaceId: space.id,
 			actorId: actor.id
 		});
-		return space;
-	}
-	async updateSpace(orgId, communityId, spaceId, patch, actor) {
-		assertConfigurator(actor);
+		return this.oneSpaceView(space);
+	}
+	async updateSpace(communityId, spaceId, patch, actor) {
+		this.require(actor, "communities:write", communityId);
+		const orgId = actor.orgId;
+		await this.assertAttachable(actor, communityId, [
+			patch.coverAssetId,
+			patch.backgroundAssetId,
+			patch.iconAssetId
+		], async () => {
+			const current = await this.repo.findSpace(orgId, spaceId);
+			return current ? spaceImageIds(current) : [];
+		}, "A space");
 		const space = await this.uow.run(async ({ content, outbox }) => {
 			const current = await content.findSpace(orgId, spaceId);
 			if (!current || current.communityId !== communityId) {
@@ -892,10 +1469,13 @@ var ContentService = class {
 			spaceId,
 			actorId: actor.id
 		});
-		return space;
+		const published = await this.communityPublished(orgId, communityId);
+		await this.syncSpaceImages(space, published);
+		return this.spaceView(space, published);
 	}
-	async deleteSpace(orgId, communityId, spaceId, actor) {
-		assertConfigurator(actor);
+	async deleteSpace(communityId, spaceId, actor) {
+		this.require(actor, "communities:write", communityId);
+		const orgId = actor.orgId;
 		await this.uow.run(async ({ content, outbox }) => {
 			const space = await content.findSpace(orgId, spaceId);
 			if (!space || space.communityId !== communityId) {
@@ -920,9 +1500,11 @@ var ContentService = class {
 			spaceId,
 			actorId: actor.id
 		});
+		await this.files.syncPublicImages(orgId, spaceId, []);
 	}
-	async reorderSpaces(orgId, communityId, orderedIds, actor) {
-		assertConfigurator(actor);
+	async reorderSpaces(communityId, orderedIds, actor) {
+		this.require(actor, "communities:write", communityId);
+		const orgId = actor.orgId;
 		const spaces = await this.uow.run(async ({ content, outbox }) => {
 			if (!await content.findCommunityById(orgId, communityId)) {
 				this.logger.warn("spaces reorder rejected — community not found", {
@@ -946,10 +1528,12 @@ var ContentService = class {
 			communityId,
 			actorId: actor.id
 		});
-		return spaces;
+		const published = await this.communityPublished(orgId, communityId);
+		return spaces.map((space) => this.spaceView(space, published));
 	}
-	async setSpaceTopics(orgId, communityId, spaceId, input, actor) {
-		assertConfigurator(actor);
+	async setSpaceTopics(communityId, spaceId, input, actor) {
+		this.require(actor, "communities:write", communityId);
+		const orgId = actor.orgId;
 		const names = input.topics.map((topic) => topic.name);
 		if (new Set(names).size !== names.length) throw new InvalidInputError("A space topic name is already used");
 		const space = await this.uow.run(async ({ content, outbox }) => {
@@ -982,10 +1566,11 @@ var ContentService = class {
 			spaceId,
 			actorId: actor.id
 		});
-		return space;
+		return this.oneSpaceView(space);
 	}
-	async addSpaceLink(orgId, communityId, spaceId, contentId, actor) {
-		assertConfigurator(actor);
+	async addSpaceLink(communityId, spaceId, contentId, actor) {
+		this.require(actor, "communities:write", communityId);
+		const orgId = actor.orgId;
 		const space = await this.uow.run(async ({ content, outbox }) => {
 			const current = await content.findSpace(orgId, spaceId);
 			if (!current || current.communityId !== communityId) {
@@ -1013,10 +1598,11 @@ var ContentService = class {
 			contentId,
 			actorId: actor.id
 		});
-		return space;
+		return this.oneSpaceView(space);
 	}
-	async removeSpaceLink(orgId, communityId, spaceId, linkId, actor) {
-		assertConfigurator(actor);
+	async removeSpaceLink(communityId, spaceId, linkId, actor) {
+		this.require(actor, "communities:write", communityId);
+		const orgId = actor.orgId;
 		const space = await this.uow.run(async ({ content, outbox }) => {
 			const current = await content.findSpace(orgId, spaceId);
 			if (!current || current.communityId !== communityId) {
@@ -1043,10 +1629,11 @@ var ContentService = class {
 			linkId,
 			actorId: actor.id
 		});
-		return space;
+		return this.oneSpaceView(space);
 	}
-	async reorderSpaceLinks(orgId, communityId, spaceId, orderedIds, actor) {
-		assertConfigurator(actor);
+	async reorderSpaceLinks(communityId, spaceId, orderedIds, actor) {
+		this.require(actor, "communities:write", communityId);
+		const orgId = actor.orgId;
 		const space = await this.uow.run(async ({ content, outbox }) => {
 			const current = await content.findSpace(orgId, spaceId);
 			if (!current || current.communityId !== communityId) {
@@ -1073,7 +1660,7 @@ var ContentService = class {
 			spaceId,
 			actorId: actor.id
 		});
-		return space;
+		return this.oneSpaceView(space);
 	}
 };
 //#endregion