@forgeax/interface 0.4.1

package/dist/package/node/core/extensions/panels-chat.js

@@ -0,0 +1,41 @@
+import { buildAssetPill, requestComposerInsert } from '../../lib/composer-bridge.js';
+export const panelsChatExtension = {
+    id: 'panels.chat',
+    version: '1.0.0',
+    requires: ['commands'],
+    setup(ctx) {
+        const cleanups = [];
+        cleanups.push(ctx.registerCommand({
+            id: 'app.chat.insertPill',
+            title: 'Insert reference pill into chat composer',
+            execute: (args) => {
+                const p = args;
+                if (!p?.pill)
+                    throw new Error('app.chat.insertPill: missing { pill }');
+                requestComposerInsert(p.pill);
+                return { status: 'completed' };
+            },
+        }));
+        // Public reference channel for callers outside interface (e.g. the editor's
+        // page-tab menu): build the asset pill here so the composer-bridge stays an
+        // interface-internal detail and cross-package callers only touch commands.
+        cleanups.push(ctx.registerCommand({
+            id: 'app.chat.referenceAsset',
+            title: 'Reference an asset in the chat composer',
+            execute: (args) => {
+                const a = args;
+                if (!a?.guid)
+                    throw new Error('app.chat.referenceAsset: missing { guid }');
+                requestComposerInsert(buildAssetPill({
+                    guid: a.guid,
+                    ...(a.name ? { name: a.name } : {}),
+                    ...(a.assetKind ? { assetKind: a.assetKind } : {}),
+                    ...(a.packPath ? { packPath: a.packPath } : {}),
+                }));
+                return { status: 'completed' };
+            },
+        }));
+        return () => { for (const c of cleanups)
+            c(); };
+    },
+};

package/dist/package/node/core/extensions/panels-editor.js

@@ -0,0 +1,26 @@
+import { DEFAULT_EDITOR_PANEL_IDS } from '../../components/DockShell/panelRenderers.js';
+export function createPanelsEditorExtension(opts = {}) {
+    return {
+        id: 'panels.editor', version: '1.0.0',
+        requires: ['commands'],
+        contributes: {
+            panels: {
+                editorPanelIds: opts.editorPanelIds ?? DEFAULT_EDITOR_PANEL_IDS,
+                panels: opts.panels,
+                surfaces: opts.surfaces,
+            },
+        },
+        setup(ctx) {
+            return ctx.registerCommand({
+                id: 'app.editor.focus',
+                title: 'Focus an editor panel by short id (hierarchy / assets / mesh / ...)',
+                execute: (args) => {
+                    const p = args;
+                    if (!p?.panel)
+                        throw new Error('app.editor.focus: missing { panel }');
+                    return ctx.host.commands.execute('app.panel.focus', { id: `ep:${p.panel}` });
+                },
+            });
+        },
+    };
+}

package/dist/package/node/core/extensions/panels-viewport.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ViewportPanel } from '../../components/MainArea/SurfacePanels.js';
+export const panelsViewportExtension = {
+    id: 'panels.viewport',
+    version: '1.0.0',
+    contributes: {
+        panels: {
+            panels: {
+                viewport: {
+                    title: 'Viewport',
+                    order: 0,
+                    header: { visible: true, showTitle: false },
+                    content: { padding: 'none', scroll: 'none', tone: 'tool' },
+                    dockChrome: { singleTab: 'hideTitle' },
+                    render: () => _jsx(ViewportPanel, {}),
+                },
+            },
+        },
+    },
+};

package/dist/package/node/core/extensions/session-client.js

@@ -0,0 +1,42 @@
+// packages/interface/src/core/extensions/session-client.ts
+//
+// host.session capability — bridges the legacy useShellStore session slice so
+// non-React callers (event handlers, module-level code, other plugins) can
+// reach session state/methods through the AppHost instead of importing the
+// store directly.
+//
+// This is a thin capability object, NOT a reactivity source: read-getters
+// snapshot `useShellStore.getState()` on each access; components that need to
+// re-render on session changes must keep subscribing to useShellStore. The
+// per-callsite migration (and eventual slice deletion) lands in T24.
+import { useShellStore } from '../../store.js';
+import { getSessionClient, hasSessionClient } from '../../store-parts/session-client.js';
+export const sessionClientExtension = {
+    id: 'session-client',
+    version: '1.0.0',
+    provides: ['session'],
+    setup(ctx) {
+        // Graceful degradation: interface-alone / standalone-editor hosts have no
+        // forgeax-server, so the composition root never configures a client. Skip
+        // providing host.session (consumers already narrow with `if (host.session)`)
+        // instead of throwing the shell boot into console.error.
+        if (!hasSessionClient()) {
+            ctx.log.info('[session-client] no client configured — host.session skipped (studio-only capability)');
+            return;
+        }
+        const client = getSessionClient();
+        const cap = {
+            client,
+            get tabs() { return useShellStore.getState().tabs; },
+            get activeSid() { return useShellStore.getState().activeSid; },
+            get activeGameSlug() { return useShellStore.getState().activeGameSlug; },
+            switchToSession: (sid) => useShellStore.getState().switchToSession(sid),
+            createSession: (opts) => useShellStore.getState().createNewSession(opts),
+            closeSession: (sid) => useShellStore.getState().closeSession(sid),
+            renameTab: (sid, n) => useShellStore.getState().renameTab(sid, n),
+            refreshSessions: () => useShellStore.getState().refreshSessions(),
+            setActiveGame: async (slug) => { await useShellStore.getState().setActiveGame(slug); },
+        };
+        ctx.host.extend('session', cap);
+    },
+};

package/dist/package/node/core/extensions/slots-corner-agent-picker.js

@@ -0,0 +1,6 @@
+export function createSlotsCornerAgentPickerExtension(CornerAgentPicker) {
+    return {
+        id: 'slots.corner-agent-picker', version: '1.0.0',
+        contributes: { panels: { slots: { CornerAgentPicker } } },
+    };
+}

package/dist/package/node/core/extensions/slots-main-area-body.js

@@ -0,0 +1,6 @@
+export function createSlotsMainAreaBodyExtension(MainAreaBody) {
+    return {
+        id: 'slots.main-area-body', version: '1.0.0',
+        contributes: { panels: { slots: { MainAreaBody } } },
+    };
+}

package/dist/package/node/core/extensions/slots-sidebar-agents.js

@@ -0,0 +1,6 @@
+export function createSlotsSidebarAgentsExtension(SidebarAgents) {
+    return {
+        id: 'slots.sidebar-agents', version: '1.0.0',
+        contributes: { panels: { slots: { SidebarAgents } } },
+    };
+}

package/dist/package/node/core/extensions/studio-domain-clients.js

@@ -0,0 +1,15 @@
+import { getAgentCatalogClient, getStudioBuildClient, getStudioProjectClient, hasStudioDomainClients, } from '../../store-parts/domain-clients.js';
+export const studioDomainClientsExtension = {
+    id: 'studio-domain-clients',
+    version: '1.0.0',
+    provides: ['agentCatalog', 'projects', 'builds'],
+    setup(ctx) {
+        if (!hasStudioDomainClients()) {
+            ctx.log.info('[studio-domain-clients] no clients configured; standalone hosts keep domain capabilities absent');
+            return;
+        }
+        ctx.host.extend('agentCatalog', { client: getAgentCatalogClient() });
+        ctx.host.extend('projects', { client: getStudioProjectClient() });
+        ctx.host.extend('builds', { client: getStudioBuildClient() });
+    },
+};

package/dist/package/node/core/extensions/surfaces-scene-editor.js

@@ -0,0 +1,6 @@
+export function createSurfacesSceneEditorExtension(SceneEditor) {
+    return {
+        id: 'surfaces.scene-editor', version: '1.0.0',
+        contributes: { panels: { surfaces: { SceneEditor } } },
+    };
+}

package/dist/package/node/core/extensions/trajectory.js

@@ -0,0 +1,50 @@
+import { registerAction, registerStateSlice } from '../../lib/action-registry.js';
+import { TRAJECTORY_MAX, clearTrajectory, readTrajectory, startTrajectoryRecording, } from '../../lib/ui-trajectory.js';
+/** 随每次 ui_snapshot 内联出墙的尾部条数(压 token;更多靠 trajectory.read 拉)。 */
+const SNAPSHOT_TAIL = 20;
+export const trajectoryExtension = {
+    id: 'trajectory',
+    version: '1.0.0',
+    setup() {
+        const stopRecording = startTrajectoryRecording();
+        // ① 观察上下文:最近 N 条操作随每次 ui_snapshot 自动出墙。
+        const offSlice = registerStateSlice('ui.trajectory', () => readTrajectory({ limit: SNAPSHOT_TAIL }).entries);
+        // ② 按需读取(firstClass:模型直接看到这条工具,免一次 snapshot 发现往返)。
+        const offRead = registerAction({
+            id: 'trajectory.read',
+            title: '读取操作轨迹',
+            description: 'Read the recent trajectory of UI operations performed on the page by BOTH the human and the AI, ordered oldest→newest. Every operation dispatched through the action registry is recorded (page mode switches, panel toggles, session/game/role/extension ops, etc.). Use this to understand what the user just did before asking you something. Params: limit (default 50, max ' +
+                TRAJECTORY_MAX +
+                '), source ("human"|"ai" to filter by who performed it). Returns { total, count, entries:[{seq,ts,id,title,source,capability,args}] } in the result.',
+            schema: {
+                type: 'object',
+                properties: {
+                    limit: { type: 'number' },
+                    source: { type: 'string', enum: ['human', 'ai'] },
+                },
+            },
+            capability: 'read',
+            firstClass: true,
+            surface: 'ui',
+            run: (args) => {
+                const limit = typeof args.limit === 'number' ? args.limit : undefined;
+                const source = args.source === 'human' || args.source === 'ai' ? args.source : undefined;
+                return { status: 'completed', stateDigest: readTrajectory({ limit, source }) };
+            },
+        });
+        const offClear = registerAction({
+            id: 'trajectory.clear',
+            title: '清空操作轨迹',
+            description: 'Clear the recorded UI operation trajectory buffer. Returns { cleared } — how many entries were removed.',
+            capability: 'write',
+            surface: 'ui',
+            run: () => ({ status: 'completed', stateDigest: { cleared: clearTrajectory() } }),
+        });
+        return () => {
+            stopRecording();
+            offSlice();
+            offRead();
+            offClear();
+        };
+    },
+};

package/dist/package/node/core/page-navigation.js

@@ -0,0 +1 @@
+export { extensionPageMatches, installPageNavigation, openExtensionPage, openPageType, openResource, resolveRegisteredOverlayId, } from '@forgeax/app-shell/application';

package/dist/package/node/core/page-platform/activity.js

@@ -0,0 +1,46 @@
+// Rail sort layers (§ActivityRegistration.sourceLayer). Lower rank ⇒ earlier;
+// builtin core nav always precedes plugins, which caps any plugin `order`.
+const LAYER_RANK = { builtin: 0, project: 1, installed: 2, user: 3 };
+// `order` default anchor.升序里 0 = 最靠前，等于把「未表态」翻译成「抢第一」——
+// 用居中锚点代替，未声明 order 的活动落层内中部，前后都留插空。
+const ORDER_BASE = 1000;
+// Absent / unknown layer ⇒ treated as installed (rank 2), so it sits with
+// plugins below builtin. Literal fallback keeps the return a plain `number`
+// under noUncheckedIndexedAccess.
+const layerRank = (layer) => LAYER_RANK[layer ?? 'installed'] ?? 2;
+export function createActivityRegistry(contributions, pages, commands) {
+    let cache;
+    const derive = () => {
+        const version = contributions.version();
+        if (cache?.version === version)
+            return cache.snapshot;
+        const activities = contributions.entries()
+            .flatMap(({ owner, item }) => (item.activities ?? []).map((activity) => ({ ...activity, owner })))
+            .sort((a, b) => layerRank(a.sourceLayer) - layerRank(b.sourceLayer)
+            || (a.order ?? ORDER_BASE) - (b.order ?? ORDER_BASE)
+            || a.id.localeCompare(b.id));
+        const snapshot = { generation: version, activities };
+        cache = { version, snapshot };
+        return snapshot;
+    };
+    return {
+        getSnapshot: derive,
+        subscribe(listener) {
+            return contributions.onChange(listener);
+        },
+        async launch(id) {
+            const activity = this.getSnapshot().activities.find((candidate) => candidate.id === id);
+            if (!activity)
+                throw new Error(`activity "${id}" is not registered`);
+            if (activity.pageTypeId) {
+                await pages.open({ typeId: activity.pageTypeId });
+                return;
+            }
+            if (activity.commandId) {
+                await commands.execute(activity.commandId);
+                return;
+            }
+            throw new Error(`activity "${id}" has no launch target`);
+        },
+    };
+}

package/dist/package/node/core/page-platform/dockview-layout.js

@@ -0,0 +1,63 @@
+function childSizes(node) {
+    if (node.sizes?.length === node.children.length)
+        return node.sizes;
+    return node.children.map(() => 1);
+}
+function compileNode(node, size, path, context) {
+    if (node.kind === 'tabs') {
+        const suffix = path.length > 0 ? path.join('-') : 'root';
+        const id = `page-${context.pageId}-${suffix}`;
+        context.groupIds.push(id);
+        return {
+            type: 'leaf',
+            size,
+            data: {
+                views: node.placements,
+                ...(node.active ? { activeView: node.active } : {}),
+                id,
+            },
+        };
+    }
+    const sizes = childSizes(node);
+    return {
+        type: 'branch',
+        size,
+        data: node.children.map((child, index) => compileNode(child, sizes[index], [...path, index], context)),
+    };
+}
+function rootChildren(layout, context) {
+    if (layout.root.kind === 'tabs') {
+        return [compileNode(layout.root, 1, [], context)];
+    }
+    const sizes = childSizes(layout.root);
+    return layout.root.children.map((child, index) => compileNode(child, sizes[index], [index], context));
+}
+/** Compile Page-owned semantic panel positions into Dockview's transport.
+ * The Page is the SSOT: pane names and panel implementation details never
+ * participate in layout decisions. */
+export function pageLayoutToDockview(pageId, pageTitle, placements, layout) {
+    const safePageId = pageId.replace(/[^a-z0-9.-]+/giu, '-').replace(/^-+|-+$/gu, '') || 'page';
+    const context = { pageId: safePageId, groupIds: [] };
+    const root = layout.root;
+    const rootSizes = root.kind === 'split' ? childSizes(root) : [1];
+    const total = rootSizes.reduce((sum, size) => sum + size, 0);
+    const horizontal = root.kind !== 'split' || root.direction === 'horizontal';
+    return {
+        grid: {
+            height: horizontal ? 800 : Math.max(800, total),
+            width: horizontal ? Math.max(1200, total) : 1200,
+            orientation: horizontal ? 'HORIZONTAL' : 'VERTICAL',
+            root: {
+                type: 'branch',
+                size: horizontal ? 800 : 1200,
+                data: rootChildren(layout, context),
+            },
+        },
+        panels: Object.fromEntries(placements.map((placement) => [placement.id, {
+                id: placement.id,
+                contentComponent: placement.id,
+                title: placement.title ?? (placements.length === 1 ? pageTitle : placement.id),
+            }])),
+        activeGroup: context.groupIds.at(-1),
+    };
+}

package/dist/package/node/core/page-platform/index.js

@@ -0,0 +1,8 @@
+export * from './types.js';
+export * from './registry.js';
+export * from './session.js';
+export * from './activity.js';
+export * from './resource-editor.js';
+export * from './layout-store.js';
+export * from './dockview-layout.js';
+export * from './page-dirty-probe.js';

package/dist/package/node/core/page-platform/layout-store.js

@@ -0,0 +1,54 @@
+function parseStoredPageLayout(raw) {
+    try {
+        const value = JSON.parse(raw);
+        if (value.schemaVersion !== 1
+            || typeof value.pageTypeId !== 'string'
+            || !Number.isInteger(value.layoutVersion)
+            || !value.layout
+            || typeof value.layout !== 'object')
+            return null;
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+export const pageLayoutStore = {
+    load(key, expected) {
+        let raw = null;
+        try {
+            raw = localStorage.getItem(key);
+        }
+        catch {
+            return null;
+        }
+        if (!raw)
+            return null;
+        const stored = parseStoredPageLayout(raw);
+        if (!stored
+            || stored.pageTypeId !== expected.pageTypeId
+            || stored.layoutVersion !== expected.layoutVersion) {
+            this.remove(key);
+            return null;
+        }
+        return stored.layout;
+    },
+    save(key, identity, layout) {
+        const stored = {
+            schemaVersion: 1,
+            pageTypeId: identity.pageTypeId,
+            layoutVersion: identity.layoutVersion,
+            layout,
+        };
+        try {
+            localStorage.setItem(key, JSON.stringify(stored));
+        }
+        catch { /* quota */ }
+    },
+    remove(key) {
+        try {
+            localStorage.removeItem(key);
+        }
+        catch { /* unavailable */ }
+    },
+};

package/dist/package/node/core/page-platform/page-dirty-probe.js

@@ -0,0 +1,4 @@
+// Compatibility export while application consumers migrate to App Shell.
+// The process-wide probe must have one module owner so an Editor registration
+// is visible to Interface page chrome in the same realm.
+export { isPageDirty, registerPageDirtyProbe, subscribePageDirty, } from '@forgeax/app-shell/application';

package/dist/package/node/core/page-platform/registry.js

@@ -0,0 +1,194 @@
+import { PagePlatformError } from './types.js';
+function ownerFromQualifiedId(id) {
+    const separator = id.indexOf('#');
+    return separator > 0 ? id.slice(0, separator) : undefined;
+}
+function sanitizeLayoutNode(node, allowed) {
+    if (node.kind === 'tabs') {
+        const placements = node.placements.filter((placement) => allowed.has(placement));
+        if (placements.length === 0)
+            return undefined;
+        return {
+            kind: 'tabs',
+            placements,
+            ...(node.active && placements.includes(node.active) ? { active: node.active } : {}),
+        };
+    }
+    const children = node.children
+        .map((child) => sanitizeLayoutNode(child, allowed))
+        .filter((child) => child !== undefined);
+    if (children.length === 0)
+        return undefined;
+    if (children.length === 1)
+        return children[0];
+    return {
+        kind: 'split',
+        direction: node.direction,
+        children,
+        ...(node.sizes?.length === children.length ? { sizes: node.sizes } : {}),
+    };
+}
+function sanitizedLayout(layout, allowed) {
+    return {
+        version: layout.version,
+        root: sanitizeLayoutNode(layout.root, allowed) ?? { kind: 'tabs', placements: [] },
+    };
+}
+function isPageLayoutEnvelope(layout) {
+    return 'version' in layout && 'root' in layout;
+}
+export function createPageRegistry(contributions) {
+    let cache;
+    const derive = () => {
+        const version = contributions.version();
+        if (cache?.version === version)
+            return cache.snapshot;
+        const panels = new Map();
+        const duplicatePanels = new Set();
+        const pages = new Map();
+        for (const entry of contributions.entries()) {
+            for (const panel of entry.item.panelTypes ?? []) {
+                if (panels.has(panel.id))
+                    duplicatePanels.add(panel.id);
+                else
+                    panels.set(panel.id, panel);
+            }
+            for (const page of entry.item.pageTypes ?? []) {
+                const registrations = pages.get(page.id) ?? [];
+                registrations.push({ owner: entry.owner, definition: page });
+                pages.set(page.id, registrations);
+            }
+        }
+        for (const id of duplicatePanels)
+            panels.delete(id);
+        const resolvedPages = new Map();
+        for (const [id, registrations] of pages) {
+            const first = registrations[0];
+            if (registrations.length > 1) {
+                resolvedPages.set(id, {
+                    status: 'unavailable',
+                    owner: first.owner,
+                    definition: first.definition,
+                    reason: 'duplicate-page-type',
+                    missingPanelTypeIds: [],
+                });
+                continue;
+            }
+            const missingRequired = [];
+            const resolvedPanels = first.definition.panels.flatMap((placement) => {
+                const panelType = panels.get(placement.panelTypeId);
+                if (!panelType) {
+                    if (!placement.optional)
+                        missingRequired.push(placement.panelTypeId);
+                    return [];
+                }
+                return [{ ...placement, panelType }];
+            });
+            if (missingRequired.length > 0) {
+                resolvedPages.set(id, {
+                    status: 'unavailable',
+                    owner: first.owner,
+                    definition: first.definition,
+                    reason: 'missing-required-panel',
+                    missingPanelTypeIds: missingRequired,
+                });
+                continue;
+            }
+            const allowed = new Set(resolvedPanels.map((placement) => placement.id));
+            resolvedPages.set(id, {
+                status: 'available',
+                owner: first.owner,
+                definition: first.definition,
+                panels: resolvedPanels,
+                layout: isPageLayoutEnvelope(first.definition.layout)
+                    ? sanitizedLayout(first.definition.layout, allowed)
+                    : first.definition.layout,
+            });
+        }
+        const snapshot = {
+            generation: version,
+            pageTypes: resolvedPages,
+            panelTypes: panels,
+        };
+        cache = { version, snapshot };
+        return snapshot;
+    };
+    return {
+        get(typeId) {
+            return derive().pageTypes.get(typeId);
+        },
+        ownerOf(typeId) {
+            return derive().pageTypes.get(typeId)?.owner;
+        },
+        getSnapshot: derive,
+        subscribe(listener) {
+            return contributions.onChange(listener);
+        },
+        validateContribution(owner, contribution) {
+            const existing = derive();
+            const pageIds = new Set();
+            const panelIds = new Set();
+            for (const panel of contribution.panelTypes ?? [])
+                panelIds.add(panel.id);
+            for (const page of contribution.pageTypes ?? []) {
+                if (ownerFromQualifiedId(page.id) !== owner) {
+                    throw new PagePlatformError('PAGE_CONTRIBUTION_OWNER_MISMATCH', `page type "${page.id}" does not belong to "${owner}"`, { owner, id: page.id });
+                }
+                if (pageIds.has(page.id) || existing.pageTypes.has(page.id)) {
+                    throw new PagePlatformError('PAGE_CONTRIBUTION_CONFLICT', `page type "${page.id}" is already registered`, { owner, id: page.id });
+                }
+                pageIds.add(page.id);
+                const placementIds = new Set();
+                for (const placement of page.panels) {
+                    if (placementIds.has(placement.id)) {
+                        throw new PagePlatformError('PAGE_CONTRIBUTION_CONFLICT', `page type "${page.id}" declares placement "${placement.id}" more than once`, { owner, id: page.id, placementId: placement.id });
+                    }
+                    placementIds.add(placement.id);
+                    if (!placement.optional &&
+                        !panelIds.has(placement.panelTypeId) &&
+                        !existing.panelTypes.has(placement.panelTypeId)) {
+                        throw new PagePlatformError('PAGE_TYPE_UNAVAILABLE', `page type "${page.id}" requires missing panel type "${placement.panelTypeId}"`, { owner, id: page.id, panelTypeId: placement.panelTypeId });
+                    }
+                }
+            }
+            for (const panel of contribution.panelTypes ?? []) {
+                if (ownerFromQualifiedId(panel.id) !== owner) {
+                    throw new PagePlatformError('PAGE_CONTRIBUTION_OWNER_MISMATCH', `panel type "${panel.id}" does not belong to "${owner}"`, { owner, id: panel.id });
+                }
+                if ((contribution.panelTypes ?? []).filter((candidate) => candidate.id === panel.id).length > 1 ||
+                    existing.panelTypes.has(panel.id)) {
+                    throw new PagePlatformError('PAGE_CONTRIBUTION_CONFLICT', `panel type "${panel.id}" is already registered`, { owner, id: panel.id });
+                }
+            }
+            const knownPage = (id) => pageIds.has(id) || existing.pageTypes.has(id);
+            const contributionIds = new Set();
+            for (const activity of contribution.activities ?? []) {
+                if (ownerFromQualifiedId(activity.id) !== owner) {
+                    throw new PagePlatformError('PAGE_CONTRIBUTION_OWNER_MISMATCH', `activity "${activity.id}" does not belong to "${owner}"`);
+                }
+                if (contributionIds.has(activity.id)) {
+                    throw new PagePlatformError('PAGE_CONTRIBUTION_CONFLICT', `activity "${activity.id}" is already registered`);
+                }
+                contributionIds.add(activity.id);
+                if (Number(Boolean(activity.pageTypeId)) + Number(Boolean(activity.commandId)) !== 1) {
+                    throw new PagePlatformError('PAGE_TYPE_UNAVAILABLE', `activity "${activity.id}" must have exactly one launch target`);
+                }
+                if (activity.pageTypeId && !knownPage(activity.pageTypeId)) {
+                    throw new PagePlatformError('PAGE_TYPE_UNAVAILABLE', `activity "${activity.id}" references missing page type "${activity.pageTypeId}"`);
+                }
+            }
+            for (const editor of contribution.resourceEditors ?? []) {
+                if (ownerFromQualifiedId(editor.id) !== owner) {
+                    throw new PagePlatformError('PAGE_CONTRIBUTION_OWNER_MISMATCH', `resource editor "${editor.id}" does not belong to "${owner}"`);
+                }
+                if (contributionIds.has(editor.id)) {
+                    throw new PagePlatformError('PAGE_CONTRIBUTION_CONFLICT', `resource editor "${editor.id}" is already registered`);
+                }
+                contributionIds.add(editor.id);
+                if (!knownPage(editor.pageTypeId)) {
+                    throw new PagePlatformError('PAGE_TYPE_UNAVAILABLE', `resource editor "${editor.id}" references missing page type "${editor.pageTypeId}"`);
+                }
+            }
+        },
+    };
+}