@mosetta/editor 0.0.0-stage → 0.0.28

package/tiles/content/content.server.ts

@@ -0,0 +1,593 @@
+// The editor's content persistence server module: the real API behind the visual editor.
+// Runs in a Worker Loader isolate; all disk access goes through the opt-in content transport to the
+// provider. This module is the TRUSTED writer: it includes DevContentTransport in its
+// services — that line IS the write capability (the framework blesses nothing by default).
+import {
+  ContentError,
+  ContentRepository,
+  ContentSchemas,
+  ContentTransportError,
+  CONTENT_REPOSITORY_TOKEN,
+  CONTENT_TRANSPORT_TOKEN,
+  createContentSchemas,
+  DevContentTransport,
+  ICatalogEntry,
+  IDistributionEntry,
+  ILibraryPrefabEntry,
+  IModuleDescriptor,
+  IBlueprintNodeDoc,
+  ILoadedContent,
+  ILoadedDraft,
+  IPageDoc,
+  IPrefabDoc,
+  pageAsPrefab,
+  prefabAsPage,
+  prefabReference,
+  publishedFormOf,
+} from '@mosetta/content';
+import type { ContentKind } from '@mosetta/content';
+import {
+  DiInject,
+  DiServerAction,
+  defineServerSide,
+  ICreateSchema,
+  IServerActionPayload,
+  ServerAction,
+  TILE_HOSTS_TOKEN,
+} from '@mosetta/server-action/server';
+import type { ICaller, IServerActionAccess, ITileHostBase } from '@mosetta/server-action/server';
+import { mergeTileHosts } from '@mosetta/core';
+import { DiService, SingleDiToken } from '@mosetta/di';
+import type { ZodType } from 'zod';
+import { projectNamespaceOf, unitOf } from '@mosetta/content';
+import type { IContentTransport } from '@mosetta/content';
+import { CONFIG_PATH } from '@mosetta/content/paths';
+import { blockSchemas, settingsIssueLine, treeSettingsIssues } from '@mosetta/settings/check';
+import type { ICatalogSettingsEntry } from '@mosetta/settings/check';
+import {
+  ContentActionResult,
+  createPageDraftToken,
+  createPageToken,
+  deletePageToken,
+  discardPageDraftToken,
+  forkPageDraftToken,
+  IKindInput,
+  IPageDraftListItem,
+  IPageListEntry,
+  IPrefabTree,
+  listComponentsToken,
+  listPagesToken,
+  loadPageDraftToken,
+  loadPageToken,
+  prefabTreesToken,
+  projectConfigToken,
+  publishPageToken,
+  refreshLiveSiteToken,
+  savePageDraftToken,
+} from './contentCommon';
+
+// ---- catalog: the public tile host descriptors (modules.json) of every tile host of the site ----
+
+const CATALOG_TOKEN = new SingleDiToken<CatalogService>('EDITOR_CATALOG_TOKEN');
+
+const facetKey = (d: IModuleDescriptor) => `${d.reference.namespace}/${d.reference.name}/${d.reference.version}`;
+
+const withSlash = (base: string): string => (base.endsWith('/') ? base : `${base}/`);
+
+@DiService(CATALOG_TOKEN)
+class CatalogService {
+  /** the site's tile hosts, the primary first */
+  private readonly hosts: readonly ITileHostBase[];
+
+  private readonly fetchImpl: typeof fetch;
+
+  constructor(
+    @DiInject(TILE_HOSTS_TOKEN)
+    hosts: readonly ITileHostBase[],
+  ) {
+    this.hosts = hosts.map(({ key, publicBase }) => ({ key, publicBase: withSlash(publicBase) }));
+    this.fetchImpl = fetch.bind(globalThis);
+  }
+
+  /**
+   * Every tile the site may place, merged by the factory's own rule (a brand — one tile host, a tile
+   * past the primary — with its integrity). The primary's descriptor is the editor's own: without
+   * it nothing is offered. Another host that cannot be read is left out, said in the log.
+   */
+  async descriptors(): Promise<IModuleDescriptor[]> {
+    const parts = await Promise.all(this.hosts.map(async ({ key, publicBase }, index) => {
+      const res = await this.fetchImpl(`${publicBase}modules.json`);
+      if (res.ok) return { key, public: (await res.json()) as IModuleDescriptor[], private: [] };
+      await res.body?.cancel();
+      if (index === 0) throw new Error(`catalog fetch failed: ${res.status}`);
+      if (res.status !== 404) console.warn(`[mosetta editor] tile host ${key} answered ${res.status} — its tiles are not offered`);
+      return { key, public: [], private: [] };
+    }));
+    const merged = mergeTileHosts(parts);
+    for (const warning of merged.warnings) console.warn(`[mosetta editor] ${warning}`);
+    return [...merged.public.entities];
+  }
+
+  /** where a file of an entity's folder is fetched — beside the entity's own artifact, at its tile host */
+  private fileUrl(entity: IModuleDescriptor, file: unknown): string | undefined {
+    const key = (entity as { provider?: string }).provider;
+    const base = (key ? this.hosts.find((h) => h.key === key) : undefined) ?? this.hosts[0];
+    return typeof file === 'string' && file && base ? `${base.publicBase}modules/${entity.id}/${file}` : undefined;
+  }
+
+  /** palette entries: requested types (default: components), each paired with its editor facet */
+  async entries(types?: string[]): Promise<ICatalogEntry[]> {
+    const all = await this.descriptors();
+    const editors = new Set(all.filter((d) => d.reference.type === 'editor').map(facetKey));
+    const wanted = new Set(types && types.length ? types : ['component']);
+    return all
+      .filter((d) => wanted.has(d.reference.type))
+      .map((d) => {
+        const iconUrl = this.fileUrl(d, (d as { icon?: unknown }).icon);
+        return { ...d, hasEditor: editors.has(facetKey(d)), ...(iconUrl ? { iconUrl } : {}) };
+      });
+  }
+
+  /** the prefabs the libraries bring — placed LIVE, by a reference that names no version */
+  async libraryPrefabs(): Promise<ILibraryPrefabEntry[]> {
+    return (await this.descriptors())
+      .filter((d) => d.reference.type === 'prefab')
+      .map((d) => ({
+        namespace: d.reference.namespace,
+        name: d.reference.name,
+        version: d.reference.version,
+        reference: prefabReference(d.reference.namespace, d.reference.name),
+      }));
+  }
+
+  /** the distributions the catalog describes — what each calls itself and its pictures */
+  async distributions(): Promise<IDistributionEntry[]> {
+    return (await this.descriptors())
+      .filter((d) => d.reference.type === 'distribution')
+      .map((d) => {
+        const own = d as unknown as { title?: unknown; description?: unknown; source?: unknown; icon?: unknown; cover?: unknown; internal?: unknown; base?: unknown; changes?: unknown };
+        const text = (value: unknown) => (typeof value === 'string' && value ? value : undefined);
+        const iconUrl = this.fileUrl(d, own.icon);
+        const coverUrl = this.fileUrl(d, own.cover);
+        return {
+          id: d.id,
+          namespace: d.reference.namespace,
+          version: d.reference.version,
+          title: text(own.title) ?? d.reference.namespace,
+          ...(text(own.description) ? { description: text(own.description) } : {}),
+          ...(text(own.source) ? { source: text(own.source) } : {}),
+          ...(iconUrl ? { iconUrl } : {}),
+          ...(coverUrl ? { coverUrl } : {}),
+          ...(own.internal === true ? { internal: true } : {}),
+          ...(own.base === true ? { base: true } : {}),
+          ...(text(own.changes) ? { changes: text(own.changes) } : {}),
+        };
+      });
+  }
+
+  async knownReferences(): Promise<Set<string>> {
+    return new Set((await this.descriptors()).map((d) => d.id));
+  }
+}
+
+// ---- shared action machinery ----
+
+function collectNodeReferences(node: IBlueprintNodeDoc, into: Set<string>): void {
+  into.add(node.reference);
+  for (const child of node.children ?? []) collectNodeReferences(child, into);
+}
+
+function pageReferences(page: IPageDoc): string[] {
+  const refs = new Set<string>();
+  collectNodeReferences(page, refs);
+  if (page.fallback) refs.add(page.fallback);
+  return [...refs];
+}
+
+/**
+ * A tree's references checked the way each kind exists: a module against the catalog; a live
+ * PREFAB is content (the project's) or the distribution's and never in the catalog — a missing one
+ * renders the node's children without it. Inside a prefab a prefab is refused: one level only.
+ */
+function referenceIssues(refs: readonly string[], known: ReadonlySet<string>, kind: ContentKind): string[] {
+  return refs.flatMap((ref) => {
+    if (unitOf(ref) !== null) return kind === 'prefabs' ? [`a prefab cannot hold a prefab: ${ref}`] : [];
+    return known.has(ref) ? [] : [`unknown tile reference: ${ref}`];
+  });
+}
+
+/** the document as it is stored: a prefab edited in a page's shape goes back to being a prefab */
+const storedFormOf = (kind: ContentKind, page: IPageDoc): unknown => (kind === 'prefabs' ? pageAsPrefab(page) : page);
+
+/** the document as the editor edits it: a prefab in a page's shape */
+const editedFormOf = (kind: ContentKind, doc: unknown): IPageDoc => (kind === 'prefabs' ? prefabAsPage(doc as IPrefabDoc) : doc as IPageDoc);
+
+class PublishValidationError extends Error {
+  constructor(readonly issues: string[]) {
+    super(`publish validation failed: ${issues.join('; ')}`);
+  }
+}
+
+/**
+ * An EDITOR of the project — as the host vouches: the platform's Worker names the roles a person
+ * holds in the project (`roles: ['editor']`), and `mosetta dev` names the developer at the machine
+ * the same way. The content is its editors' to read and write — nobody else's.
+ */
+const isEditor = (caller: ICaller | null): boolean => Array.isArray(caller?.roles) && (caller.roles as unknown[]).includes('editor');
+
+// Base for every content action: editors only; builds domain schemas from the injected zod builder
+// and maps domain failures to structured results (the editor UI branches on `code`; transport 5xx
+// stays for real bugs).
+abstract class ContentAction<TIn extends {}, TOut extends {}> extends ServerAction<TIn, ContentActionResult<TOut>> {
+  // set on every request: the glue invokes createSchema() BEFORE action(), so run() can deep-validate
+  // stored documents (e.g. on publish) with the same injected zod the input was parsed with.
+  protected schemas!: ContentSchemas;
+
+  createSchema({ builder }: ICreateSchema): ZodType<TIn> {
+    this.schemas = createContentSchemas(builder);
+    return this.inputSchema(builder, this.schemas);
+  }
+
+  authorize({ caller }: IServerActionAccess<TIn>): boolean {
+    return isEditor(caller);
+  }
+
+  protected abstract inputSchema(builder: ICreateSchema['builder'], schemas: ContentSchemas): ZodType<TIn>;
+
+  protected abstract run(input: TIn): Promise<TOut>;
+
+  async action({ input }: IServerActionPayload<TIn>): Promise<ContentActionResult<TOut>> {
+    try {
+      return { ok: true, ...(await this.run(input)) };
+    } catch (e) {
+      if (e instanceof ContentError) return { ok: false, code: e.code, message: e.message };
+      if (e instanceof PublishValidationError) {
+        return { ok: false, code: 'PUBLISH_VALIDATION', message: e.message, issues: e.issues };
+      }
+      if (e instanceof ContentTransportError) {
+        return { ok: false, code: e.status === 409 ? 'IMMUTABLE' : 'TRANSPORT', message: e.message };
+      }
+      throw e; // unexpected → the glue's 500
+    }
+  }
+}
+
+// ---- pages and prefabs ----
+
+@DiServerAction(listPagesToken)
+class ListPagesAction extends ContentAction<IKindInput, { pages: IPageListEntry[] }> {
+  constructor(@DiInject(CONTENT_REPOSITORY_TOKEN) private readonly content: ContentRepository) {
+    super();
+  }
+
+  protected inputSchema(builder: ICreateSchema['builder'], s: ContentSchemas) {
+    return builder.object({ kind: s.contentKind.optional() });
+  }
+
+  // The listing carries ROUTES: patterns are versioned with the documents. The live one is read
+  // off the publish markers (the route table itself), a draft's comes with its summary — one
+  // listing and the entities side by side, no document opened twice. A prefab has no route.
+  protected async run({ kind = 'pages' }: IKindInput) {
+    const [entities, live] = await Promise.all([
+      this.content.list(kind),
+      kind === 'pages' ? this.content.livePatterns().catch(() => new Map<string, string>()) : Promise.resolve(new Map<string, string>()),
+    ]);
+    const pages: IPageListEntry[] = entities.map((entity) => ({
+      name: entity.name,
+      meta: entity.meta,
+      drafts: entity.drafts.map(({ pattern, ...draft }): IPageDraftListItem => ({ ...draft, pattern: kind === 'pages' ? pattern ?? null : null })),
+      livePattern: kind === 'pages' && entity.meta.live != null ? live.get(entity.name) ?? null : null,
+    }));
+    return { pages };
+  }
+}
+
+type TLoadInput = { name: string; rev?: number } & IKindInput;
+
+@DiServerAction(loadPageToken)
+class LoadPageAction extends ContentAction<TLoadInput, { page: ILoadedContent<IPageDoc> }> {
+  constructor(@DiInject(CONTENT_REPOSITORY_TOKEN) private readonly content: ContentRepository) {
+    super();
+  }
+
+  protected inputSchema(builder: ICreateSchema['builder'], s: ContentSchemas) {
+    return builder.object({ name: s.entityName, rev: s.revision.optional(), kind: s.contentKind.optional() });
+  }
+
+  protected async run({ name, rev, kind = 'pages' }: TLoadInput) {
+    const loaded = await this.content.load<unknown>(kind, name, rev);
+    return { page: { ...loaded, doc: editedFormOf(kind, loaded.doc) } };
+  }
+}
+
+type TDraftInput = { name: string; draftId: string } & IKindInput;
+
+@DiServerAction(loadPageDraftToken)
+class LoadPageDraftAction extends ContentAction<TDraftInput, { draft: ILoadedDraft<IPageDoc> }> {
+  constructor(@DiInject(CONTENT_REPOSITORY_TOKEN) private readonly content: ContentRepository) {
+    super();
+  }
+
+  protected inputSchema(builder: ICreateSchema['builder'], s: ContentSchemas) {
+    return builder.object({ name: s.entityName, draftId: s.draftId, kind: s.contentKind.optional() });
+  }
+
+  protected async run({ name, draftId, kind = 'pages' }: TDraftInput) {
+    const loaded = await this.content.loadDraft<unknown>(kind, name, draftId);
+    return { draft: { ...loaded, doc: editedFormOf(kind, loaded.doc) } };
+  }
+}
+
+type TPageInput = { name: string; page: IPageDoc } & IKindInput;
+
+@DiServerAction(createPageToken)
+class CreatePageAction extends ContentAction<TPageInput, { draftId: string }> {
+  constructor(@DiInject(CONTENT_REPOSITORY_TOKEN) private readonly content: ContentRepository) {
+    super();
+  }
+
+  protected inputSchema(builder: ICreateSchema['builder'], s: ContentSchemas) {
+    return builder.object({ name: s.entityName, page: s.pageDoc, kind: s.contentKind.optional() }) as unknown as ZodType<TPageInput>;
+  }
+
+  protected async run({ name, page, kind = 'pages' }: TPageInput) {
+    return { draftId: await this.content.create(kind, name, storedFormOf(kind, page), kind === 'prefabs' ? 'unit' : undefined) };
+  }
+}
+
+type TSaveInput = { name: string; draftId: string; page: IPageDoc } & IKindInput;
+
+@DiServerAction(savePageDraftToken)
+class SavePageDraftAction extends ContentAction<TSaveInput, { warnings: string[] }> {
+  constructor(
+    @DiInject(CONTENT_REPOSITORY_TOKEN) private readonly content: ContentRepository,
+    @DiInject(CATALOG_TOKEN) private readonly catalog: CatalogService,
+  ) {
+    super();
+  }
+
+  protected inputSchema(builder: ICreateSchema['builder'], s: ContentSchemas) {
+    return builder.object({
+      name: s.entityName,
+      draftId: s.draftId,
+      page: s.pageDoc,
+      kind: s.contentKind.optional(),
+    }) as unknown as ZodType<TSaveInput>;
+  }
+
+  // save is SOFT on referential integrity (a draft may be half-done, a module may not be built yet):
+  // unknown references come back as warnings; publish is where they become errors. Concurrency is
+  // NOT soft: a page whose seq does not follow the stored draft's comes back as CONFLICT.
+  protected async run({ name, draftId, page, kind = 'pages' }: TSaveInput) {
+    const known = await this.catalog.knownReferences();
+    const warnings = referenceIssues(pageReferences(page), known, kind);
+    await this.content.saveDraft(kind, name, draftId, storedFormOf(kind, page));
+    return { warnings };
+  }
+}
+
+type TCreateDraftInput = { name: string; fromRev?: number } & IKindInput;
+
+@DiServerAction(createPageDraftToken)
+class CreatePageDraftAction extends ContentAction<TCreateDraftInput, { draftId: string; page: IPageDoc }> {
+  constructor(@DiInject(CONTENT_REPOSITORY_TOKEN) private readonly content: ContentRepository) {
+    super();
+  }
+
+  protected inputSchema(builder: ICreateSchema['builder'], s: ContentSchemas) {
+    return builder.object({ name: s.entityName, fromRev: s.revision.optional(), kind: s.contentKind.optional() });
+  }
+
+  protected async run({ name, fromRev, kind = 'pages' }: TCreateDraftInput) {
+    const { id, doc } = await this.content.createDraft(kind, name, fromRev);
+    return { draftId: id, page: editedFormOf(kind, doc) };
+  }
+}
+
+@DiServerAction(forkPageDraftToken)
+class ForkPageDraftAction extends ContentAction<TPageInput, { draftId: string; page: IPageDoc }> {
+  constructor(@DiInject(CONTENT_REPOSITORY_TOKEN) private readonly content: ContentRepository) {
+    super();
+  }
+
+  protected inputSchema(builder: ICreateSchema['builder'], s: ContentSchemas) {
+    return builder.object({ name: s.entityName, page: s.pageDoc, kind: s.contentKind.optional() }) as unknown as ZodType<TPageInput>;
+  }
+
+  protected async run({ name, page, kind = 'pages' }: TPageInput) {
+    const { id, doc } = await this.content.forkDraft(kind, name, storedFormOf(kind, page));
+    return { draftId: id, page: editedFormOf(kind, doc) };
+  }
+}
+
+type TPublishInput = TDraftInput & { title?: string };
+
+@DiServerAction(publishPageToken)
+class PublishPageAction extends ContentAction<TPublishInput, { live: number }> {
+  constructor(
+    @DiInject(CONTENT_REPOSITORY_TOKEN) private readonly content: ContentRepository,
+    @DiInject(CATALOG_TOKEN) private readonly catalog: CatalogService,
+    @DiInject(CONTENT_TRANSPORT_TOKEN) private readonly transport: IContentTransport,
+  ) {
+    super();
+  }
+
+  /** a prefab of the project the page places must be published — a draft-only one would show nothing */
+  private async unpublishedPrefabs(refs: readonly string[]): Promise<string[]> {
+    const namespace = projectNamespaceOf(await this.transport.read(CONFIG_PATH).catch(() => null));
+    const own = refs.map(unitOf).filter((unit) => unit !== null && unit.namespace === namespace);
+    if (!own.length) return [];
+    const live = new Set((await this.content.list('prefabs')).filter((e) => e.meta.live != null).map((e) => e.name));
+    return own.filter((unit) => !live.has(unit!.name)).map((unit) => `the prefab ${unit!.name} is not published`);
+  }
+
+  protected inputSchema(builder: ICreateSchema['builder'], s: ContentSchemas) {
+    return builder.object({ name: s.entityName, draftId: s.draftId, kind: s.contentKind.optional(), title: builder.string().max(80).optional() });
+  }
+
+  // publish is STRICT: what would go live must re-validate against the schema (the draft may have
+  // been hand-edited on disk), every reference must exist in the catalog, every block's settings
+  // must fit what its block describes (its catalog entry's settings schema — a draft may hold
+  // anything while it is worked on, the live site only what fits), and a page's route pattern must
+  // be unique among the OTHER live pages. Validated in its PUBLISHED form: the working fields (undo
+  // stacks, seq, …) are stripped by the publish itself.
+  protected async run({ name, draftId, kind = 'pages', title }: TPublishInput) {
+    const { doc: stored } = await this.content.loadDraft<object>(kind, name, draftId);
+    const doc = publishedFormOf(stored);
+    const issues: string[] = [];
+
+    const shape = (kind === 'prefabs' ? this.schemas.prefabDoc : this.schemas.pageDoc).safeParse(doc);
+    if (!shape.success) issues.push(...shape.error.issues.map((i) => `${i.path.join('.') || '(root)'}: ${i.message}`));
+
+    const descriptors = await this.catalog.descriptors();
+    const known = new Set(descriptors.map((d) => d.id));
+    const edited = editedFormOf(kind, doc);
+    const refs = pageReferences(edited);
+    issues.push(...referenceIssues(refs, known, kind));
+    issues.push(...treeSettingsIssues(edited, blockSchemas(descriptors as readonly ICatalogSettingsEntry[])).map(settingsIssueLine));
+
+    if (kind === 'pages') {
+      // the live routes are the publish markers — read side by side with the prefab check
+      const pattern = (doc as IPageDoc).pattern;
+      const [prefabIssues, live] = await Promise.all([this.unpublishedPrefabs(refs), this.content.livePatterns()]);
+      issues.push(...prefabIssues);
+      for (const [other, otherPattern] of live) {
+        if (other !== name && otherPattern === pattern) issues.push(`pattern ${pattern} is already live on page ${other}`);
+      }
+    }
+
+    if (issues.length) throw new PublishValidationError(issues);
+    return { live: await this.content.publish(kind, name, draftId, title) };
+  }
+}
+
+@DiServerAction(prefabTreesToken)
+class PrefabTreesAction extends ContentAction<{ names: string[] }, { prefabs: IPrefabTree[] }> {
+  constructor(@DiInject(CONTENT_REPOSITORY_TOKEN) private readonly content: ContentRepository) {
+    super();
+  }
+
+  protected inputSchema(builder: ICreateSchema['builder'], s: ContentSchemas) {
+    return builder.object({ names: builder.array(s.entityName).max(100) });
+  }
+
+  protected async run({ names }: { names: string[] }) {
+    const loaded = await Promise.all([...new Set(names)].map(async (name): Promise<IPrefabTree | null> => {
+      try {
+        const { rev, doc } = await this.content.load<IPrefabDoc>('prefabs', name);
+        return { name, rev, doc: prefabAsPage(doc) };
+      } catch {
+        return null; // not there, or never published: nothing to show for it
+      }
+    }));
+    return { prefabs: loaded.filter((p): p is IPrefabTree => p !== null) };
+  }
+}
+
+/** the project's content config as it is — a project-wide block (i18n) reads its languages */
+@DiServerAction(projectConfigToken)
+class ProjectConfigAction extends ContentAction<{}, { config: Record<string, unknown> }> {
+  constructor(@DiInject(CONTENT_TRANSPORT_TOKEN) private readonly transport: IContentTransport) {
+    super();
+  }
+
+  protected inputSchema(builder: ICreateSchema['builder']) {
+    return builder.object({});
+  }
+
+  protected async run() {
+    const config = await this.transport.read(CONFIG_PATH).catch(() => null);
+    return { config: config && typeof config === 'object' && !Array.isArray(config) ? config as Record<string, unknown> : {} };
+  }
+}
+
+@DiServerAction(refreshLiveSiteToken)
+class RefreshLiveSiteAction extends ContentAction<{}, { refreshed: boolean }> {
+  constructor(@DiInject(CONTENT_REPOSITORY_TOKEN) private readonly content: ContentRepository) {
+    super();
+  }
+
+  protected inputSchema(builder: ICreateSchema['builder']) {
+    return builder.object({});
+  }
+
+  protected async run() {
+    return { refreshed: await this.content.refreshLiveSite() };
+  }
+}
+
+@DiServerAction(discardPageDraftToken)
+class DiscardPageDraftAction extends ContentAction<TDraftInput, {}> {
+  constructor(@DiInject(CONTENT_REPOSITORY_TOKEN) private readonly content: ContentRepository) {
+    super();
+  }
+
+  protected inputSchema(builder: ICreateSchema['builder'], s: ContentSchemas) {
+    return builder.object({ name: s.entityName, draftId: s.draftId, kind: s.contentKind.optional() });
+  }
+
+  protected async run({ name, draftId, kind = 'pages' }: TDraftInput) {
+    await this.content.discardDraft(kind, name, draftId);
+    return {};
+  }
+}
+
+type TNameInput = { name: string } & IKindInput;
+
+@DiServerAction(deletePageToken)
+class DeletePageAction extends ContentAction<TNameInput, {}> {
+  constructor(@DiInject(CONTENT_REPOSITORY_TOKEN) private readonly content: ContentRepository) {
+    super();
+  }
+
+  protected inputSchema(builder: ICreateSchema['builder'], s: ContentSchemas) {
+    return builder.object({ name: s.entityName, kind: s.contentKind.optional() });
+  }
+
+  protected async run({ name, kind = 'pages' }: TNameInput) {
+    await this.content.delete(kind, name);
+    return {};
+  }
+}
+
+// ---- catalog ----
+
+@DiServerAction(listComponentsToken)
+class ListComponentsAction extends ContentAction<{ types?: string[] }, { components: ICatalogEntry[]; distributions: IDistributionEntry[]; prefabs: ILibraryPrefabEntry[] }> {
+  constructor(@DiInject(CATALOG_TOKEN) private readonly catalog: CatalogService) {
+    super();
+  }
+
+  protected inputSchema(builder: ICreateSchema['builder']) {
+    return builder.object({ types: builder.array(builder.string()).optional() });
+  }
+
+  protected async run({ types }: { types?: string[] }) {
+    const [components, distributions, prefabs] = await Promise.all([this.catalog.entries(types), this.catalog.distributions(), this.catalog.libraryPrefabs()]);
+    return { components, distributions, prefabs };
+  }
+}
+
+// DevContentTransport in `services` is the OPT-IN write capability:
+// the editor is the trusted writer; a module without this line cannot resolve the transport.
+export default defineServerSide({
+  services: [
+    DevContentTransport,
+    ContentRepository,
+    CatalogService,
+    ListPagesAction,
+    LoadPageAction,
+    LoadPageDraftAction,
+    CreatePageAction,
+    SavePageDraftAction,
+    CreatePageDraftAction,
+    ForkPageDraftAction,
+    PublishPageAction,
+    ProjectConfigAction,
+    RefreshLiveSiteAction,
+    PrefabTreesAction,
+    DiscardPageDraftAction,
+    DeletePageAction,
+    ListComponentsAction,
+  ],
+});