@modelprofile.com/flexharness 10.24.0 → 11.0.0

package/dist_ts/classes.flexharness.sessions.d.ts

@@ -0,0 +1,20 @@
+import { type IFlexCreateSessionOptions, type IFlexEventArchiveMetadata, type IFlexMessage, type IFlexMessagePage, type IFlexMessagePageOptions, type IFlexSession, type IFlexSessionView, type IFlexSessionMetrics, type IFlexUpdateSessionOptions, type IJsonObject } from './interfaces.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+/** Sessions and their messages: listing, creation, updates, views and message pages. */
+export declare class FlexHarnessSessions<TScope> {
+    private readonly core;
+    constructor(core: FlexHarnessCore<TScope>);
+    listSessions(scopeId: string): Promise<IFlexSession[]>;
+    createSession(scopeId: string, options?: IFlexCreateSessionOptions): Promise<IFlexSession>;
+    getSession(scopeId: string, sessionId: string): Promise<IFlexSession>;
+    getSessionMetrics(scopeId: string, sessionId: string): Promise<IFlexSessionMetrics>;
+    updateSession(scopeId: string, sessionId: string, options: IFlexUpdateSessionOptions): Promise<IFlexSession>;
+    getSessionView(scopeId: string, sessionId: string): Promise<IFlexSessionView>;
+    getMessages(scopeId: string, sessionId: string): Promise<IFlexMessage[]>;
+    listMessagePage(scopeId: string, sessionId: string, options?: IFlexMessagePageOptions): Promise<IFlexMessagePage>;
+    getMessage(scopeId: string, sessionId: string, messageId: string): Promise<IFlexMessage>;
+    pushRuntimeEvent(scopeId: string, sessionId: string, event: IJsonObject & {
+        type: string;
+    }): Promise<void>;
+    archiveSessionEvents(scopeId: string, sessionId: string, compactionEventId?: string): Promise<IFlexEventArchiveMetadata | undefined>;
+}

package/dist_ts/classes.flexharness.sessions.js

@@ -0,0 +1,381 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessAbortError, FlexHarnessSessionBusyError, FlexHarnessValidationError, } from './errors.js';
+import { FLEX_PROJECT_MANAGEMENT_LIMITS, } from './interfaces.js';
+import { cloneSerializable } from './utils.json.js';
+import { createBoundedTransferMessage, jsonBytes, maxMessagePageCursorBytes, maxMessagePageSize, maxTransferPageBytes, publicSnapshot, requireTransferIdentifier, } from './utils.transfer.js';
+import { validateIdentifier, validateSessionGenerationId, validateSessionConfigurationRef, validateUpdateSessionOptions, validateUtf8String, } from './utils.validation.js';
+import { sessionMetricsView } from './utils.sessionmetrics.js';
+import { createSessionGenerationId, requireSessionGeneration, combineErrors, } from './utils.flexharness.js';
+/**
+ * Consecutive waits a session view makes for queued writes and open sections to settle. Each wait
+ * ends only when real work finishes, so the bound limits starvation by a session that never stops
+ * changing, not the time one slow save may take.
+ */
+const maxSessionViewPasses = 64;
+/** Sessions and their messages: listing, creation, updates, views and message pages. */
+export class FlexHarnessSessions {
+    core;
+    constructor(core) {
+        this.core = core;
+    }
+    async listSessions(scopeId) {
+        const { state } = await this.core.resolveState(scopeId);
+        await state.scopeQueue;
+        this.core.assertOpen();
+        this.core.assertStateAcceptingWork(state);
+        return publicSnapshot([...state.sessions.values()]
+            .filter((stored) => !state.initializingSessions.has(stored.session.sessionId))
+            .map((stored) => stored.session)
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)));
+    }
+    async createSession(scopeId, options = {}) {
+        if (!options || typeof options !== 'object' || Array.isArray(options)) {
+            throw new FlexHarnessValidationError('createSession options must be a plain object.');
+        }
+        const unsupported = Object.keys(options).find((key) => !['sessionId', 'sessionGenerationId', 'configurationRef', 'title'].includes(key));
+        if (unsupported)
+            throw new FlexHarnessValidationError(`createSession does not support "${unsupported}".`);
+        const requestedSessionGenerationId = options.sessionGenerationId;
+        if (requestedSessionGenerationId !== undefined) {
+            validateSessionGenerationId(requestedSessionGenerationId);
+        }
+        if (options.configurationRef !== undefined)
+            validateSessionConfigurationRef(options.configurationRef);
+        const resolved = await this.core.resolveState(scopeId);
+        const sessionId = options.sessionId ?? plugins.crypto.randomUUID();
+        validateIdentifier(sessionId, 'sessionId');
+        requireTransferIdentifier(sessionId, 'sessionId');
+        if (options.title !== undefined) {
+            validateUtf8String(options.title, 'title', FLEX_PROJECT_MANAGEMENT_LIMITS.maxTitleBytes, true);
+        }
+        await resolved.state.scopeQueue;
+        if (resolved.state.sessions.has(sessionId)
+            || resolved.state.tombstones.has(sessionId)
+            || resolved.state.initializingSessions.has(sessionId)) {
+            throw new FlexHarnessValidationError(`Session "${sessionId}" already exists or is being deleted.`);
+        }
+        resolved.state.initializingSessions.add(sessionId);
+        let resolveInitialization;
+        const initializationCompletion = new Promise((resolve) => {
+            resolveInitialization = resolve;
+        });
+        let initializationCompleted = false;
+        const completeInitialization = () => {
+            if (initializationCompleted)
+                return;
+            initializationCompleted = true;
+            if (resolved.state.sessionInitializations.get(sessionId) === initializationCompletion) {
+                resolved.state.sessionInitializations.delete(sessionId);
+            }
+            resolveInitialization();
+        };
+        resolved.state.sessionInitializations.set(sessionId, initializationCompletion);
+        let scopeReserved = false;
+        let metadata;
+        try {
+            await this.core.mutateScope(resolved.state, () => {
+                if (resolved.state.sessions.has(sessionId) || resolved.state.tombstones.has(sessionId)) {
+                    throw new FlexHarnessValidationError(`Session "${sessionId}" already exists or is being deleted.`);
+                }
+                const timestamp = new Date().toISOString();
+                metadata = {
+                    scopeId,
+                    sessionId,
+                    sessionGenerationId: requestedSessionGenerationId ?? createSessionGenerationId(),
+                    sessionGenerationSequence: resolved.state.revision + 1,
+                    ...(options.configurationRef === undefined ? {} : { configurationRef: options.configurationRef }),
+                    ...(options.title ? { title: options.title } : {}),
+                    createdAt: timestamp,
+                    updatedAt: timestamp,
+                    status: 'idle',
+                    activity: { status: 'idle' },
+                    depth: 0,
+                };
+                resolved.state.sessions.set(sessionId, this.core.createUninitializedStoredSession(metadata, resolved.state.storageKey));
+            });
+            scopeReserved = true;
+            const placeholder = resolved.state.sessions.get(sessionId);
+            const initialization = this.core.loadSessionRuntime(resolved.state, metadata, scopeId, resolved.scope.scope, placeholder.compactorLifecycleController, true);
+            const loaded = await initialization;
+            if (resolved.state.sessions.get(sessionId) !== placeholder) {
+                const aborted = new FlexHarnessAbortError('The session was deleted while it was being created.');
+                try {
+                    await this.core.lifecycle.closeStoredSession(loaded);
+                }
+                catch (closeError) {
+                    this.core.lifecycle.orphanedStoredSessions.add(loaded);
+                    throw combineErrors([aborted, closeError]);
+                }
+                throw aborted;
+            }
+            resolved.state.sessions.set(sessionId, loaded);
+        }
+        catch (error) {
+            const projectedError = this.core.projectOperationError(error, 'agentSession', scopeId, sessionId, 'session-create');
+            scopeReserved ||= resolved.state.sessions.has(sessionId);
+            if (!scopeReserved)
+                throw projectedError;
+            const tombstone = {
+                sessionId,
+                ...requireSessionGeneration(metadata),
+                deletedAt: new Date().toISOString(),
+                rootSessionId: sessionId,
+                depth: 0,
+            };
+            let tombstoneCommitted = false;
+            let domainCleanupCompleted = false;
+            try {
+                await this.core.mutateScope(resolved.state, () => {
+                    resolved.state.sessions.delete(sessionId);
+                    resolved.state.tombstones.set(sessionId, tombstone);
+                }, true);
+                tombstoneCommitted = true;
+                completeInitialization();
+                await this.core.deletion.finishTombstoneCleanup(resolved.state, sessionId, scopeId, { scopeId, scope: resolved.scope.scope });
+                domainCleanupCompleted = true;
+            }
+            catch (cleanupError) {
+                const projectedCleanup = this.core.projectOperationError(cleanupError, 'persistence', scopeId, sessionId, 'session-create-cleanup');
+                if (!tombstoneCommitted || domainCleanupCompleted) {
+                    resolved.state.sessions.delete(sessionId);
+                    const stateLoad = this.core.stateLoads.get(resolved.state.storageKey);
+                    if (stateLoad) {
+                        completeInitialization();
+                        try {
+                            await this.core.lifecycle.drainStorage(resolved.state.storageKey, stateLoad, this.core.trustInternalError(new FlexHarnessAbortError('The session namespace was fenced after uncertain creation cleanup.')), { scopeId, scope: resolved.scope.scope });
+                        }
+                        catch {
+                            // The projected creation and cleanup errors remain safe for the caller.
+                        }
+                    }
+                }
+                throw combineErrors([projectedError, projectedCleanup]);
+            }
+            throw projectedError;
+        }
+        finally {
+            resolved.state.initializingSessions.delete(sessionId);
+            completeInitialization();
+        }
+        const result = publicSnapshot(metadata);
+        this.core.emitEvent(scopeId, metadata, { type: 'session.created', session: result });
+        return result;
+    }
+    async getSession(scopeId, sessionId) {
+        const { state } = await this.core.resolveState(scopeId);
+        await state.scopeQueue;
+        this.core.assertStateAcceptingWork(state);
+        return publicSnapshot(this.core.requireSession(state, sessionId).session);
+    }
+    async getSessionMetrics(scopeId, sessionId) {
+        const { state } = await this.core.resolveState(scopeId);
+        const stored = this.core.requireSession(state, sessionId);
+        await stored.projectionQueue;
+        this.core.assertStateAcceptingWork(state);
+        if (stored.metricsFailure !== undefined)
+            throw stored.metricsFailure;
+        return publicSnapshot(sessionMetricsView(stored.metrics));
+    }
+    async updateSession(scopeId, sessionId, options) {
+        validateUpdateSessionOptions(options);
+        const { state } = await this.core.resolveState(scopeId);
+        let result;
+        await this.core.mutateScope(state, () => {
+            const stored = Object.prototype.hasOwnProperty.call(options, 'archived')
+                ? this.core.requireMutableSession(state, sessionId)
+                : this.core.requireSession(state, sessionId);
+            const timestamp = new Date().toISOString();
+            if (Object.prototype.hasOwnProperty.call(options, 'title')) {
+                if (options.title === null)
+                    delete stored.session.title;
+                else
+                    stored.session.title = options.title;
+            }
+            if (options.archived === true)
+                stored.session.archivedAt ??= timestamp;
+            else if (options.archived === false)
+                delete stored.session.archivedAt;
+            stored.session.updatedAt = timestamp;
+            result = publicSnapshot(stored.session);
+        });
+        this.core.emitEvent(scopeId, result, { type: 'session.updated', session: result });
+        return result;
+    }
+    async getSessionView(scopeId, sessionId) {
+        const { state } = await this.core.resolveState(scopeId);
+        let stored = this.core.requireSession(state, sessionId);
+        for (let pass = 0;; pass++) {
+            if (pass === maxSessionViewPasses) {
+                throw new FlexHarnessSessionBusyError(sessionId, `kept changing through ${maxSessionViewPasses} consecutive waits for a settled view`);
+            }
+            const scopeQueue = state.scopeQueue;
+            const projectionQueue = stored.projectionQueue;
+            const publications = [...(state.publications.get(sessionId) ?? [])];
+            await Promise.all([scopeQueue, projectionQueue, ...publications]);
+            this.core.assertStateAcceptingWork(state);
+            stored = this.core.requireSession(state, sessionId);
+            if (state.scopeQueue === scopeQueue
+                && stored.projectionQueue === projectionQueue
+                && !state.publications.get(sessionId)?.size)
+                break;
+        }
+        const run = state.activeRuns.get(sessionId);
+        const messages = this.core.visibleMessages(stored).map((message) => (run && run.stored === stored && message.messageId === run.assistantMessageId
+            && message.status === 'streaming'
+            ? { ...message, parts: run.callbackParts }
+            : message));
+        return publicSnapshot({
+            session: stored.session,
+            messages,
+            pendingPermissions: [...state.pendingPermissions.values()]
+                .map((pending) => pending.request)
+                .filter((request) => request.sessionId === sessionId)
+                .sort((left, right) => left.createdAt.localeCompare(right.createdAt)),
+            sequence: this.core.sequence,
+        });
+    }
+    async getMessages(scopeId, sessionId) {
+        const { state } = await this.core.resolveState(scopeId);
+        const stored = this.core.requireSession(state, sessionId);
+        await stored.projectionQueue;
+        this.core.assertStateAcceptingWork(state);
+        return publicSnapshot(this.core.visibleMessages(stored));
+    }
+    async listMessagePage(scopeId, sessionId, options = {}) {
+        if (!options || typeof options !== 'object' || Array.isArray(options)) {
+            throw new FlexHarnessValidationError('Message page options must be a plain object.');
+        }
+        const unsupported = Object.keys(options).find((key) => key !== 'limit' && key !== 'before');
+        if (unsupported)
+            throw new FlexHarnessValidationError(`Message page options do not support "${unsupported}".`);
+        const limit = options.limit ?? maxMessagePageSize;
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > maxMessagePageSize) {
+            throw new FlexHarnessValidationError(`Message page limit must be an integer from 1 through ${maxMessagePageSize}.`);
+        }
+        if (options.before !== undefined
+            && (typeof options.before !== 'string'
+                || !options.before
+                || Buffer.byteLength(options.before, 'utf8') > maxMessagePageCursorBytes)) {
+            throw new FlexHarnessValidationError('Message page cursor is invalid.');
+        }
+        const { state } = await this.core.resolveState(scopeId);
+        const stored = this.core.requireSession(state, sessionId);
+        await stored.projectionQueue;
+        this.core.assertStateAcceptingWork(state);
+        const namespace = this.core.messageCursorNamespace(state.storageKey);
+        const visibleMessages = this.core.visibleMessages(stored);
+        let end = visibleMessages.length;
+        if (options.before !== undefined) {
+            const cursor = this.core.parseMessageCursor(options.before);
+            if (cursor.namespace !== namespace || cursor.sessionId !== sessionId) {
+                throw new FlexHarnessValidationError('Message page cursor is invalid.');
+            }
+            const anchor = visibleMessages.findIndex((message) => message.messageId === cursor.anchorMessageId);
+            if (anchor < 0)
+                throw new FlexHarnessValidationError('Message page cursor is stale.');
+            end = anchor;
+        }
+        let start = end;
+        let messages = [];
+        for (let index = end - 1; index >= 0 && messages.length < limit; index--) {
+            const candidate = createBoundedTransferMessage(visibleMessages[index]);
+            const candidateMessages = [candidate, ...messages];
+            const nextCursor = index > 0
+                ? this.core.createMessageCursor(namespace, sessionId, candidate.messageId)
+                : undefined;
+            const candidatePage = {
+                messages: candidateMessages,
+                startIndex: index,
+                ...(nextCursor ? { nextCursor } : {}),
+            };
+            if (jsonBytes(candidatePage) > maxTransferPageBytes)
+                break;
+            start = index;
+            messages = candidateMessages;
+        }
+        if (messages.length === 0 && end > 0) {
+            throw new FlexHarnessValidationError('Stored message exceeds the page transfer limit.');
+        }
+        const nextCursor = start > 0
+            ? this.core.createMessageCursor(namespace, sessionId, messages[0].messageId)
+            : undefined;
+        return publicSnapshot({ messages, startIndex: start, ...(nextCursor ? { nextCursor } : {}) });
+    }
+    async getMessage(scopeId, sessionId, messageId) {
+        validateIdentifier(messageId, 'messageId');
+        requireTransferIdentifier(messageId, 'messageId');
+        const { state } = await this.core.resolveState(scopeId);
+        const stored = this.core.requireSession(state, sessionId);
+        await stored.projectionQueue;
+        this.core.assertStateAcceptingWork(state);
+        return publicSnapshot(createBoundedTransferMessage(this.core.requireMessage(stored, messageId)));
+    }
+    async pushRuntimeEvent(scopeId, sessionId, event) {
+        this.core.validateRuntimeEvent(event);
+        const { scope, state } = await this.core.resolveState(scopeId);
+        const stored = this.core.requireSession(state, sessionId);
+        this.core.assertSessionWritable(stored);
+        this.core.assertStateAcceptingWork(state);
+        try {
+            await this.core.compaction.withCompactorContext(this.core.compaction.createCompactorContext(scopeId, scope.scope, state.storageKey, sessionId), () => stored.agentSession.pushRuntimeEvent(cloneSerializable(event)));
+        }
+        catch (error) {
+            throw this.core.projectOperationError(error, 'agentSession', scopeId, sessionId, 'runtime-event');
+        }
+    }
+    async archiveSessionEvents(scopeId, sessionId, compactionEventId) {
+        if (compactionEventId !== undefined) {
+            validateIdentifier(compactionEventId, 'compactionEventId');
+            requireTransferIdentifier(compactionEventId, 'compactionEventId');
+        }
+        const { scope, state } = await this.core.resolveState(scopeId);
+        const stored = this.core.requireSession(state, sessionId);
+        this.core.assertSessionWritable(stored);
+        this.core.assertStateAcceptingWork(state);
+        this.core.commands.requireSessionAvailableForSlashCommand(state, stored, 'archive');
+        const compaction = compactionEventId === undefined
+            ? [...stored.agentSession.getEvents()].reverse().find((event) => event.type === 'context-compaction')
+            : stored.agentSession.getEvents().find((event) => event.type === 'context-compaction' && event.id === compactionEventId);
+        if (!compaction || compaction.type !== 'context-compaction')
+            return undefined;
+        let archive;
+        try {
+            archive = await stored.agentSession.archiveCompactedEvents(compaction.id);
+        }
+        catch (error) {
+            throw this.core.projectOperationError(error, 'agentSession', scopeId, sessionId, 'archive');
+        }
+        if (!archive)
+            return undefined;
+        let branchCommitted = false;
+        try {
+            const archivedIds = new Set(archive.events.map((event) => event.id));
+            await this.core.mutateProjection(state, stored, () => {
+                branchCommitted = this.core.reversions.commitRevertedBranchState(stored);
+                for (const segment of stored.reversionSegments) {
+                    if (segment.eventIds.some((eventId) => archivedIds.has(eventId))) {
+                        segment.contextAvailable = false;
+                    }
+                }
+                this.core.reversions.pruneReversionState(stored);
+            }, true);
+        }
+        catch (error) {
+            throw this.core.projectOperationError(error, 'persistence', scopeId, sessionId, 'archive-horizon');
+        }
+        if (branchCommitted) {
+            this.core.emitEvent(scopeId, stored.session, {
+                type: 'session.history.changed',
+                direction: 'branch',
+            });
+        }
+        await this.core.reversions.drainReversionReleases(state, stored, scopeId, scope.scope, false);
+        return publicSnapshot({
+            archiveId: this.core.boundedIdentifier(archive.archiveId, 'archiveId'),
+            sessionId: this.core.boundedIdentifier(archive.sessionId, 'sessionId'),
+            createdAt: new Date(archive.createdAt).toISOString(),
+            eventCount: archive.events.length,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexharness.sessions.js","sourceRoot":"","sources":["../ts/classes.flexharness.sessions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,EACL,qBAAqB,EACrB,2BAA2B,EAC3B,0BAA0B,GAC3B,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,8BAA8B,GAY/B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EACL,4BAA4B,EAC5B,SAAS,EACT,yBAAyB,EACzB,kBAAkB,EAClB,oBAAoB,EACpB,cAAc,EACd,yBAAyB,GAC1B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,kBAAkB,EAClB,2BAA2B,EAC3B,+BAA+B,EAC/B,4BAA4B,EAC5B,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EACxB,aAAa,GACd,MAAM,wBAAwB,CAAC;AAGhC;;;;GAIG;AACH,MAAM,oBAAoB,GAAG,EAAE,CAAC;AAEhC,wFAAwF;AACxF,MAAM,OAAO,mBAAmB;IACD,IAAI;IAAjC,YAA6B,IAA6B;oBAA7B,IAAI;IAA4B,CAAC;IAEvD,KAAK,CAAC,YAAY,CAAC,OAAe;QACvC,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACxD,MAAM,KAAK,CAAC,UAAU,CAAC;QACvB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;QACvB,IAAI,CAAC,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;QAC1C,OAAO,cAAc,CAAC,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;aAC/C,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;aAC7E,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC;aAC/B,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAC3E,CAAC;IAEM,KAAK,CAAC,aAAa,CACxB,OAAe,EACf,OAAO,GAA8B,EAAE;QAEvC,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YACtE,MAAM,IAAI,0BAA0B,CAAC,+CAA+C,CAAC,CAAC;QACxF,CAAC;QACD,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAC3C,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAC1F,CAAC;QACF,IAAI,WAAW;YAAE,MAAM,IAAI,0BAA0B,CAAC,mCAAmC,WAAW,IAAI,CAAC,CAAC;QAC1G,MAAM,4BAA4B,GAAG,OAAO,CAAC,mBAAmB,CAAC;QACjE,IAAI,4BAA4B,KAAK,SAAS,EAAE,CAAC;YAC/C,2BAA2B,CAAC,4BAA4B,CAAC,CAAC;QAC5D,CAAC;QACD,IAAI,OAAO,CAAC,gBAAgB,KAAK,SAAS;YAAE,+BAA+B,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;QACtG,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACvD,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QACnE,kBAAkB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QAC3C,yBAAyB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QAClD,IAAI,OAAO,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAChC,kBAAkB,CAChB,OAAO,CAAC,KAAK,EACb,OAAO,EACP,8BAA8B,CAAC,aAAa,EAC5C,IAAI,CACL,CAAC;QACJ,CAAC;QACD,MAAM,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC;QAChC,IACE,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC;eACnC,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC;eACxC,QAAQ,CAAC,KAAK,CAAC,oBAAoB,CAAC,GAAG,CAAC,SAAS,CAAC,EACrD,CAAC;YACD,MAAM,IAAI,0BAA0B,CAAC,YAAY,SAAS,uCAAuC,CAAC,CAAC;QACrG,CAAC;QACD,QAAQ,CAAC,KAAK,CAAC,oBAAoB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACnD,IAAI,qBAAkC,CAAC;QACvC,MAAM,wBAAwB,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YAC7D,qBAAqB,GAAG,OAAO,CAAC;QAClC,CAAC,CAAC,CAAC;QACH,IAAI,uBAAuB,GAAG,KAAK,CAAC;QACpC,MAAM,sBAAsB,GAAG,GAAG,EAAE;YAClC,IAAI,uBAAuB;gBAAE,OAAO;YACpC,uBAAuB,GAAG,IAAI,CAAC;YAC/B,IAAI,QAAQ,CAAC,KAAK,CAAC,sBAAsB,CAAC,GAAG,CAAC,SAAS,CAAC,KAAK,wBAAwB,EAAE,CAAC;gBACtF,QAAQ,CAAC,KAAK,CAAC,sBAAsB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YAC1D,CAAC;YACD,qBAAqB,EAAE,CAAC;QAC1B,CAAC,CAAC;QACF,QAAQ,CAAC,KAAK,CAAC,sBAAsB,CAAC,GAAG,CAAC,SAAS,EAAE,wBAAwB,CAAC,CAAC;QAC/E,IAAI,aAAa,GAAG,KAAK,CAAC;QAC1B,IAAI,QAAuB,CAAC;QAC5B,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE;gBAC/C,IAAI,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;oBACvF,MAAM,IAAI,0BAA0B,CAAC,YAAY,SAAS,uCAAuC,CAAC,CAAC;gBACrG,CAAC;gBACD,MAAM,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;gBAC3C,QAAQ,GAAG;oBACT,OAAO;oBACP,SAAS;oBACT,mBAAmB,EAAE,4BAA4B,IAAI,yBAAyB,EAAE;oBAChF,yBAAyB,EAAE,QAAQ,CAAC,KAAK,CAAC,QAAQ,GAAG,CAAC;oBACtD,GAAG,CAAC,OAAO,CAAC,gBAAgB,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,OAAO,CAAC,gBAAgB,EAAE,CAAC;oBACjG,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;oBAClD,SAAS,EAAE,SAAS;oBACpB,SAAS,EAAE,SAAS;oBACpB,MAAM,EAAE,MAAM;oBACd,QAAQ,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE;oBAC5B,KAAK,EAAE,CAAC;iBACT,CAAC;gBACF,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CACzB,SAAS,EACT,IAAI,CAAC,IAAI,CAAC,gCAAgC,CAAC,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,CAChF,CAAC;YACJ,CAAC,CAAC,CAAC;YACH,aAAa,GAAG,IAAI,CAAC;YACrB,MAAM,WAAW,GAAG,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAE,CAAC;YAC5D,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,kBAAkB,CACjD,QAAQ,CAAC,KAAK,EACd,QAAQ,EACR,OAAO,EACP,QAAQ,CAAC,KAAK,CAAC,KAAK,EACpB,WAAW,CAAC,4BAA4B,EACxC,IAAI,CACL,CAAC;YACF,MAAM,MAAM,GAAG,MAAM,cAAc,CAAC;YACpC,IAAI,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,KAAK,WAAW,EAAE,CAAC;gBAC3D,MAAM,OAAO,GAAG,IAAI,qBAAqB,CAAC,qDAAqD,CAAC,CAAC;gBACjG,IAAI,CAAC;oBACH,MAAM,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;gBACvD,CAAC;gBAAC,OAAO,UAAU,EAAE,CAAC;oBACpB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;oBACvD,MAAM,aAAa,CAAC,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC;gBAC7C,CAAC;gBACD,MAAM,OAAO,CAAC;YAChB,CAAC;YACD,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QACjD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,qBAAqB,CACpD,KAAK,EACL,cAAc,EACd,OAAO,EACP,SAAS,EACT,gBAAgB,CACjB,CAAC;YACF,aAAa,KAAK,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YACzD,IAAI,CAAC,aAAa;gBAAE,MAAM,cAAc,CAAC;YACzC,MAAM,SAAS,GAA0B;gBACvC,SAAS;gBACT,GAAG,wBAAwB,CAAC,QAAQ,CAAC;gBACrC,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;gBACnC,aAAa,EAAE,SAAS;gBACxB,KAAK,EAAE,CAAC;aACT,CAAC;YACF,IAAI,kBAAkB,GAAG,KAAK,CAAC;YAC/B,IAAI,sBAAsB,GAAG,KAAK,CAAC;YACnC,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE;oBAC/C,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;oBAC1C,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;gBACtD,CAAC,EAAE,IAAI,CAAC,CAAC;gBACT,kBAAkB,GAAG,IAAI,CAAC;gBAC1B,sBAAsB,EAAE,CAAC;gBACzB,MAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,sBAAsB,CAC7C,QAAQ,CAAC,KAAK,EACd,SAAS,EACT,OAAO,EACP,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,CACzC,CAAC;gBACF,sBAAsB,GAAG,IAAI,CAAC;YAChC,CAAC;YAAC,OAAO,YAAY,EAAE,CAAC;gBACtB,MAAM,gBAAgB,GAAG,IAAI,CAAC,IAAI,CAAC,qBAAqB,CACtD,YAAY,EACZ,aAAa,EACb,OAAO,EACP,SAAS,EACT,wBAAwB,CACzB,CAAC;gBACF,IAAI,CAAC,kBAAkB,IAAI,sBAAsB,EAAE,CAAC;oBAClD,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;oBAC1C,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;oBACtE,IAAI,SAAS,EAAE,CAAC;wBACd,sBAAsB,EAAE,CAAC;wBACzB,IAAI,CAAC;4BACH,MAAM,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,CACpC,QAAQ,CAAC,KAAK,CAAC,UAAU,EACzB,SAAS,EACT,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,qBAAqB,CACpD,oEAAoE,CACrE,CAAC,EACF,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,CACzC,CAAC;wBACJ,CAAC;wBAAC,MAAM,CAAC;4BACP,wEAAwE;wBAC1E,CAAC;oBACH,CAAC;gBACH,CAAC;gBACD,MAAM,aAAa,CAAC,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC,CAAC;YAC1D,CAAC;YACD,MAAM,cAAc,CAAC;QACvB,CAAC;gBAAS,CAAC;YACT,QAAQ,CAAC,KAAK,CAAC,oBAAoB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;YACtD,sBAAsB,EAAE,CAAC;QAC3B,CAAC;QACD,MAAM,MAAM,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC;QACxC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;QACrF,OAAO,MAAM,CAAC;IAChB,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,OAAe,EAAE,SAAiB;QACxD,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACxD,MAAM,KAAK,CAAC,UAAU,CAAC;QACvB,IAAI,CAAC,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;QAC1C,OAAO,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC;IAC5E,CAAC;IAEM,KAAK,CAAC,iBAAiB,CAAC,OAAe,EAAE,SAAiB;QAC/D,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACxD,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QAC1D,MAAM,MAAM,CAAC,eAAe,CAAC;QAC7B,IAAI,CAAC,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;QAC1C,IAAI,MAAM,CAAC,cAAc,KAAK,SAAS;YAAE,MAAM,MAAM,CAAC,cAAc,CAAC;QACrE,OAAO,cAAc,CAAC,kBAAkB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IAC5D,CAAC;IAEM,KAAK,CAAC,aAAa,CACxB,OAAe,EACf,SAAiB,EACjB,OAAkC;QAElC,4BAA4B,CAAC,OAAO,CAAC,CAAC;QACtC,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACxD,IAAI,MAAqB,CAAC;QAC1B,MAAM,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,GAAG,EAAE;YACtC,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC;gBACtE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE,SAAS,CAAC;gBACnD,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;YAC/C,MAAM,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;YAC3C,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC;gBAC3D,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI;oBAAE,OAAO,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC;;oBACnD,MAAM,CAAC,OAAO,CAAC,KAAK,GAAG,OAAO,CAAC,KAAM,CAAC;YAC7C,CAAC;YACD,IAAI,OAAO,CAAC,QAAQ,KAAK,IAAI;gBAAE,MAAM,CAAC,OAAO,CAAC,UAAU,KAAK,SAAS,CAAC;iBAClE,IAAI,OAAO,CAAC,QAAQ,KAAK,KAAK;gBAAE,OAAO,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC;YACtE,MAAM,CAAC,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;YACrC,MAAM,GAAG,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;QACnF,OAAO,MAAM,CAAC;IAChB,CAAC;IAEM,KAAK,CAAC,cAAc,CAAC,OAAe,EAAE,SAAiB;QAC5D,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACxD,IAAI,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QACxD,KAAK,IAAI,IAAI,GAAG,CAAC,GAAI,IAAI,EAAE,EAAE,CAAC;YAC5B,IAAI,IAAI,KAAK,oBAAoB,EAAE,CAAC;gBAClC,MAAM,IAAI,2BAA2B,CACnC,SAAS,EACT,yBAAyB,oBAAoB,uCAAuC,CACrF,CAAC;YACJ,CAAC;YACD,MAAM,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC;YACpC,MAAM,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC;YAC/C,MAAM,YAAY,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;YACpE,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,eAAe,EAAE,GAAG,YAAY,CAAC,CAAC,CAAC;YAClE,IAAI,CAAC,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;YAC1C,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;YACpD,IACE,KAAK,CAAC,UAAU,KAAK,UAAU;mBAC5B,MAAM,CAAC,eAAe,KAAK,eAAe;mBAC1C,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,IAAI;gBAC3C,MAAM;QACV,CAAC;QACD,MAAM,GAAG,GAAG,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC5C,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAClE,GAAG,IAAI,GAAG,CAAC,MAAM,KAAK,MAAM,IAAI,OAAO,CAAC,SAAS,KAAK,GAAG,CAAC,kBAAkB;eACvE,OAAO,CAAC,MAAM,KAAK,WAAW;YACjC,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,KAAK,EAAE,GAAG,CAAC,aAAa,EAAE;YAC1C,CAAC,CAAC,OAAO,CACZ,CAAC,CAAC;QACH,OAAO,cAAc,CAAC;YACpB,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,QAAQ;YACR,kBAAkB,EAAE,CAAC,GAAG,KAAK,CAAC,kBAAkB,CAAC,MAAM,EAAE,CAAC;iBACvD,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC;iBACjC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC;iBACpD,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;YACvE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ;SAC7B,CAAC,CAAC;IACL,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,OAAe,EAAE,SAAiB;QACzD,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACxD,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QAC1D,MAAM,MAAM,CAAC,eAAe,CAAC;QAC7B,IAAI,CAAC,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;QAC1C,OAAO,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC;IAC3D,CAAC;IAEM,KAAK,CAAC,eAAe,CAC1B,OAAe,EACf,SAAiB,EACjB,OAAO,GAA4B,EAAE;QAErC,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YACtE,MAAM,IAAI,0BAA0B,CAAC,8CAA8C,CAAC,CAAC;QACvF,CAAC;QACD,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,KAAK,OAAO,IAAI,GAAG,KAAK,QAAQ,CAAC,CAAC;QAC5F,IAAI,WAAW;YAAE,MAAM,IAAI,0BAA0B,CAAC,wCAAwC,WAAW,IAAI,CAAC,CAAC;QAC/G,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,kBAAkB,CAAC;QAClD,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,GAAG,kBAAkB,EAAE,CAAC;YAC5E,MAAM,IAAI,0BAA0B,CAAC,wDAAwD,kBAAkB,GAAG,CAAC,CAAC;QACtH,CAAC;QACD,IACE,OAAO,CAAC,MAAM,KAAK,SAAS;eACzB,CAAC,OAAO,OAAO,CAAC,MAAM,KAAK,QAAQ;mBACjC,CAAC,OAAO,CAAC,MAAM;mBACf,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,yBAAyB,CAAC,EAC3E,CAAC;YACD,MAAM,IAAI,0BAA0B,CAAC,iCAAiC,CAAC,CAAC;QAC1E,CAAC;QACD,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACxD,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QAC1D,MAAM,MAAM,CAAC,eAAe,CAAC;QAC7B,IAAI,CAAC,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;QAC1C,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QACrE,MAAM,eAAe,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;QAC1D,IAAI,GAAG,GAAG,eAAe,CAAC,MAAM,CAAC;QACjC,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YACjC,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAC5D,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;gBACrE,MAAM,IAAI,0BAA0B,CAAC,iCAAiC,CAAC,CAAC;YAC1E,CAAC;YACD,MAAM,MAAM,GAAG,eAAe,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,SAAS,KAAK,MAAM,CAAC,eAAe,CAAC,CAAC;YACpG,IAAI,MAAM,GAAG,CAAC;gBAAE,MAAM,IAAI,0BAA0B,CAAC,+BAA+B,CAAC,CAAC;YACtF,GAAG,GAAG,MAAM,CAAC;QACf,CAAC;QACD,IAAI,KAAK,GAAG,GAAG,CAAC;QAChB,IAAI,QAAQ,GAAmB,EAAE,CAAC;QAClC,KAAK,IAAI,KAAK,GAAG,GAAG,GAAG,CAAC,EAAE,KAAK,IAAI,CAAC,IAAI,QAAQ,CAAC,MAAM,GAAG,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC;YACzE,MAAM,SAAS,GAAG,4BAA4B,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC;YACvE,MAAM,iBAAiB,GAAG,CAAC,SAAS,EAAE,GAAG,QAAQ,CAAC,CAAC;YACnD,MAAM,UAAU,GAAG,KAAK,GAAG,CAAC;gBAC1B,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC,SAAS,CAAC;gBAC1E,CAAC,CAAC,SAAS,CAAC;YACd,MAAM,aAAa,GAAqB;gBACtC,QAAQ,EAAE,iBAAiB;gBAC3B,UAAU,EAAE,KAAK;gBACjB,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aACtC,CAAC;YACF,IAAI,SAAS,CAAC,aAAa,CAAC,GAAG,oBAAoB;gBAAE,MAAM;YAC3D,KAAK,GAAG,KAAK,CAAC;YACd,QAAQ,GAAG,iBAAiB,CAAC;QAC/B,CAAC;QACD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,IAAI,GAAG,GAAG,CAAC,EAAE,CAAC;YACrC,MAAM,IAAI,0BAA0B,CAAC,iDAAiD,CAAC,CAAC;QAC1F,CAAC;QACD,MAAM,UAAU,GAAG,KAAK,GAAG,CAAC;YAC1B,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAC5E,CAAC,CAAC,SAAS,CAAC;QACd,OAAO,cAAc,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAChG,CAAC;IAEM,KAAK,CAAC,UAAU,CACrB,OAAe,EACf,SAAiB,EACjB,SAAiB;QAEjB,kBAAkB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QAC3C,yBAAyB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QAClD,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QACxD,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QAC1D,MAAM,MAAM,CAAC,eAAe,CAAC;QAC7B,IAAI,CAAC,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;QAC1C,OAAO,cAAc,CAAC,4BAA4B,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACnG,CAAC;IAEM,KAAK,CAAC,gBAAgB,CAC3B,OAAe,EACf,SAAiB,EACjB,KAAqC;QAErC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;QACtC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC/D,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QAC1D,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;QACxC,IAAI,CAAC,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;QAC1C,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,oBAAoB,CAC7C,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,sBAAsB,CAAC,OAAO,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,EAAE,SAAS,CAAC,EAC9F,GAAG,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CACrE,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,SAAS,EAAE,eAAe,CAAC,CAAC;QACpG,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,oBAAoB,CAC/B,OAAe,EACf,SAAiB,EACjB,iBAA0B;QAE1B,IAAI,iBAAiB,KAAK,SAAS,EAAE,CAAC;YACpC,kBAAkB,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,CAAC;YAC3D,yBAAyB,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,CAAC;QACpE,CAAC;QACD,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC/D,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QAC1D,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;QACxC,IAAI,CAAC,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;QAC1C,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,sCAAsC,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;QACpF,MAAM,UAAU,GAAG,iBAAiB,KAAK,SAAS;YAChD,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAC5D,KAAK,CAAC,IAAI,KAAK,oBAAoB,CAAC;YACxC,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAC7C,KAAK,CAAC,IAAI,KAAK,oBAAoB,IAAI,KAAK,CAAC,EAAE,KAAK,iBAAiB,CAAC,CAAC;QAC7E,IAAI,CAAC,UAAU,IAAI,UAAU,CAAC,IAAI,KAAK,oBAAoB;YAAE,OAAO,SAAS,CAAC;QAC9E,IAAI,OAAO,CAAC;QACZ,IAAI,CAAC;YACH,OAAO,GAAG,MAAM,MAAM,CAAC,YAAY,CAAC,sBAAsB,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;QAC5E,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;QAC9F,CAAC;QACD,IAAI,CAAC,OAAO;YAAE,OAAO,SAAS,CAAC;QAC/B,IAAI,eAAe,GAAG,KAAK,CAAC;QAC5B,IAAI,CAAC;YACH,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;YACrE,MAAM,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE;gBACnD,eAAe,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,yBAAyB,CAAC,MAAM,CAAC,CAAC;gBACzE,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,iBAAiB,EAAE,CAAC;oBAC/C,IAAI,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC;wBACjE,OAAO,CAAC,gBAAgB,GAAG,KAAK,CAAC;oBACnC,CAAC;gBACH,CAAC;gBACD,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;YACnD,CAAC,EAAE,IAAI,CAAC,CAAC;QACX,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,SAAS,EAAE,iBAAiB,CAAC,CAAC;QACrG,CAAC;QACD,IAAI,eAAe,EAAE,CAAC;YACpB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE;gBAC3C,IAAI,EAAE,yBAAyB;gBAC/B,SAAS,EAAE,QAAQ;aACpB,CAAC,CAAC;QACL,CAAC;QACD,MAAM,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAC9F,OAAO,cAAc,CAAC;YACpB,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,SAAS,EAAE,WAAW,CAAC;YACtE,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,SAAS,EAAE,WAAW,CAAC;YACtE,SAAS,EAAE,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE;YACpD,UAAU,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM;SAClC,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist_ts/classes.flexharness.slashcommands.d.ts

@@ -0,0 +1,40 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessAbortError } from './errors.js';
+import type { IFlexSlashCommandDescriptor, IFlexSlashCommandExecutionOptions, TFlexSlashCommandExecutionResult } from './interfaces.js';
+import type { IStoredSessionState, IStorageState, IActiveSlashCommandExecution, ISlashCommandInvocationOwner, ISlashCommandActivityOwner } from './interfaces.flexharness.js';
+import type { FlexHarnessCore } from './classes.flexharness.core.js';
+/** Slash command listing and execution, and the ownership of their activity. */
+export declare class FlexHarnessSlashCommands<TScope> {
+    private readonly core;
+    readonly activeSlashCommandExecutions: Map<string, IActiveSlashCommandExecution>;
+    private readonly activeSlashCommandListings;
+    readonly slashCommandInvocationContext: plugins.AsyncLocalStorage<ISlashCommandInvocationOwner>;
+    readonly slashCommandActivityContext: plugins.AsyncLocalStorage<ISlashCommandActivityOwner>;
+    constructor(core: FlexHarnessCore<TScope>);
+    listSlashCommands(scopeId: string, sessionId: string): Promise<IFlexSlashCommandDescriptor[]>;
+    private createSlashCommandDescriptors;
+    executeSlashCommand(scopeId: string, sessionId: string, untouchedInput: string, options?: IFlexSlashCommandExecutionOptions): Promise<TFlexSlashCommandExecutionResult>;
+    executeSessionSlashCommand(scopeId: string, sessionId: string, untouchedInput: string, options?: IFlexSlashCommandExecutionOptions): Promise<TFlexSlashCommandExecutionResult>;
+    private executeSlashCommandInternal;
+    private isSessionAvailableForSlashCommand;
+    private slashCommandPromptUnavailableReason;
+    private slashCommandPromptAvailability;
+    private requireSlashCommandPromptAvailable;
+    slashCommandSessionKey(storageKey: string, sessionId: string): string;
+    requireSessionAvailableForSlashCommand(state: IStorageState, stored: IStoredSessionState, commandName: string): void;
+    trackSlashCommandExecution<TResult>(scopeId: string, state: IStorageState, sessionId: string, kind: IActiveSlashCommandExecution['kind'], externalSignal: AbortSignal | undefined, operation: (signal: AbortSignal) => Promise<TResult>): Promise<TResult>;
+    private trackSlashCommandListing;
+    private executeSlashCommandHandler;
+    abortSlashCommandExecutions(storageKey: string | undefined, reason: FlexHarnessAbortError, errors: unknown[], sessionId?: string): Promise<void>;
+    abortSlashCommandListings(storageKey: string | undefined, reason: FlexHarnessAbortError, sessionId?: string): Promise<void> | undefined;
+    ambientSlashCommandOwner(criteria?: {
+        scopeId?: string;
+        storageKey?: string;
+        sessionId?: string;
+    }): ISlashCommandInvocationOwner | ISlashCommandActivityOwner | undefined;
+    assertNoAmbientSlashCommandTeardown(criteria?: {
+        scopeId?: string;
+        storageKey?: string;
+        sessionId?: string;
+    }): void;
+}