@fps-games/editor 0.1.8 → 0.2.0-beta.2

package/node_modules/@fps-games/editor-core/dist/editor-plugin-host.js

@@ -0,0 +1,759 @@
+import { defineFpsServiceToken, defineFpsPluginEntry, resolveFpsPluginEnvironmentScopes, } from '@fps-games/plugin-api';
+import { createFpsPluginHost, } from '@fps-games/plugin-host';
+import { EDITOR_AGENT_BRIDGE_SCHEMA_VERSION, } from '@fps-games/editor-protocol';
+import { FPS_EDITOR_DIAGNOSTIC_REPORTED, createFpsEditorEventPublisher, } from './events.js';
+import { FPS_EDITOR_LIFECYCLE_TRANSITION_TYPES, assertFpsEditorLifecycleScopeTopology, } from './lifecycle.js';
+const UNAVAILABLE_EDITOR_EVENT_ROUTE = Object.freeze({
+    subscribe: () => () => { },
+    publish: () => Promise.resolve(),
+});
+const contributionRegistrars = new WeakMap();
+const trustedContributionContexts = new WeakMap();
+const CONTRIBUTION_KINDS = new Set([
+    'hierarchy', 'inspector', 'panel', 'command', 'capability', 'lifecycle-participant',
+]);
+export const FPS_EDITOR_CONTRIBUTIONS = defineFpsServiceToken('fps.editor.contributions');
+const lifecycleScopeHostFactories = new WeakMap();
+function createEditorPluginCleanupError(message, errors) {
+    const details = errors.map(error => error instanceof Error ? error.message : String(error)).join('; ');
+    const combined = new Error(`${message}: ${details}`);
+    combined.errors = [...errors];
+    return combined;
+}
+export function getFpsEditorPluginLifecycleScopeHost(host) {
+    const createScopeHost = lifecycleScopeHostFactories.get(host);
+    if (!createScopeHost)
+        throw new Error('Editor Plugin lifecycle scope host is unavailable.');
+    return createScopeHost();
+}
+const editorCommandDispatchers = new WeakMap();
+export function registerFpsEditorCommand(context, registration, handler) {
+    const trusted = requireTrustedContributionContext(context);
+    assertApplicationContributionScope(context);
+    const snapshot = snapshotEditorCommandRegistration(registration);
+    const unregisterHandler = context.commands.register(snapshot.command, handler);
+    trusted.addDisposer(unregisterHandler);
+    try {
+        const contribution = Object.freeze({
+            type: 'editor.command',
+            registration: snapshot,
+        });
+        editorCommandDispatchers.set(contribution, context.commands);
+        registerFpsEditorContribution(context, {
+            id: snapshot.command.id,
+            kind: 'command',
+            value: contribution,
+        });
+    }
+    catch (error) {
+        unregisterHandler();
+        throw error;
+    }
+}
+export function registerFpsEditorLifecycleParticipant(context, participant) {
+    const snapshot = snapshotEditorLifecycleParticipant(participant);
+    return registerFpsEditorContribution(context, {
+        id: snapshot.id,
+        kind: 'lifecycle-participant',
+        value: snapshot,
+    });
+}
+export function resolveFpsEditorLifecycleParticipants(registry) {
+    return registry.list('lifecycle-participant').map(contribution => {
+        const participant = snapshotEditorLifecycleParticipant(contribution.value);
+        if (participant.id !== contribution.id) {
+            throw new Error(`Editor lifecycle participant contribution id mismatch: ${contribution.id} != ${participant.id}`);
+        }
+        return participant;
+    });
+}
+export function createFpsEditorContributionRegistry() {
+    const entries = new Map();
+    const registry = {
+        get: id => entries.get(id),
+        list: kind => {
+            if (kind !== undefined)
+                assertContributionKind(kind);
+            return [...entries.values()]
+                .filter(entry => kind === undefined || entry.kind === kind)
+                .sort(compareContributions);
+        },
+    };
+    contributionRegistrars.set(registry, (pluginId, contribution) => {
+        const id = assertContributionId(contribution.id);
+        const kind = assertContributionKind(contribution.kind);
+        if (entries.has(id))
+            throw new Error(`Duplicate editor contribution id: ${id}`);
+        const entry = Object.freeze({
+            ...contribution,
+            id,
+            kind,
+            pluginId,
+            priority: normalizePriority(contribution.priority),
+        });
+        entries.set(id, entry);
+        let active = true;
+        return () => {
+            if (!active)
+                return;
+            active = false;
+            if (entries.get(id) === entry)
+                entries.delete(id);
+        };
+    });
+    return registry;
+}
+export function registerFpsEditorContribution(context, contribution) {
+    const trusted = requireTrustedContributionContext(context);
+    assertApplicationContributionScope(context);
+    const declaredRegistry = context.services.get(FPS_EDITOR_CONTRIBUTIONS);
+    if (declaredRegistry !== trusted.registry) {
+        throw new Error('Editor contribution service does not belong to this Plugin Host.');
+    }
+    const register = contributionRegistrars.get(trusted.registry);
+    if (!register)
+        throw new Error('Editor contribution registry is not owned by this host.');
+    if (contribution.kind === 'lifecycle-participant') {
+        snapshotEditorLifecycleParticipant(contribution.value);
+    }
+    const unregister = register(trusted.pluginId, contribution);
+    trusted.addDisposer(unregister);
+    let active = true;
+    return () => {
+        if (!active || !trusted.registrationOpen)
+            return;
+        active = false;
+        return unregister();
+    };
+}
+export function createFpsEditorPluginHost(options) {
+    const contributions = createFpsEditorContributionRegistry();
+    const consumers = new Map();
+    let nextConsumerId = 1;
+    let lifecycleTransitioning = false;
+    let activeLifecycleScopeTransitions = 0;
+    let lifecycleCleanupFailed = false;
+    let cleanupRetryKind = null;
+    const lifecycleScopes = new Map();
+    const failedLifecycleScopeIds = new Set();
+    const editorDiagnostics = [];
+    let eventPublisher;
+    const reportEditorDiagnostic = (diagnostic, publishEvent, context = { scope: 'application', scopeId: 'editor:application' }) => {
+        editorDiagnostics.push(Object.freeze({
+            code: diagnostic.code,
+            message: diagnostic.message,
+            severity: diagnostic.severity,
+            ...(diagnostic.pluginId ? { pluginId: diagnostic.pluginId } : {}),
+        }));
+        if (editorDiagnostics.length > 200)
+            editorDiagnostics.shift();
+        try {
+            options.report?.(diagnostic);
+        }
+        catch { /* Diagnostic observers cannot affect Plugin or Editor lifecycle state. */ }
+        if (!publishEvent || !eventPublisher
+            || diagnostic.details?.eventId === FPS_EDITOR_DIAGNOSTIC_REPORTED.id)
+            return;
+        void eventPublisher.publish(FPS_EDITOR_DIAGNOSTIC_REPORTED, Object.freeze({
+            diagnostic: Object.freeze({
+                code: diagnostic.code,
+                message: diagnostic.message,
+                severity: diagnostic.severity,
+                ...(diagnostic.pluginId ? { pluginId: diagnostic.pluginId } : {}),
+            }),
+        }), {
+            ...context,
+            ...(context.sourcePluginId || !diagnostic.pluginId ? {} : { sourcePluginId: diagnostic.pluginId }),
+        });
+    };
+    const hasLifecycleCleanupFailure = () => (lifecycleCleanupFailed || failedLifecycleScopeIds.size > 0);
+    const applicationManifests = options.manifests.filter(manifest => (resolveFpsPluginEnvironmentScopes(manifest, 'editor').includes('application')));
+    const host = createFpsPluginHost({
+        environment: 'editor',
+        apiVersion: 1,
+        scope: 'application',
+        manifests: applicationManifests,
+        initialServices: [
+            { token: FPS_EDITOR_CONTRIBUTIONS, value: contributions },
+            ...(options.initialServices ?? []),
+        ],
+        pluginConfigs: options.pluginConfigs,
+        loadEntry: async (manifest, environment) => {
+            const entry = await options.loadEntry(manifest, environment);
+            return entry ? bindEditorPluginEntry(defineFpsPluginEntry(entry), contributions) : null;
+        },
+        report: diagnostic => reportEditorDiagnostic(diagnostic, true),
+    });
+    eventPublisher = createFpsEditorEventPublisher({
+        events: host.events,
+        captureRoute(context) {
+            const route = [];
+            let record = lifecycleScopes.get(context.scopeId);
+            while (record) {
+                route.push(record);
+                record = record.input.parentId ? lifecycleScopes.get(record.input.parentId) : undefined;
+            }
+            return () => {
+                for (const candidate of route) {
+                    if (lifecycleScopes.get(candidate.input.id) !== candidate
+                        || candidate.closeRequested
+                        || candidate.closing)
+                        continue;
+                    const routeHost = candidate.host ?? host;
+                    if (routeHost.state !== 'started' || routeHost.transitioning)
+                        continue;
+                    return routeHost.events;
+                }
+                // Scope-close facts are delivered asynchronously. A parent teardown can
+                // reserve the complete host tree before an earlier child-close fact
+                // reaches this resolver. In that interval public event operations are
+                // intentionally unavailable, and every observer on that route is also
+                // being torn down. Treat the route as closed instead of reporting an
+                // observer failure for a lifecycle state that is working as designed.
+                return host.state === 'started' && !host.transitioning
+                    ? host.events
+                    : UNAVAILABLE_EDITOR_EVENT_ROUTE;
+            };
+        },
+        report: diagnostic => reportEditorDiagnostic(diagnostic, false),
+    });
+    const isLifecycleTransitioning = () => (lifecycleTransitioning || activeLifecycleScopeTransitions > 0 || host.transitioning);
+    const assertStableObservation = () => {
+        if (hasLifecycleCleanupFailure()) {
+            throw new Error('Editor Plugin Host cleanup is incomplete; only cleanup retry operations are available.');
+        }
+        if (isLifecycleTransitioning()) {
+            throw new Error('Editor Plugin Host observation is unavailable during a lifecycle transition.');
+        }
+    };
+    const publicContributions = Object.freeze({
+        get(id) {
+            assertStableObservation();
+            return contributions.get(id);
+        },
+        list(kind) {
+            assertStableObservation();
+            return contributions.list(kind);
+        },
+    });
+    const runLifecycleScopeTransition = async (operation) => {
+        activeLifecycleScopeTransitions += 1;
+        try {
+            return await operation();
+        }
+        finally {
+            activeLifecycleScopeTransitions -= 1;
+        }
+    };
+    const acquireConsumer = (label = 'anonymous') => {
+        const transitioning = isLifecycleTransitioning();
+        if (host.state !== 'started' || transitioning || hasLifecycleCleanupFailure()) {
+            throw new Error(`Editor Plugin Host consumers require an idle started host, got: ${hasLifecycleCleanupFailure() ? 'cleanup-failed' : host.state}${transitioning ? ' (transitioning)' : ''}`);
+        }
+        const id = nextConsumerId++;
+        consumers.set(id, label);
+        let active = true;
+        return () => {
+            if (!active)
+                return;
+            active = false;
+            consumers.delete(id);
+        };
+    };
+    const openLifecycleScope = async (owner, input) => {
+        const existing = lifecycleScopes.get(input.id);
+        if (existing) {
+            if (existing.input.scope !== input.scope || existing.input.parentId !== input.parentId) {
+                throw new Error(`Editor Plugin lifecycle scope identity conflicts with the existing scope: ${input.id}`);
+            }
+            if (existing.owner !== owner) {
+                throw new Error(`Editor Plugin lifecycle scope is owned by another controller: ${input.id}`);
+            }
+            if (failedLifecycleScopeIds.has(input.id)) {
+                throw new Error(`Editor Plugin lifecycle scope cleanup is incomplete; close must be retried: ${input.id}`);
+            }
+            if (existing.closing)
+                throw new Error(`Editor Plugin lifecycle scope is closing: ${input.id}`);
+            return existing.ready;
+        }
+        const transitioning = lifecycleTransitioning || host.transitioning;
+        if (host.state !== 'started' || transitioning || hasLifecycleCleanupFailure()) {
+            throw new Error(`Editor Plugin lifecycle scopes require an idle started host, got: ${hasLifecycleCleanupFailure() ? 'cleanup-failed' : host.state}${transitioning ? ' (transitioning)' : ''}`);
+        }
+        assertFpsEditorLifecycleScopeTopology(input, [...lifecycleScopes.values()].map(record => ({
+            id: record.input.id,
+            scope: record.input.scope,
+            state: record.closing ? 'failed' : 'open',
+        })));
+        if (input.scope === 'application') {
+            lifecycleScopes.set(input.id, {
+                input: Object.freeze({ ...input }),
+                owner,
+                host: null,
+                ready: Promise.resolve(),
+                closing: null,
+                closeRequested: false,
+                releaseTeardownReservation: null,
+            });
+            return;
+        }
+        const parent = lifecycleScopes.get(input.parentId);
+        if (!parent || parent.closing) {
+            throw new Error(`Editor Plugin lifecycle parent scope is not open: ${input.parentId}`);
+        }
+        if (parent.owner !== owner) {
+            throw new Error(`Editor Plugin lifecycle parent scope is owned by another controller: ${input.parentId}`);
+        }
+        const childScope = input.scope;
+        const scopedManifests = options.manifests.filter(manifest => (resolveFpsPluginEnvironmentScopes(manifest, 'editor').includes(childScope)));
+        const record = {
+            input: Object.freeze({ ...input }),
+            owner,
+            host: null,
+            ready: Promise.resolve(),
+            closing: null,
+            closeRequested: false,
+            releaseTeardownReservation: null,
+        };
+        lifecycleScopes.set(input.id, record);
+        record.ready = parent.ready.then(async () => {
+            const child = (parent.host ?? host).createScope({ scope: childScope, manifests: scopedManifests });
+            record.host = child;
+            if (record.closeRequested) {
+                record.releaseTeardownReservation = child.reserveTeardown();
+                return;
+            }
+            await child.start();
+        }).catch(async (error) => {
+            let cleanupError;
+            try {
+                await record.host?.dispose();
+            }
+            catch (caught) {
+                cleanupError = caught;
+            }
+            if (!record.host || record.host.state === 'disposed') {
+                if (lifecycleScopes.get(input.id) === record)
+                    lifecycleScopes.delete(input.id);
+            }
+            if (cleanupError) {
+                failedLifecycleScopeIds.add(input.id);
+                cleanupRetryKind = 'dispose';
+                const combined = new Error('Editor Plugin lifecycle scope start and cleanup failed.');
+                combined.errors = [error, cleanupError];
+                throw combined;
+            }
+            throw error;
+        });
+        await record.ready;
+    };
+    const reserveLifecycleScopeClose = (scopeId, owner) => {
+        const record = lifecycleScopes.get(scopeId);
+        if (!record)
+            return null;
+        if (owner && record.owner !== owner) {
+            throw new Error(`Editor Plugin lifecycle scope is owned by another controller: ${scopeId}`);
+        }
+        record.closeRequested = true;
+        record.releaseTeardownReservation ?? (record.releaseTeardownReservation = record.input.scope === 'application'
+            ? host.reserveTeardown()
+            : record.host?.reserveTeardown() ?? null);
+        try {
+            record.releaseTeardownReservation?.assertReady();
+        }
+        catch (error) {
+            failedLifecycleScopeIds.add(scopeId);
+            cleanupRetryKind = 'dispose';
+            throw error;
+        }
+        return record;
+    };
+    const closeLifecycleScope = async (scopeId, owner) => {
+        const record = reserveLifecycleScopeClose(scopeId, owner);
+        if (!record)
+            return;
+        if (record.closing)
+            return record.closing;
+        record.closing = (async () => {
+            try {
+                try {
+                    await record.ready;
+                }
+                catch { /* The open caller already received the start failure. */ }
+                const children = [...lifecycleScopes.values()]
+                    .filter(candidate => candidate.input.parentId === scopeId)
+                    .reverse();
+                const childErrors = [];
+                for (const child of children) {
+                    try {
+                        await closeLifecycleScope(child.input.id, owner);
+                    }
+                    catch (error) {
+                        childErrors.push(error);
+                        break;
+                    }
+                }
+                if (childErrors.length > 0) {
+                    throw createEditorPluginCleanupError(`Editor Plugin lifecycle child scope cleanup failed: ${scopeId}`, childErrors);
+                }
+                if (record.host?.state !== 'disposed')
+                    await record.host?.dispose();
+                failedLifecycleScopeIds.delete(scopeId);
+                lifecycleScopes.delete(scopeId);
+            }
+            catch (error) {
+                const scopeCleanupFailed = record.host?.state === 'cleanup-failed'
+                    || [...lifecycleScopes.values()].some(candidate => (candidate.input.parentId === scopeId && failedLifecycleScopeIds.has(candidate.input.id)));
+                if (scopeCleanupFailed) {
+                    failedLifecycleScopeIds.add(scopeId);
+                    cleanupRetryKind ?? (cleanupRetryKind = 'dispose');
+                }
+                throw error;
+            }
+            finally {
+                if (lifecycleScopes.get(scopeId) === record) {
+                    record.closing = null;
+                }
+                else {
+                    record.releaseTeardownReservation?.();
+                    record.releaseTeardownReservation = null;
+                }
+            }
+        })();
+        return record.closing;
+    };
+    const closeLifecycleScopeRoots = async () => {
+        const roots = [...lifecycleScopes.values()]
+            .filter(record => !record.input.parentId)
+            .reverse();
+        const errors = [];
+        for (const root of roots) {
+            try {
+                await closeLifecycleScope(root.input.id);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (errors.length > 0) {
+            throw createEditorPluginCleanupError('Editor Plugin lifecycle root scope cleanup failed', errors);
+        }
+    };
+    const editorHost = {
+        get state() { return hasLifecycleCleanupFailure() ? 'cleanup-failed' : host.state; },
+        get transitioning() { return isLifecycleTransitioning(); },
+        contributions: publicContributions,
+        eventPublisher,
+        reportDiagnostic(diagnostic, context = { scope: 'application', scopeId: 'editor:application' }) {
+            reportEditorDiagnostic(diagnostic, true, context);
+        },
+        inspect: () => {
+            const inspection = host.inspect();
+            return Object.freeze({
+                ...inspection,
+                ...(hasLifecycleCleanupFailure() ? { state: 'cleanup-failed' } : {}),
+                transitioning: isLifecycleTransitioning(),
+                diagnostics: Object.freeze([...editorDiagnostics]),
+            });
+        },
+        acquireConsumer,
+        listCommands: () => {
+            assertStableObservation();
+            return resolveEditorCommandRegistrations(contributions);
+        },
+        executeCommand(command, input) {
+            const transitioning = isLifecycleTransitioning();
+            if (host.state !== 'started' || transitioning || hasLifecycleCleanupFailure()) {
+                throw new Error(`Editor Plugin Host commands require an idle started host, got: ${hasLifecycleCleanupFailure() ? 'cleanup-failed' : host.state}${transitioning ? ' (transitioning)' : ''}`);
+            }
+            const contribution = resolveEditorCommandContribution(contributions, command.id);
+            if (!contribution)
+                throw new Error(`Editor command is not contributed by this host: ${command.id}`);
+            const dispatcher = editorCommandDispatchers.get(contribution);
+            if (!dispatcher)
+                throw new Error(`Editor command dispatcher is unavailable: ${command.id}`);
+            const release = acquireConsumer(`command:${command.id}`);
+            return dispatcher.execute(command, input).finally(() => {
+                release();
+            });
+        },
+        start: () => host.start(),
+        stop: () => {
+            assertNoEditorPluginHostConsumers(consumers, 'stop');
+            if (lifecycleTransitioning)
+                throw new Error('Editor Plugin Host lifecycle is already transitioning.');
+            if (hasLifecycleCleanupFailure() && cleanupRetryKind === 'dispose') {
+                throw new Error('Editor Plugin Host disposal cleanup is incomplete; dispose or the owning scope close must be retried.');
+            }
+            lifecycleTransitioning = true;
+            cleanupRetryKind = 'stop';
+            return (async () => {
+                try {
+                    await closeLifecycleScopeRoots();
+                    await host.stop();
+                    lifecycleCleanupFailed = false;
+                    cleanupRetryKind = null;
+                }
+                catch (error) {
+                    lifecycleCleanupFailed = true;
+                    throw error;
+                }
+                finally {
+                    lifecycleTransitioning = false;
+                }
+            })();
+        },
+        dispose: () => {
+            assertNoEditorPluginHostConsumers(consumers, 'dispose');
+            if (lifecycleTransitioning)
+                throw new Error('Editor Plugin Host lifecycle is already transitioning.');
+            lifecycleTransitioning = true;
+            cleanupRetryKind = 'dispose';
+            return (async () => {
+                try {
+                    await closeLifecycleScopeRoots();
+                    await host.dispose();
+                    lifecycleCleanupFailed = false;
+                    cleanupRetryKind = null;
+                }
+                catch (error) {
+                    lifecycleCleanupFailed = true;
+                    throw error;
+                }
+                finally {
+                    lifecycleTransitioning = false;
+                }
+            })();
+        },
+    };
+    lifecycleScopeHostFactories.set(editorHost, () => {
+        const owner = Object.freeze({});
+        const scopeHost = {
+            openScope: input => runLifecycleScopeTransition(() => openLifecycleScope(owner, input)),
+            reserveScopeClose: scopeId => { reserveLifecycleScopeClose(scopeId, owner); },
+            closeScope: scopeId => runLifecycleScopeTransition(async () => {
+                await closeLifecycleScope(scopeId, owner);
+                if (!hasLifecycleCleanupFailure() && !lifecycleTransitioning)
+                    cleanupRetryKind = null;
+            }),
+        };
+        return Object.freeze(scopeHost);
+    });
+    return editorHost;
+}
+export function createFpsEditorPluginHostFromEnvironmentModule(options) {
+    if (options.module.environment !== 'editor') {
+        throw new Error(`Editor Plugin Host requires an editor environment module, got: ${options.module.environment}`);
+    }
+    const entries = new Map();
+    for (const entry of options.module.entries) {
+        if (entries.has(entry.pluginId))
+            throw new Error(`Duplicate Editor Plugin module entry: ${entry.pluginId}`);
+        entries.set(entry.pluginId, entry);
+    }
+    return createFpsEditorPluginHost({
+        manifests: options.module.manifests,
+        pluginConfigs: options.module.pluginConfigs,
+        initialServices: options.initialServices,
+        report: options.report,
+        async loadEntry(manifest) {
+            const entry = entries.get(manifest.id);
+            if (!entry)
+                throw new Error(`Editor Plugin module entry is missing: ${manifest.id}`);
+            return entry.load();
+        },
+    });
+}
+function requireTrustedContributionContext(context) {
+    const trusted = trustedContributionContexts.get(context);
+    if (!trusted)
+        throw new Error('Editor contribution registration requires a host-authenticated Plugin context.');
+    if (!trusted.registrationOpen) {
+        throw new Error('Editor contributions may only be registered during the Plugin register lifecycle.');
+    }
+    return trusted;
+}
+function assertApplicationContributionScope(context) {
+    if (context.scope !== 'application') {
+        throw new Error(`Editor contributions are application-scope extension definitions; ${context.scope} scopes may own resources but cannot register global contributions.`);
+    }
+}
+function resolveEditorCommandRegistrations(registry) {
+    return registry.list('command').map(contribution => {
+        const value = contribution.value;
+        if (!isEditorCommandContribution(value) || value.registration.command.id !== contribution.id) {
+            throw new Error(`Invalid Editor command contribution: ${contribution.id}`);
+        }
+        return value.registration;
+    });
+}
+function resolveEditorCommandContribution(registry, commandId) {
+    const contribution = registry.get(commandId);
+    if (!contribution || contribution.kind !== 'command')
+        return null;
+    const value = contribution.value;
+    if (!isEditorCommandContribution(value) || value.registration.command.id !== commandId) {
+        throw new Error(`Invalid Editor command contribution: ${commandId}`);
+    }
+    return value;
+}
+function isEditorCommandContribution(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const contribution = value;
+    return contribution.type === 'editor.command'
+        && !!contribution.registration
+        && contribution.registration.command?.kind === 'command';
+}
+function snapshotEditorCommandRegistration(registration) {
+    if (registration.command?.kind !== 'command')
+        throw new Error('Editor command registration requires a command token.');
+    const title = registration.title?.trim();
+    if (!title)
+        throw new Error(`Editor command title is required: ${registration.command.id}`);
+    const description = registration.description?.trim();
+    const agent = registration.agent
+        ? snapshotEditorAgentCapability(registration.command.id, registration.agent)
+        : undefined;
+    return Object.freeze({
+        command: registration.command,
+        title,
+        ...(description ? { description } : {}),
+        ...(agent ? { agent } : {}),
+    });
+}
+function snapshotEditorLifecycleParticipant(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Editor lifecycle participant must be an object.');
+    }
+    const participant = value;
+    const id = assertContributionId(participant.id ?? '');
+    if (!Array.isArray(participant.transitions) || participant.transitions.length === 0) {
+        throw new Error(`Editor lifecycle participant transitions are required: ${id}`);
+    }
+    const allowed = new Set(FPS_EDITOR_LIFECYCLE_TRANSITION_TYPES);
+    const transitions = participant.transitions.map(transition => {
+        if (typeof transition !== 'string' || !allowed.has(transition)) {
+            throw new Error(`Editor lifecycle participant transition is invalid: ${id} -> ${String(transition)}`);
+        }
+        return transition;
+    });
+    for (const method of ['prepare', 'settled', 'failed']) {
+        if (participant[method] !== undefined && typeof participant[method] !== 'function') {
+            throw new Error(`Editor lifecycle participant ${method} must be a function: ${id}`);
+        }
+    }
+    return Object.freeze({
+        id,
+        transitions: Object.freeze([...new Set(transitions)]),
+        ...(participant.prepare ? { prepare: participant.prepare } : {}),
+        ...(participant.settled ? { settled: participant.settled } : {}),
+        ...(participant.failed ? { failed: participant.failed } : {}),
+    });
+}
+function snapshotEditorAgentCapability(commandId, manifest) {
+    if (manifest.schemaVersion !== EDITOR_AGENT_BRIDGE_SCHEMA_VERSION) {
+        throw new Error(`Editor command Agent capability schema mismatch: ${commandId}`);
+    }
+    if (manifest.id !== commandId) {
+        throw new Error(`Editor command and Agent capability ids must match: ${commandId} != ${manifest.id}`);
+    }
+    if (!manifest.title?.trim())
+        throw new Error(`Editor command Agent capability title is required: ${commandId}`);
+    if (manifest.access !== 'read' && manifest.access !== 'write') {
+        throw new Error(`Editor command Agent capability access is invalid: ${commandId}`);
+    }
+    return Object.freeze({
+        ...manifest,
+        title: manifest.title.trim(),
+        ...(manifest.description?.trim() ? { description: manifest.description.trim() } : {}),
+        ...(manifest.inputSchema ? { inputSchema: cloneEditorJsonObject(manifest.inputSchema) } : {}),
+        ...(manifest.outputSchema ? { outputSchema: cloneEditorJsonObject(manifest.outputSchema) } : {}),
+    });
+}
+function cloneEditorJsonObject(value) {
+    return cloneEditorJsonValue(value, '$');
+}
+function cloneEditorJsonValue(value, path) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (Array.isArray(value)) {
+        return Object.freeze(value.map((entry, index) => cloneEditorJsonValue(entry, `${path}[${index}]`)));
+    }
+    if (!value || typeof value !== 'object')
+        throw new Error(`Editor Agent schema contains invalid value at ${path}`);
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new Error(`Editor Agent schema must contain plain objects at ${path}`);
+    }
+    const result = {};
+    for (const key of Object.keys(value)) {
+        result[key] = cloneEditorJsonValue(value[key], `${path}.${key}`);
+    }
+    return Object.freeze(result);
+}
+function assertNoEditorPluginHostConsumers(consumers, operation) {
+    if (consumers.size === 0)
+        return;
+    throw new Error(`Cannot ${operation} Editor Plugin Host with active consumers: ${[...consumers.values()].join(', ')}`);
+}
+function bindEditorPluginEntry(entry, registry) {
+    return {
+        pluginId: entry.pluginId,
+        environment: entry.environment,
+        async register(context) {
+            const trusted = {
+                registry,
+                pluginId: context.pluginId,
+                registrationOpen: true,
+                addDisposer: context.add.bind(context),
+            };
+            trustedContributionContexts.set(context, trusted);
+            try {
+                return await entry.register(context);
+            }
+            finally {
+                trusted.registrationOpen = false;
+            }
+        },
+        ...(entry.start ? { start: (context) => entry.start(context) } : {}),
+        ...(entry.stop ? { stop: (context) => entry.stop(context) } : {}),
+        dispose: async (context) => {
+            try {
+                await entry.dispose?.(context);
+            }
+            finally {
+                trustedContributionContexts.delete(context);
+            }
+        },
+    };
+}
+function assertContributionId(id) {
+    const normalized = id.trim();
+    if (!/^[a-z0-9]+(?:[._-][a-z0-9]+)+$/.test(normalized)) {
+        throw new Error(`Editor contribution id must be namespaced lowercase, got: ${id}`);
+    }
+    return normalized;
+}
+function normalizePriority(priority) {
+    if (priority === undefined)
+        return 0;
+    if (!Number.isFinite(priority))
+        throw new Error('Editor contribution priority must be finite.');
+    return priority;
+}
+function assertContributionKind(value) {
+    if (typeof value !== 'string' || !CONTRIBUTION_KINDS.has(value)) {
+        throw new Error(`Unknown editor contribution kind: ${String(value)}`);
+    }
+    return value;
+}
+function compareContributions(left, right) {
+    const priority = (right.priority ?? 0) - (left.priority ?? 0);
+    if (priority !== 0)
+        return priority;
+    return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+}
+//# sourceMappingURL=editor-plugin-host.js.map