@fps-games/editor 0.2.1-beta.3 → 0.2.1-beta.4

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

@@ -0,0 +1,1211 @@
+import { EDITOR_COMMAND_SCHEMA_VERSION, } from '@fps-games/editor-protocol';
+import { createEditorCommandSystem, } from './editor-command-system.js';
+import { callWithEditorSessionWriteAuthority, claimEditorSessionWriteAuthority, releaseEditorSessionWriteAuthority, runWithEditorSessionWriteAuthority, } from './editor-session-authority.js';
+import { authorizeCommandComposedRegistration } from './editor-command-composed-authority.js';
+const CALL_WITH_SERIALIZED_SESSION_AUTHORITY = Symbol('fps.editor.call-with-serialized-session-authority');
+/** @internal Adapter used by command handlers that already own the Host FIFO. */
+export function callWithEditorAuthoringSerializedAccess(access, handler) {
+    if (!access || typeof access !== 'object'
+        || !(CALL_WITH_SERIALIZED_SESSION_AUTHORITY in access)) {
+        throw new Error('Editor Authoring Host serialized access is invalid or expired.');
+    }
+    return access[CALL_WITH_SERIALIZED_SESSION_AUTHORITY](handler);
+}
+/** @internal Operation-scoped Session façade for a handler that already owns serialized Host access. */
+export function createEditorAuthoringSerializedSessionView(session, serializedAccess) {
+    return createOperationScopedSessionView(session, () => callWithEditorAuthoringSerializedAccess(serializedAccess, () => undefined), handler => callWithEditorAuthoringSerializedAccess(serializedAccess, handler));
+}
+const DEFAULT_EVENT_LIMIT = 200;
+const DEFAULT_HISTORY_VIEW_LIMIT = 200;
+const EXTERNAL_COMMAND_SESSION_VIEW_METHODS = new Set([
+    'getState',
+    'getWorkingDocument',
+    'getSource',
+    'getSelection',
+    'isDirty',
+    'canUndo',
+    'canRedo',
+    'dispatch',
+    'undo',
+    'redo',
+    'rebaseExternalDocuments',
+]);
+const SESSION_AUTHORITY_OWNERS = new WeakMap();
+const HOST_EXTERNAL_COMMAND_REGISTRARS = new WeakMap();
+/** @internal Registration path bound to the Host that owns authoring authority. */
+export function registerEditorAuthoringHostExternalCommand(host, registration) {
+    const register = HOST_EXTERNAL_COMMAND_REGISTRARS.get(host);
+    if (!register)
+        throw new Error('Editor Authoring Host external command registration authority is unavailable.');
+    return register(registration);
+}
+export function createEditorAuthoringHost(options) {
+    const serviceInstanceId = normalizeRequiredId(options.serviceInstanceId, 'serviceInstanceId');
+    const commandSystem = options.commandSystem ?? createEditorCommandSystem(options.commandSystemOptions);
+    const ownsCommandSystem = options.commandSystem === undefined;
+    const sessionAuthorityOwner = Object.freeze({ serviceInstanceId });
+    const claimedSessions = new Set();
+    const reservedSessionCounts = new Map();
+    const trackedSessions = new Set();
+    let sessionClaimsReleased = false;
+    const assertSessionAuthorityAvailable = (session) => {
+        if (!session || typeof session !== 'object')
+            throw new Error('Editor Authoring Host session is required.');
+        const owner = SESSION_AUTHORITY_OWNERS.get(session);
+        if (owner && owner !== sessionAuthorityOwner) {
+            throw new Error('Editor Session already has a different write authority.');
+        }
+    };
+    const claimSessionAuthority = (session) => {
+        assertSessionAuthorityAvailable(session);
+        claimEditorSessionWriteAuthority(session, sessionAuthorityOwner);
+        try {
+            runWithEditorSessionWriteAuthority(session, sessionAuthorityOwner, () => {
+                session.detachDocumentReferencesForWriteAuthority();
+            });
+        }
+        catch (error) {
+            releaseEditorSessionWriteAuthority(session, sessionAuthorityOwner);
+            throw error;
+        }
+        SESSION_AUTHORITY_OWNERS.set(session, sessionAuthorityOwner);
+        claimedSessions.add(session);
+        trackedSessions.add(session);
+    };
+    const reserveSessionAuthority = (session) => {
+        assertSessionAuthorityAvailable(session);
+        if (claimedSessions.has(session)) {
+            return Object.freeze({ establish() { }, release() { } });
+        }
+        const existingOwner = SESSION_AUTHORITY_OWNERS.get(session);
+        claimEditorSessionWriteAuthority(session, sessionAuthorityOwner);
+        if (!existingOwner) {
+            try {
+                runWithEditorSessionWriteAuthority(session, sessionAuthorityOwner, () => {
+                    session.detachDocumentReferencesForWriteAuthority();
+                });
+            }
+            catch (error) {
+                releaseEditorSessionWriteAuthority(session, sessionAuthorityOwner);
+                throw error;
+            }
+        }
+        SESSION_AUTHORITY_OWNERS.set(session, sessionAuthorityOwner);
+        trackedSessions.add(session);
+        reservedSessionCounts.set(session, (reservedSessionCounts.get(session) ?? 0) + 1);
+        let active = true;
+        const settle = (establish) => {
+            if (!active)
+                return;
+            active = false;
+            const remaining = (reservedSessionCounts.get(session) ?? 1) - 1;
+            if (remaining > 0)
+                reservedSessionCounts.set(session, remaining);
+            else
+                reservedSessionCounts.delete(session);
+            if (establish)
+                claimedSessions.add(session);
+            if (!claimedSessions.has(session) && !reservedSessionCounts.has(session)) {
+                if (SESSION_AUTHORITY_OWNERS.get(session) === sessionAuthorityOwner) {
+                    SESSION_AUTHORITY_OWNERS.delete(session);
+                }
+                releaseEditorSessionWriteAuthority(session, sessionAuthorityOwner);
+                trackedSessions.delete(session);
+            }
+        };
+        return Object.freeze({
+            establish: () => settle(true),
+            release: () => settle(false),
+        });
+    };
+    const releaseSessionAuthorities = () => {
+        if (sessionClaimsReleased)
+            return;
+        sessionClaimsReleased = true;
+        for (const session of trackedSessions) {
+            if (SESSION_AUTHORITY_OWNERS.get(session) === sessionAuthorityOwner) {
+                SESSION_AUTHORITY_OWNERS.delete(session);
+            }
+            releaseEditorSessionWriteAuthority(session, sessionAuthorityOwner);
+        }
+        claimedSessions.clear();
+        reservedSessionCounts.clear();
+        trackedSessions.clear();
+    };
+    try {
+        claimSessionAuthority(options.session);
+    }
+    catch (error) {
+        if (ownsCommandSystem)
+            commandSystem.dispose();
+        throw error;
+    }
+    const eventLimit = normalizePositiveInteger(options.eventLimit, DEFAULT_EVENT_LIMIT);
+    const now = options.now ?? Date.now;
+    const events = [];
+    const unregisterBuiltins = [];
+    const ownedRegistrations = new Set();
+    const ownedCommandIds = new Set();
+    const handlerValidatedRevisionCommandIds = new Set();
+    let eventCursor = 0;
+    let disposed = false;
+    const authorityController = new AbortController();
+    let writeQueue = Promise.resolve();
+    let writeAdmissionCount = 0;
+    let externalOperationCount = 0;
+    const activeExternalOperationIds = new Set();
+    let authorityReleased = false;
+    let resolveDrained;
+    const drained = new Promise(resolve => { resolveDrained = resolve; });
+    const activeTransactions = new Map();
+    const externalCommandResults = new Map();
+    const activeSerializedAccess = new WeakSet();
+    let activeSession = options.session;
+    const prepareEvent = (reason, state, timestamp) => Object.freeze({
+        cursor: eventCursor + 1,
+        serviceInstanceId,
+        reason,
+        documentRevision: state.documentRevision,
+        dirty: state.dirty,
+        timestamp,
+    });
+    const commitEvent = (event) => {
+        eventCursor = event.cursor;
+        events.push(event);
+        while (events.length > eventLimit)
+            events.shift();
+    };
+    const registerCommand = (registration) => {
+        assertActive();
+        const expectedRevisionPolicy = registration.expectedRevisionPolicy ?? 'current-document';
+        if (expectedRevisionPolicy !== 'current-document'
+            && expectedRevisionPolicy !== 'handler-validated') {
+            throw new Error('Editor Authoring Host command expected revision policy is invalid.');
+        }
+        if (expectedRevisionPolicy === 'handler-validated'
+            && (registration.manifest.target !== 'authoring' || registration.manifest.access !== 'write')) {
+            throw new Error('Handler-validated revisions are reserved for authoring write commands.');
+        }
+        const isSerializedWrite = registration.manifest.target === 'authoring'
+            && registration.manifest.access === 'write';
+        const { expectedRevisionPolicy: _expectedRevisionPolicy, ...commandRegistration } = registration;
+        const unregisterCommand = commandSystem.registerCommand({
+            ...commandRegistration,
+            authorityTransaction: 'isolated',
+            handler: async (input, context) => {
+                const readTransaction = isSerializedWrite ? undefined : activeSession.beginTransaction();
+                const session = isSerializedWrite
+                    ? activeTransactions.get(context.operationId)?.session
+                    : readTransaction?.session;
+                if (!session) {
+                    return {
+                        ok: false,
+                        diagnostics: [diagnostic('command.authorityUnavailable', `Authoring transaction is unavailable: ${context.commandId}`)],
+                    };
+                }
+                try {
+                    return await registration.handler(input, {
+                        ...context,
+                        session,
+                        dispatch(command, dispatchOptions) {
+                            session.dispatch(command, dispatchOptions);
+                            return session.getState();
+                        },
+                    });
+                }
+                finally {
+                    readTransaction?.discard();
+                }
+            },
+        });
+        ownedCommandIds.add(registration.manifest.id);
+        if (expectedRevisionPolicy === 'handler-validated') {
+            handlerValidatedRevisionCommandIds.add(registration.manifest.id);
+        }
+        let active = true;
+        const unregister = () => {
+            if (!active)
+                return;
+            active = false;
+            ownedRegistrations.delete(unregister);
+            ownedCommandIds.delete(registration.manifest.id);
+            handlerValidatedRevisionCommandIds.delete(registration.manifest.id);
+            unregisterCommand();
+        };
+        ownedRegistrations.add(unregister);
+        return unregister;
+    };
+    let releaseExecutionAuthority;
+    try {
+        releaseExecutionAuthority = commandSystem.installExecutionInterceptor(async (context, execute) => {
+            const isSerializedWrite = (context.authorityTransaction === 'composed'
+                && context.manifest.access === 'write')
+                || (context.manifest.target === 'authoring' && context.manifest.access === 'write');
+            if (!isSerializedWrite)
+                return execute();
+            const admittedSession = activeSession;
+            return enqueueWrite(async () => {
+                if (authorityController.signal.aborted)
+                    return cancelledDiagnostic(context.commandId);
+                if (context.signal.aborted)
+                    return cancelledDiagnostic(context.commandId);
+                if (activeSession !== admittedSession && context.authorityTransaction !== 'composed') {
+                    return {
+                        ok: false,
+                        diagnostics: [diagnostic('command.documentScopeChanged', `Authoring document scope changed before execution: ${context.commandId}`)],
+                    };
+                }
+                if (context.authorityTransaction !== 'composed' && !ownedCommandIds.has(context.commandId)) {
+                    return {
+                        ok: false,
+                        diagnostics: [diagnostic('command.authorityRegistrationRequired', `Authoring write command is not registered by this Host: ${context.commandId}`)],
+                    };
+                }
+                const gate = validateAuthoringWriteInvocation(context, activeSession, handlerValidatedRevisionCommandIds.has(context.commandId));
+                if (gate)
+                    return { ok: false, diagnostics: [gate] };
+                const beforeRevision = activeSession.getState({ cloneDocuments: false }).documentRevision;
+                if (context.authorityTransaction === 'composed') {
+                    // The timestamp source is injectable and may throw. Resolve it before
+                    // a external command handler can mutate the authoritative Session.
+                    const eventTimestamp = now();
+                    externalOperationCount += 1;
+                    activeExternalOperationIds.add(context.operationId);
+                    const serializedAccess = Object.freeze({
+                        serviceInstanceId,
+                        [CALL_WITH_SERIALIZED_SESSION_AUTHORITY]: (handler) => {
+                            if (!activeSerializedAccess.has(serializedAccess)) {
+                                throw new Error('Editor Authoring Host serialized access is invalid or expired.');
+                            }
+                            return callWithEditorSessionWriteAuthority(activeSession, sessionAuthorityOwner, handler);
+                        },
+                    });
+                    activeSerializedAccess.add(serializedAccess);
+                    try {
+                        try {
+                            const execution = callWithEditorSessionWriteAuthority(activeSession, sessionAuthorityOwner, () => execute(serializedAccess));
+                            return await execution;
+                        }
+                        catch (error) {
+                            return {
+                                ok: false,
+                                diagnostics: [diagnostic('command.exception', error instanceof Error ? error.message : String(error))],
+                            };
+                        }
+                    }
+                    finally {
+                        activeSerializedAccess.delete(serializedAccess);
+                        const next = activeSession.getState({ cloneDocuments: false });
+                        if (activeSession === admittedSession && next.documentRevision !== beforeRevision) {
+                            commitEvent(prepareEvent('document', next, eventTimestamp));
+                        }
+                        externalOperationCount -= 1;
+                        activeExternalOperationIds.delete(context.operationId);
+                        finishDisposal();
+                    }
+                }
+                const transaction = activeSession.beginTransaction();
+                activeTransactions.set(context.operationId, transaction);
+                let committed = false;
+                try {
+                    const outcome = await executeWhileHostActive(execute, context.commandId);
+                    if (!outcome.ok)
+                        return outcome;
+                    if (context.signal.aborted)
+                        return cancelledDiagnostic(context.commandId);
+                    const reason = context.commandId === 'history.undo' || context.commandId === 'history.redo'
+                        ? 'history'
+                        : 'document';
+                    const draftState = transaction.session.getState({ cloneDocuments: false });
+                    const event = draftState.documentRevision !== beforeRevision
+                        ? prepareEvent(reason, draftState, now())
+                        : null;
+                    runWithEditorSessionWriteAuthority(activeSession, sessionAuthorityOwner, () => {
+                        transaction.commit(reason);
+                    });
+                    committed = true;
+                    if (event)
+                        commitEvent(event);
+                    return outcome;
+                }
+                finally {
+                    activeTransactions.delete(context.operationId);
+                    if (!committed)
+                        transaction.discard();
+                }
+            });
+        }, { scopeId: serviceInstanceId });
+    }
+    catch (error) {
+        releaseSessionAuthorities();
+        if (ownsCommandSystem)
+            commandSystem.dispose();
+        throw error;
+    }
+    const host = {
+        serviceInstanceId,
+        commandSystem: createCommandClient(commandSystem),
+        registerCommand,
+        invoke(invocation) {
+            assertActive();
+            return commandSystem.invoke(invocation);
+        },
+        execute(invocation) {
+            assertActive();
+            return commandSystem.execute(invocation);
+        },
+        getSnapshot() {
+            assertActive();
+            return createSnapshot(activeSession.getState(), serviceInstanceId, eventCursor);
+        },
+        readEvents(afterCursor = eventCursor, expectedServiceInstanceId = serviceInstanceId) {
+            assertActive();
+            if (expectedServiceInstanceId !== serviceInstanceId) {
+                return {
+                    kind: 'snapshot-required',
+                    reason: 'service.restarted',
+                    snapshot: host.getSnapshot(),
+                };
+            }
+            const normalizedCursor = Number.isSafeInteger(afterCursor) && afterCursor >= 0
+                ? afterCursor
+                : 0;
+            if (normalizedCursor > eventCursor) {
+                return {
+                    kind: 'snapshot-required',
+                    reason: 'cursor.invalid',
+                    snapshot: host.getSnapshot(),
+                };
+            }
+            const oldestCursor = events[0]?.cursor ?? eventCursor + 1;
+            if (normalizedCursor < oldestCursor - 1) {
+                return {
+                    kind: 'snapshot-required',
+                    reason: 'cursor.expired',
+                    snapshot: host.getSnapshot(),
+                };
+            }
+            return {
+                kind: 'events',
+                serviceInstanceId,
+                latestCursor: eventCursor,
+                events: events.filter(event => event.cursor > normalizedCursor).map(event => ({ ...event })),
+            };
+        },
+        async markSaved(document, markSavedOptions) {
+            assertActive();
+            if (!markSavedOptions || typeof markSavedOptions !== 'object'
+                || !Number.isSafeInteger(markSavedOptions.expectedDocumentRevision)
+                || markSavedOptions.expectedDocumentRevision < 0) {
+                throw new Error('Editor save checkpoint expectedDocumentRevision must be a non-negative safe integer.');
+            }
+            const expectedDocumentRevision = markSavedOptions.expectedDocumentRevision;
+            const serializedAccess = markSavedOptions.serializedAccess;
+            const admittedSession = activeSession;
+            const admission = admittedSession.beginTransaction();
+            let admittedDocument;
+            let admittedSource;
+            try {
+                admission.session.reset(document, markSavedOptions.source);
+                admittedDocument = admission.session.getWorkingDocument();
+                admittedSource = admission.session.getSource();
+            }
+            finally {
+                admission.discard();
+            }
+            const commitCheckpoint = async () => {
+                assertActive();
+                if (activeSession !== admittedSession) {
+                    throw new Error('Editor save checkpoint document scope changed before commit.');
+                }
+                const actualRevision = activeSession.getState({ cloneDocuments: false }).documentRevision;
+                if (actualRevision !== expectedDocumentRevision) {
+                    throw new Error(`Editor save checkpoint revision mismatch: expected ${expectedDocumentRevision}, received ${actualRevision}.`);
+                }
+                const transaction = activeSession.beginTransaction();
+                let committed = false;
+                try {
+                    const eventTimestamp = now();
+                    transaction.session.markSaved(admittedDocument, admittedSource);
+                    const draftState = transaction.session.getState({ cloneDocuments: false });
+                    const event = prepareEvent('saved', draftState, eventTimestamp);
+                    const state = runWithEditorSessionWriteAuthority(activeSession, sessionAuthorityOwner, () => (transaction.commit('saved')));
+                    committed = true;
+                    commitEvent(event);
+                    return createSnapshot(state, serviceInstanceId, eventCursor);
+                }
+                finally {
+                    if (!committed)
+                        transaction.discard();
+                }
+            };
+            if (serializedAccess) {
+                assertSerializedAccess(serializedAccess);
+                return commitCheckpoint();
+            }
+            return enqueueWrite(commitCheckpoint);
+        },
+        async markSavedWithRelatedSession(document, markSavedOptions) {
+            assertActive();
+            if (!markSavedOptions || typeof markSavedOptions !== 'object'
+                || !Number.isSafeInteger(markSavedOptions.expectedDocumentRevision)
+                || markSavedOptions.expectedDocumentRevision < 0) {
+                throw new Error('Editor related save checkpoint expectedDocumentRevision must be a non-negative safe integer.');
+            }
+            if (!markSavedOptions.relatedSession || typeof markSavedOptions.relatedSession !== 'object') {
+                throw new Error('Editor related save checkpoint Session is required.');
+            }
+            if (!Number.isSafeInteger(markSavedOptions.expectedRelatedDocumentRevision)
+                || markSavedOptions.expectedRelatedDocumentRevision < 0) {
+                throw new Error('Editor related save checkpoint expectedRelatedDocumentRevision must be a non-negative safe integer.');
+            }
+            if (typeof markSavedOptions.mutateRelatedSession !== 'function') {
+                throw new Error('Editor related save checkpoint mutation is required.');
+            }
+            const expectedDocumentRevision = markSavedOptions.expectedDocumentRevision;
+            const admittedSession = activeSession;
+            const relatedSession = markSavedOptions.relatedSession;
+            const expectedRelatedDocumentRevision = markSavedOptions.expectedRelatedDocumentRevision;
+            const resetHistory = markSavedOptions.resetHistory === true;
+            const mutateRelatedSession = markSavedOptions.mutateRelatedSession;
+            const serializedAccess = markSavedOptions.serializedAccess;
+            if (admittedSession === relatedSession) {
+                throw new Error('Editor related save checkpoint requires a distinct Session.');
+            }
+            const admission = admittedSession.beginTransaction();
+            let admittedDocument;
+            let admittedSource;
+            try {
+                admission.session.reset(document, markSavedOptions.source);
+                admittedDocument = admission.session.getWorkingDocument();
+                admittedSource = admission.session.getSource();
+            }
+            finally {
+                admission.discard();
+            }
+            const sessionReservation = reserveSessionAuthority(relatedSession);
+            const commitCheckpoint = async () => {
+                assertActive();
+                if (activeSession !== admittedSession) {
+                    throw new Error('Editor related save checkpoint document scope changed before commit.');
+                }
+                const actualRevision = activeSession.getState({ cloneDocuments: false }).documentRevision;
+                if (actualRevision !== expectedDocumentRevision) {
+                    throw new Error(`Editor related save checkpoint revision mismatch: expected ${expectedDocumentRevision}, received ${actualRevision}.`);
+                }
+                const actualRelatedRevision = relatedSession.getState({ cloneDocuments: false }).documentRevision;
+                if (actualRelatedRevision !== expectedRelatedDocumentRevision) {
+                    throw new Error(`Editor related save checkpoint related revision mismatch: expected ${expectedRelatedDocumentRevision}, received ${actualRelatedRevision}.`);
+                }
+                const activeTransaction = activeSession.beginTransaction();
+                const relatedTransaction = relatedSession.beginTransaction();
+                let committed = false;
+                try {
+                    const eventTimestamp = now();
+                    activeTransaction.session.markSaved(admittedDocument, admittedSource, {
+                        resetHistory,
+                    });
+                    const relatedMutationResult = mutateRelatedSession(relatedTransaction.session);
+                    if (relatedMutationResult && typeof relatedMutationResult === 'object'
+                        && 'then' in relatedMutationResult && typeof relatedMutationResult.then === 'function') {
+                        throw new Error('Editor related save checkpoint mutation must be synchronous.');
+                    }
+                    const draftState = activeTransaction.session.getState({ cloneDocuments: false });
+                    const event = prepareEvent('saved', draftState, eventTimestamp);
+                    const preparedActive = activeTransaction.prepareCommit('saved');
+                    const preparedRelated = relatedTransaction.prepareCommit('saved');
+                    preparedActive.assertReady();
+                    preparedRelated.assertReady();
+                    const { activeCommit, relatedCommit } = runWithEditorSessionWriteAuthority(activeSession, sessionAuthorityOwner, () => runWithEditorSessionWriteAuthority(relatedSession, sessionAuthorityOwner, () => ({
+                        activeCommit: preparedActive.commit({ deferChangeNotification: true }),
+                        relatedCommit: preparedRelated.commit({ deferChangeNotification: true }),
+                    })));
+                    committed = true;
+                    sessionReservation.establish();
+                    activeCommit.notifyChange();
+                    relatedCommit.notifyChange();
+                    commitEvent(event);
+                    return createSnapshot(activeCommit.state, serviceInstanceId, eventCursor);
+                }
+                finally {
+                    if (!committed) {
+                        activeTransaction.discard();
+                        relatedTransaction.discard();
+                    }
+                }
+            };
+            try {
+                const result = serializedAccess
+                    ? (assertSerializedAccess(serializedAccess), await commitCheckpoint())
+                    : await enqueueWrite(commitCheckpoint);
+                return result;
+            }
+            catch (error) {
+                sessionReservation.release();
+                throw error;
+            }
+        },
+        async reset(document, source, resetOptions) {
+            assertActive();
+            if (!resetOptions || !Number.isSafeInteger(resetOptions.expectedDocumentRevision)
+                || resetOptions.expectedDocumentRevision < 0) {
+                throw new Error('Editor reset expectedDocumentRevision must be a non-negative safe integer.');
+            }
+            const expectedDocumentRevision = resetOptions.expectedDocumentRevision;
+            const serializedAccess = resetOptions.serializedAccess;
+            const admittedSession = activeSession;
+            const admission = admittedSession.beginTransaction();
+            let admittedDocument;
+            let admittedSource;
+            try {
+                admission.session.reset(document, source);
+                admittedDocument = admission.session.getWorkingDocument();
+                admittedSource = admission.session.getSource();
+            }
+            finally {
+                admission.discard();
+            }
+            const commitReset = async () => {
+                assertActive();
+                if (activeSession !== admittedSession) {
+                    throw new Error('Editor reset document scope changed before commit.');
+                }
+                const actualRevision = activeSession.getState({ cloneDocuments: false }).documentRevision;
+                if (actualRevision !== expectedDocumentRevision) {
+                    throw new Error(`Editor reset revision mismatch: expected ${expectedDocumentRevision}, received ${actualRevision}.`);
+                }
+                const transaction = activeSession.beginTransaction();
+                let committed = false;
+                try {
+                    const eventTimestamp = now();
+                    transaction.session.reset(admittedDocument, admittedSource);
+                    const draftState = transaction.session.getState({ cloneDocuments: false });
+                    const event = prepareEvent('reset', draftState, eventTimestamp);
+                    const state = runWithEditorSessionWriteAuthority(activeSession, sessionAuthorityOwner, () => (transaction.commit('reset')));
+                    committed = true;
+                    commitEvent(event);
+                    return createSnapshot(state, serviceInstanceId, eventCursor);
+                }
+                finally {
+                    if (!committed)
+                        transaction.discard();
+                }
+            };
+            if (serializedAccess) {
+                assertSerializedAccess(serializedAccess);
+                return commitReset();
+            }
+            return enqueueWrite(commitReset);
+        },
+        async resetWithRelatedSession(document, source, resetOptions) {
+            assertActive();
+            if (!resetOptions || !Number.isSafeInteger(resetOptions.expectedDocumentRevision)
+                || resetOptions.expectedDocumentRevision < 0) {
+                throw new Error('Editor related reset expectedDocumentRevision must be a non-negative safe integer.');
+            }
+            if (!resetOptions.relatedSession || typeof resetOptions.relatedSession !== 'object') {
+                throw new Error('Editor related reset Session is required.');
+            }
+            if (!Number.isSafeInteger(resetOptions.expectedRelatedDocumentRevision)
+                || resetOptions.expectedRelatedDocumentRevision < 0) {
+                throw new Error('Editor related reset expectedRelatedDocumentRevision must be a non-negative safe integer.');
+            }
+            if (typeof resetOptions.mutateRelatedSession !== 'function') {
+                throw new Error('Editor related reset mutation is required.');
+            }
+            const admittedSession = activeSession;
+            const relatedSession = resetOptions.relatedSession;
+            const expectedDocumentRevision = resetOptions.expectedDocumentRevision;
+            const expectedRelatedDocumentRevision = resetOptions.expectedRelatedDocumentRevision;
+            const mutateRelatedSession = resetOptions.mutateRelatedSession;
+            const serializedAccess = resetOptions.serializedAccess;
+            if (admittedSession === relatedSession) {
+                throw new Error('Editor related reset requires a distinct Session.');
+            }
+            const admission = admittedSession.beginTransaction();
+            let admittedDocument;
+            let admittedSource;
+            try {
+                admission.session.reset(document, source);
+                admittedDocument = admission.session.getWorkingDocument();
+                admittedSource = admission.session.getSource();
+            }
+            finally {
+                admission.discard();
+            }
+            const sessionReservation = reserveSessionAuthority(relatedSession);
+            const commitReset = async () => {
+                assertActive();
+                if (activeSession !== admittedSession) {
+                    throw new Error('Editor related reset document scope changed before commit.');
+                }
+                const actualRevision = activeSession.getState({ cloneDocuments: false }).documentRevision;
+                if (actualRevision !== expectedDocumentRevision) {
+                    throw new Error(`Editor related reset revision mismatch: expected ${expectedDocumentRevision}, received ${actualRevision}.`);
+                }
+                const actualRelatedRevision = relatedSession.getState({ cloneDocuments: false }).documentRevision;
+                if (actualRelatedRevision !== expectedRelatedDocumentRevision) {
+                    throw new Error(`Editor related reset related revision mismatch: expected ${expectedRelatedDocumentRevision}, received ${actualRelatedRevision}.`);
+                }
+                const activeTransaction = activeSession.beginTransaction();
+                const relatedTransaction = relatedSession.beginTransaction();
+                let committed = false;
+                try {
+                    const eventTimestamp = now();
+                    activeTransaction.session.reset(admittedDocument, admittedSource);
+                    const relatedMutationResult = mutateRelatedSession(relatedTransaction.session);
+                    if (relatedMutationResult && typeof relatedMutationResult === 'object'
+                        && 'then' in relatedMutationResult && typeof relatedMutationResult.then === 'function') {
+                        throw new Error('Editor related reset mutation must be synchronous.');
+                    }
+                    const draftState = activeTransaction.session.getState({ cloneDocuments: false });
+                    const event = prepareEvent('reset', draftState, eventTimestamp);
+                    const preparedActive = activeTransaction.prepareCommit('reset');
+                    const preparedRelated = relatedTransaction.prepareCommit('reset');
+                    preparedActive.assertReady();
+                    preparedRelated.assertReady();
+                    const { activeCommit, relatedCommit } = runWithEditorSessionWriteAuthority(activeSession, sessionAuthorityOwner, () => runWithEditorSessionWriteAuthority(relatedSession, sessionAuthorityOwner, () => ({
+                        activeCommit: preparedActive.commit({ deferChangeNotification: true }),
+                        relatedCommit: preparedRelated.commit({ deferChangeNotification: true }),
+                    })));
+                    committed = true;
+                    sessionReservation.establish();
+                    activeCommit.notifyChange();
+                    relatedCommit.notifyChange();
+                    commitEvent(event);
+                    return createSnapshot(activeCommit.state, serviceInstanceId, eventCursor);
+                }
+                finally {
+                    if (!committed) {
+                        activeTransaction.discard();
+                        relatedTransaction.discard();
+                    }
+                }
+            };
+            try {
+                const result = serializedAccess
+                    ? (assertSerializedAccess(serializedAccess), await commitReset())
+                    : await enqueueWrite(commitReset);
+                return result;
+            }
+            catch (error) {
+                sessionReservation.release();
+                throw error;
+            }
+        },
+        async switchSession(session, switchOptions) {
+            assertActive();
+            if (!session || typeof session !== 'object')
+                throw new Error('Editor Authoring Host session is required.');
+            if (!switchOptions || !Number.isSafeInteger(switchOptions.expectedDocumentRevision)
+                || switchOptions.expectedDocumentRevision < 0) {
+                throw new Error('Editor scope switch expectedDocumentRevision must be a non-negative safe integer.');
+            }
+            const expectedDocumentRevision = switchOptions.expectedDocumentRevision;
+            const serializedAccess = switchOptions.serializedAccess;
+            const sessionReservation = reserveSessionAuthority(session);
+            const admittedSession = activeSession;
+            const switchActiveSession = async () => {
+                assertActive();
+                if (activeSession !== admittedSession) {
+                    throw new Error('Editor scope changed before scope switch commit.');
+                }
+                const actualRevision = activeSession.getState({ cloneDocuments: false }).documentRevision;
+                if (actualRevision !== expectedDocumentRevision) {
+                    throw new Error(`Editor scope switch revision mismatch: expected ${expectedDocumentRevision}, received ${actualRevision}.`);
+                }
+                if (activeSession === session)
+                    return host.getSnapshot();
+                const sourceState = activeSession.getState({ cloneDocuments: false });
+                // Prepare every fallible target clone, timestamp, event and public
+                // snapshot before changing either the target revision or active owner.
+                const targetState = session.getState();
+                const eventTimestamp = now();
+                const scopeRevision = Math.max(sourceState.documentRevision, targetState.documentRevision) + 1;
+                const scopeStructureSequence = Math.max(sourceState.documentStructureRevision, targetState.documentStructureRevision) + 1;
+                const switchedState = {
+                    ...targetState,
+                    documentRevision: scopeRevision,
+                    documentStructureRevision: scopeStructureSequence,
+                };
+                const event = prepareEvent('rebase', switchedState, eventTimestamp);
+                const snapshot = createSnapshot(switchedState, serviceInstanceId, event.cursor);
+                runWithEditorSessionWriteAuthority(session, sessionAuthorityOwner, () => {
+                    session.advanceRevisionsForScopeSwitch(scopeRevision, scopeStructureSequence);
+                });
+                sessionReservation.establish();
+                activeSession = session;
+                commitEvent(event);
+                return snapshot;
+            };
+            try {
+                const result = serializedAccess
+                    ? (assertSerializedAccess(serializedAccess), await switchActiveSession())
+                    : await enqueueWrite(switchActiveSession);
+                return result;
+            }
+            catch (error) {
+                sessionReservation.release();
+                throw error;
+            }
+        },
+        runExternalCommandMutation(request, handler) {
+            assertActive();
+            const commandId = normalizeRequiredId(request?.commandId, 'commandId');
+            normalizeRequiredId(request?.requestId, 'requestId');
+            const idempotencyKey = normalizeRequiredId(request?.idempotencyKey, 'idempotencyKey');
+            const fingerprint = normalizeRequiredId(request?.fingerprint, 'fingerprint');
+            const idempotencyScope = JSON.stringify([commandId, idempotencyKey]);
+            if (!Number.isSafeInteger(request?.expectedDocumentRevision) || request.expectedDocumentRevision < 0) {
+                throw new Error('External command authoring mutation expectedDocumentRevision must be a non-negative safe integer.');
+            }
+            const expectedDocumentRevision = request.expectedDocumentRevision;
+            if (typeof handler !== 'function')
+                throw new Error('External command authoring mutation handler is required.');
+            const existing = externalCommandResults.get(idempotencyScope);
+            if (existing) {
+                if (existing.fingerprint !== fingerprint
+                    || existing.expectedDocumentRevision !== expectedDocumentRevision) {
+                    throw new Error(`External command authoring idempotency conflict: ${idempotencyKey}`);
+                }
+                return existing.result;
+            }
+            const admittedSession = activeSession;
+            externalOperationCount += 1;
+            const result = enqueueWrite(() => {
+                let beforeRevision = null;
+                let eventTimestamp = null;
+                let sessionViewActive = true;
+                const authorizedSession = createOperationScopedSessionView(admittedSession, () => {
+                    if (!sessionViewActive)
+                        throw new Error('Browser authoring Session access is expired.');
+                }, handler => runWithEditorSessionWriteAuthority(admittedSession, sessionAuthorityOwner, handler));
+                const finish = () => {
+                    sessionViewActive = false;
+                    if (beforeRevision !== null && eventTimestamp !== null && activeSession === admittedSession) {
+                        const next = activeSession.getState({ cloneDocuments: false });
+                        if (next.documentRevision !== beforeRevision) {
+                            commitEvent(prepareEvent('document', next, eventTimestamp));
+                        }
+                    }
+                    externalOperationCount -= 1;
+                    finishDisposal();
+                };
+                try {
+                    assertActive();
+                    if (activeSession !== admittedSession) {
+                        throw new Error(`Browser authoring document scope changed before execution: ${commandId}`);
+                    }
+                    beforeRevision = activeSession.getState({ cloneDocuments: false }).documentRevision;
+                    if (beforeRevision !== expectedDocumentRevision) {
+                        throw new Error(`Browser authoring revision mismatch for ${commandId}: expected ${expectedDocumentRevision}, received ${beforeRevision}.`);
+                    }
+                    eventTimestamp = now();
+                    const value = callWithEditorSessionWriteAuthority(admittedSession, sessionAuthorityOwner, () => handler(authorizedSession));
+                    if (value && typeof value === 'object' && 'then' in value
+                        && typeof value.then === 'function') {
+                        return Promise.resolve(value).finally(finish);
+                    }
+                    finish();
+                    return value;
+                }
+                catch (error) {
+                    finish();
+                    throw error;
+                }
+            }, true);
+            externalCommandResults.set(idempotencyScope, {
+                fingerprint,
+                expectedDocumentRevision,
+                result,
+            });
+            return result;
+        },
+        tryRunExternalCommandMutationImmediately(request, handler) {
+            assertActive();
+            const commandId = normalizeRequiredId(request?.commandId, 'commandId');
+            normalizeRequiredId(request?.requestId, 'requestId');
+            const idempotencyKey = normalizeRequiredId(request?.idempotencyKey, 'idempotencyKey');
+            const fingerprint = normalizeRequiredId(request?.fingerprint, 'fingerprint');
+            const idempotencyScope = JSON.stringify([commandId, idempotencyKey]);
+            if (!Number.isSafeInteger(request?.expectedDocumentRevision) || request.expectedDocumentRevision < 0) {
+                throw new Error('External command authoring mutation expectedDocumentRevision must be a non-negative safe integer.');
+            }
+            const expectedDocumentRevision = request.expectedDocumentRevision;
+            if (typeof handler !== 'function')
+                throw new Error('External command authoring mutation handler is required.');
+            const existing = externalCommandResults.get(idempotencyScope);
+            if (existing) {
+                if (existing.fingerprint !== fingerprint
+                    || existing.expectedDocumentRevision !== expectedDocumentRevision) {
+                    throw new Error(`External command authoring idempotency conflict: ${idempotencyKey}`);
+                }
+                if (existing.hasImmediateValue) {
+                    return { ok: true, value: existing.immediateValue, reused: true };
+                }
+                return { ok: false, reason: 'busy' };
+            }
+            if (writeAdmissionCount > 0)
+                return { ok: false, reason: 'busy' };
+            const beforeRevision = activeSession.getState({ cloneDocuments: false }).documentRevision;
+            if (beforeRevision !== expectedDocumentRevision) {
+                throw new Error(`Browser authoring revision mismatch for ${commandId}: expected ${expectedDocumentRevision}, received ${beforeRevision}.`);
+            }
+            const eventTimestamp = now();
+            externalOperationCount += 1;
+            const transaction = activeSession.beginTransaction();
+            let committed = false;
+            try {
+                const value = handler(transaction.session);
+                if (value && typeof value === 'object' && 'then' in value && typeof value.then === 'function') {
+                    throw new Error('Immediate Browser authoring mutations must be synchronous.');
+                }
+                const next = transaction.session.getState({ cloneDocuments: false });
+                const event = next.documentRevision !== beforeRevision
+                    ? prepareEvent('document', next, eventTimestamp)
+                    : null;
+                runWithEditorSessionWriteAuthority(activeSession, sessionAuthorityOwner, () => {
+                    transaction.commit('document');
+                });
+                committed = true;
+                if (event)
+                    commitEvent(event);
+                externalCommandResults.set(idempotencyScope, {
+                    fingerprint,
+                    expectedDocumentRevision,
+                    result: Promise.resolve(value),
+                    immediateValue: value,
+                    hasImmediateValue: true,
+                });
+                return { ok: true, value, reused: false };
+            }
+            finally {
+                if (!committed)
+                    transaction.discard();
+                externalOperationCount -= 1;
+                finishDisposal();
+            }
+        },
+        runSerializedExternalMutation(serializedAccess, expectedDocumentRevision, handler) {
+            assertActive();
+            assertSerializedAccess(serializedAccess);
+            if (!Number.isSafeInteger(expectedDocumentRevision) || expectedDocumentRevision < 0) {
+                throw new Error('Serialized external command mutation expectedDocumentRevision must be a non-negative safe integer.');
+            }
+            const actualRevision = activeSession.getState({ cloneDocuments: false }).documentRevision;
+            if (actualRevision !== expectedDocumentRevision) {
+                throw new Error(`Serialized external command mutation revision mismatch: expected ${expectedDocumentRevision}, received ${actualRevision}.`);
+            }
+            const transaction = activeSession.beginTransaction();
+            let committed = false;
+            try {
+                const value = handler(transaction.session);
+                if (value && typeof value === 'object' && 'then' in value && typeof value.then === 'function') {
+                    throw new Error('Serialized external command mutations must be synchronous.');
+                }
+                runWithEditorSessionWriteAuthority(activeSession, sessionAuthorityOwner, () => {
+                    transaction.commit('document');
+                });
+                committed = true;
+                return value;
+            }
+            finally {
+                if (!committed)
+                    transaction.discard();
+            }
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            HOST_EXTERNAL_COMMAND_REGISTRARS.delete(host);
+            authorityController.abort();
+            for (const operationId of activeExternalOperationIds)
+                commandSystem.cancelOperation(operationId);
+            for (const unregister of unregisterBuiltins.splice(0).reverse())
+                unregister();
+            for (const unregister of [...ownedRegistrations].reverse())
+                unregister();
+            finishDisposal();
+        },
+        drain() {
+            if (!disposed)
+                return Promise.resolve();
+            return drained;
+        },
+    };
+    HOST_EXTERNAL_COMMAND_REGISTRARS.set(host, (registration) => {
+        assertActive();
+        const unregisterCommand = commandSystem.registerCommand(authorizeCommandComposedRegistration({
+            ...registration,
+            authorityTransaction: 'composed',
+        }));
+        let active = true;
+        const unregister = () => {
+            if (!active)
+                return;
+            active = false;
+            ownedRegistrations.delete(unregister);
+            unregisterCommand();
+        };
+        ownedRegistrations.add(unregister);
+        return unregister;
+    });
+    try {
+        unregisterBuiltins.push(registerCommand(createSnapshotCommand(host)));
+        unregisterBuiltins.push(registerCommand(createUndoCommand()));
+        unregisterBuiltins.push(registerCommand(createRedoCommand()));
+    }
+    catch (error) {
+        HOST_EXTERNAL_COMMAND_REGISTRARS.delete(host);
+        for (const unregister of unregisterBuiltins.splice(0).reverse())
+            unregister();
+        for (const unregister of [...ownedRegistrations].reverse())
+            unregister();
+        releaseExecutionAuthority();
+        releaseSessionAuthorities();
+        if (options.disposeCommandSystem !== false)
+            commandSystem.dispose();
+        throw error;
+    }
+    return host;
+    function assertActive() {
+        if (disposed)
+            throw new Error('Editor Authoring Host is disposed.');
+    }
+    function assertSerializedAccess(access) {
+        if (!access || typeof access !== 'object' || !activeSerializedAccess.has(access)) {
+            throw new Error('Editor Authoring Host serialized access is invalid or expired.');
+        }
+    }
+    function enqueueWrite(task, startIdleSynchronously = false) {
+        const startImmediately = startIdleSynchronously && writeAdmissionCount === 0;
+        writeAdmissionCount += 1;
+        const previous = writeQueue;
+        let releaseQueue;
+        writeQueue = new Promise(resolve => { releaseQueue = resolve; });
+        const release = () => {
+            writeAdmissionCount -= 1;
+            releaseQueue();
+            finishDisposal();
+        };
+        const execute = () => {
+            try {
+                const value = task();
+                if (value && typeof value === 'object' && 'then' in value
+                    && typeof value.then === 'function') {
+                    return Promise.resolve(value).finally(release);
+                }
+                release();
+                return Promise.resolve(value);
+            }
+            catch (error) {
+                release();
+                return Promise.reject(error);
+            }
+        };
+        // A synchronous composed UI interaction may start only when the FIFO is
+        // idle; every other command retains the established queued turn.
+        return startImmediately ? execute() : previous.then(execute);
+    }
+    async function executeWhileHostActive(execute, commandId) {
+        if (authorityController.signal.aborted)
+            return cancelledDiagnostic(commandId);
+        return new Promise((resolve, reject) => {
+            const onAbort = () => resolve(cancelledDiagnostic(commandId));
+            authorityController.signal.addEventListener('abort', onAbort, { once: true });
+            execute().then(outcome => {
+                authorityController.signal.removeEventListener('abort', onAbort);
+                resolve(outcome);
+            }, error => {
+                authorityController.signal.removeEventListener('abort', onAbort);
+                reject(error);
+            });
+        });
+    }
+    function finishDisposal() {
+        if (!disposed || authorityReleased || externalOperationCount > 0 || writeAdmissionCount > 0)
+            return;
+        authorityReleased = true;
+        releaseExecutionAuthority();
+        releaseSessionAuthorities();
+        if (options.disposeCommandSystem !== false)
+            commandSystem.dispose();
+        resolveDrained();
+    }
+}
+function createCommandClient(commandSystem) {
+    return Object.freeze({
+        get catalogRevision() { return commandSystem.catalogRevision; },
+        get executionAuthorityInstalled() { return commandSystem.executionAuthorityInstalled; },
+        listManifests: () => commandSystem.listManifests(),
+        getCatalog: query => commandSystem.getCatalog(query),
+        describeCommand: commandId => commandSystem.describeCommand(commandId),
+        invoke: invocation => commandSystem.invoke(invocation),
+        execute: invocation => commandSystem.execute(invocation),
+        getOperation: operationId => commandSystem.getOperation(operationId),
+        cancelOperation: operationId => commandSystem.cancelOperation(operationId),
+    });
+}
+function createOperationScopedSessionView(session, assertActive, invoke) {
+    return new Proxy(Object.create(null), {
+        get(_target, property) {
+            assertActive();
+            if (!EXTERNAL_COMMAND_SESSION_VIEW_METHODS.has(property)) {
+                throw new Error(`Browser authoring Session member is unavailable: ${String(property)}.`);
+            }
+            const value = Reflect.get(session, property, session);
+            if (typeof value !== 'function') {
+                throw new Error(`Browser authoring Session method is unavailable: ${String(property)}.`);
+            }
+            return (...args) => {
+                assertActive();
+                return invoke(() => Reflect.apply(value, session, args));
+            };
+        },
+        set() {
+            throw new Error('Browser authoring Session properties are immutable.');
+        },
+        defineProperty() {
+            throw new Error('Browser authoring Session properties are immutable.');
+        },
+        deleteProperty() {
+            throw new Error('Browser authoring Session properties are immutable.');
+        },
+    });
+}
+function validateAuthoringWriteInvocation(context, session, handlerValidatesExpectedRevision = false) {
+    if (!context.idempotencyKey) {
+        return diagnostic('command.idempotencyKeyRequired', 'Authoring write commands require an idempotency key.');
+    }
+    const expected = context.expectedRevision?.document;
+    if (expected === undefined) {
+        return diagnostic('command.expectedRevisionRequired', 'Authoring write commands require expectedRevision.document.');
+    }
+    if (handlerValidatesExpectedRevision)
+        return null;
+    const actual = session.getState({ cloneDocuments: false }).documentRevision;
+    if (expected !== actual) {
+        return diagnostic('command.documentRevisionMismatch', `Expected document revision ${expected}, received ${actual}.`, { expected, actual });
+    }
+    return null;
+}
+function createSnapshotCommand(host) {
+    return {
+        manifest: manifest({
+            id: 'authoring.snapshot.get',
+            title: 'Get Authoring Snapshot',
+            target: 'authoring',
+            access: 'read',
+            persistence: 'none',
+            idempotent: true,
+        }),
+        handler: () => ({ ok: true, output: host.getSnapshot() }),
+    };
+}
+function createUndoCommand() {
+    return {
+        manifest: manifest({
+            id: 'history.undo', title: 'Undo', target: 'authoring', access: 'write',
+            persistence: 'authoring', idempotent: false,
+            shortcut: 'Mod+Z', menu: { path: ['Edit', 'Undo'] },
+        }),
+        available: () => true,
+        handler: (_input, context) => {
+            const result = context.session.undo();
+            if (!result)
+                return { ok: false, diagnostics: [diagnostic('history.undoUnavailable', 'There is no command to undo.')] };
+            return { ok: true, output: historyOutput(context.session) };
+        },
+    };
+}
+function createRedoCommand() {
+    return {
+        manifest: manifest({
+            id: 'history.redo', title: 'Redo', target: 'authoring', access: 'write',
+            persistence: 'authoring', idempotent: false,
+            shortcut: 'Mod+Shift+Z / Ctrl+Y', menu: { path: ['Edit', 'Redo'] },
+        }),
+        handler: (_input, context) => {
+            const result = context.session.redo();
+            if (!result)
+                return { ok: false, diagnostics: [diagnostic('history.redoUnavailable', 'There is no command to redo.')] };
+            return { ok: true, output: historyOutput(context.session) };
+        },
+    };
+}
+function manifest(input) {
+    return {
+        schemaVersion: EDITOR_COMMAND_SCHEMA_VERSION,
+        id: input.id,
+        version: 1,
+        title: input.title,
+        target: input.target,
+        access: input.access,
+        stability: 'stable',
+        inputSchema: { type: 'object', additionalProperties: false },
+        outputSchema: { type: 'object' },
+        effects: {
+            persistence: input.persistence,
+            undoable: input.id === 'history.undo' || input.id === 'history.redo',
+            idempotent: input.idempotent,
+        },
+        presentation: {
+            category: 'History',
+            inputMode: 'none',
+            ...(input.shortcut ? { shortcut: input.shortcut } : {}),
+            ...(input.menu ? { menu: input.menu } : {}),
+        },
+    };
+}
+function historyOutput(session) {
+    const state = session.getState({ cloneDocuments: false });
+    return {
+        documentRevision: state.documentRevision,
+        dirty: state.dirty,
+        canUndo: state.canUndo,
+        canRedo: state.canRedo,
+    };
+}
+function createSnapshot(state, serviceInstanceId, eventCursor) {
+    return {
+        serviceInstanceId,
+        documentRevision: state.documentRevision,
+        documentStructureRevision: state.documentStructureRevision,
+        eventCursor,
+        dirty: state.dirty,
+        canUndo: state.canUndo,
+        canRedo: state.canRedo,
+        history: {
+            entries: state.history.entries
+                .slice(0, DEFAULT_HISTORY_VIEW_LIMIT)
+                .map(entry => ({ ...entry })),
+        },
+        document: state.workingDocument,
+        savedDocument: state.persistedDocument,
+    };
+}
+function cancelledDiagnostic(commandId) {
+    return {
+        ok: false,
+        diagnostics: [diagnostic('command.cancelled', `Editor command was cancelled: ${commandId}`)],
+    };
+}
+function diagnostic(code, message, details) {
+    return {
+        severity: 'error',
+        source: 'command-system',
+        code,
+        message,
+        ...(details ? { details } : {}),
+    };
+}
+function normalizeRequiredId(value, label) {
+    if (typeof value !== 'string' || !value.trim())
+        throw new Error(`Editor Authoring Host ${label} is required.`);
+    return value.trim();
+}
+function normalizePositiveInteger(value, fallback) {
+    return Number.isInteger(value) && value > 0 ? value : fallback;
+}
+//# sourceMappingURL=editor-authoring-host.js.map