@modelprofile.com/flexharness 10.24.0 → 11.0.0

package/dist_ts/classes.flexharness.projects.js

@@ -0,0 +1,575 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessNotFoundError, FlexHarnessStoreConflictError, FlexHarnessValidationError, } from './errors.js';
+import { FLEX_PROJECT_MANAGEMENT_LIMITS, } from './interfaces.js';
+import { cloneSerializable } from './utils.json.js';
+import { assertFlexProjectManagementRecord, assertFlexProjectManagementSnapshot, createEmptyFlexProjectManagementSnapshot, } from './utils.projectmanagement.js';
+import { maxTransferIdentifierBytes, publicSnapshot } from './utils.transfer.js';
+import { validateCreateProjectTaskInput, validateProjectTaskId, validateUpdateProjectTaskInput, validateUtf8String, } from './utils.validation.js';
+import { queueOperation, requireSessionGeneration, sha256Hex } from './utils.flexharness.js';
+const maxProjectManagementTombstoneConflicts = 8;
+/** The project tasks, goal and scratchpad that a session tree shares, and their agent tools. */
+export class FlexHarnessProjectManagement {
+    core;
+    projectManagementQueues = new Map();
+    constructor(core) {
+        this.core = core;
+    }
+    async getProjectState(scopeId, sessionId) {
+        const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId, 'read');
+        const snapshot = await this.readProjectManagementState(state, stored);
+        return this.projectStateResult(snapshot);
+    }
+    async listProjectTasks(scopeId, sessionId) {
+        const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId, 'read');
+        const snapshot = await this.readProjectManagementState(state, stored);
+        return this.projectTasksResult(snapshot, snapshot.tasks);
+    }
+    async createProjectTask(scopeId, sessionId, input) {
+        validateCreateProjectTaskInput(input);
+        const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId, 'write');
+        return this.createProjectTaskInState(state, stored, input, Object.freeze({ actor: 'application' }));
+    }
+    async updateProjectTask(scopeId, sessionId, input) {
+        validateUpdateProjectTaskInput(input);
+        const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId, 'write');
+        return this.updateProjectTaskInState(state, stored, input, Object.freeze({ actor: 'application' }));
+    }
+    async deleteProjectTask(scopeId, sessionId, taskId) {
+        validateProjectTaskId(taskId);
+        const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId, 'write');
+        return this.deleteProjectTaskInState(state, stored, taskId, Object.freeze({ actor: 'application' }));
+    }
+    async clearProjectTasks(scopeId, sessionId) {
+        const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId, 'write');
+        return this.clearProjectTasksInState(state, stored, Object.freeze({ actor: 'application' }));
+    }
+    async getProjectGoal(scopeId, sessionId) {
+        const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId, 'read');
+        const snapshot = await this.readProjectManagementState(state, stored);
+        return this.projectGoalResult(snapshot);
+    }
+    async setProjectGoal(scopeId, sessionId, goal) {
+        validateUtf8String(goal, 'project goal', FLEX_PROJECT_MANAGEMENT_LIMITS.maxGoalBytes, true);
+        const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId, 'write');
+        return this.setProjectGoalInState(state, stored, goal, Object.freeze({ actor: 'application' }));
+    }
+    async clearProjectGoal(scopeId, sessionId) {
+        const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId, 'write');
+        return this.clearProjectGoalInState(state, stored, Object.freeze({ actor: 'application' }));
+    }
+    async getProjectScratchpad(scopeId, sessionId) {
+        const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId, 'read');
+        const snapshot = await this.readProjectManagementState(state, stored);
+        return this.projectScratchpadResult(snapshot);
+    }
+    async setProjectScratchpad(scopeId, sessionId, content) {
+        validateUtf8String(content, 'project scratchpad', FLEX_PROJECT_MANAGEMENT_LIMITS.maxScratchpadBytes);
+        const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId, 'write');
+        return this.setProjectScratchpadInState(state, stored, content, Object.freeze({ actor: 'application' }));
+    }
+    async appendProjectScratchpad(scopeId, sessionId, content) {
+        validateUtf8String(content, 'project scratchpad append', FLEX_PROJECT_MANAGEMENT_LIMITS.maxScratchpadBytes);
+        const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId, 'write');
+        return this.appendProjectScratchpadInState(state, stored, content, Object.freeze({ actor: 'application' }));
+    }
+    async clearProjectScratchpad(scopeId, sessionId) {
+        const { state, stored } = await this.resolveProjectManagementSession(scopeId, sessionId, 'write');
+        return this.clearProjectScratchpadInState(state, stored, Object.freeze({ actor: 'application' }));
+    }
+    requireProjectManagementTools() {
+        const projectManagement = this.core.builtInTools.projectManagement;
+        if (!projectManagement) {
+            throw new FlexHarnessValidationError('Project management is not configured for this FlexHarness.');
+        }
+        return projectManagement;
+    }
+    projectManagementKey(storageKey, sessionId) {
+        return JSON.stringify([storageKey, sessionId]);
+    }
+    queueProjectManagementOperation(storageKey, sessionId, operation) {
+        return queueOperation(this.projectManagementQueues, this.projectManagementKey(storageKey, sessionId), operation);
+    }
+    async awaitProjectManagementOperations(storageKey, sessionIds) {
+        const barriers = [...new Set(sessionIds)]
+            .map((sessionId) => this.projectManagementQueues.get(this.projectManagementKey(storageKey, sessionId)))
+            .filter((barrier) => barrier !== undefined);
+        await Promise.all(barriers);
+    }
+    async resolveProjectManagementSession(scopeId, sessionId, access) {
+        this.requireProjectManagementTools();
+        const { state } = await this.core.resolveState(scopeId);
+        await state.scopeQueue;
+        this.core.assertOpen();
+        this.core.assertStateAcceptingWork(state);
+        const stored = this.core.requireSession(state, sessionId);
+        if (access === 'write')
+            this.core.assertSessionWritable(stored);
+        return { state, stored };
+    }
+    assertProjectManagementSession(state, stored) {
+        this.core.assertOpen();
+        this.core.assertStateAcceptingWork(state);
+        if (state.sessions.get(stored.session.sessionId) !== stored
+            || state.tombstones.has(stored.session.sessionId)) {
+            throw new FlexHarnessNotFoundError('Session', stored.session.sessionId);
+        }
+    }
+    async loadProjectManagementState(state, stored) {
+        const store = this.core.stores.projectManagement;
+        const generation = requireSessionGeneration(stored.session);
+        const sessionContext = this.createProjectManagementSessionContext(state, stored.session);
+        const record = await store.load(state.storageKey, stored.session.sessionId, sessionContext);
+        if (record === undefined) {
+            return createEmptyFlexProjectManagementSnapshot(generation.sessionGenerationId, generation.sessionGenerationSequence);
+        }
+        assertFlexProjectManagementRecord(record);
+        if (record.sessionGenerationId === generation.sessionGenerationId) {
+            if (record.sessionGenerationSequence !== generation.sessionGenerationSequence) {
+                throw new FlexHarnessStoreConflictError(this.projectManagementKey(state.storageKey, stored.session.sessionId), 0, record.revision);
+            }
+            if (!('deletedAt' in record))
+                return cloneSerializable(record);
+            throw new FlexHarnessNotFoundError('Project management state', stored.session.sessionId);
+        }
+        if ('deletedAt' in record
+            && record.sessionGenerationSequence < generation.sessionGenerationSequence) {
+            return createEmptyFlexProjectManagementSnapshot(generation.sessionGenerationId, generation.sessionGenerationSequence);
+        }
+        throw new FlexHarnessStoreConflictError(this.projectManagementKey(state.storageKey, stored.session.sessionId), 0, record.revision);
+    }
+    readProjectManagementState(state, stored) {
+        return this.queueProjectManagementOperation(state.storageKey, stored.session.sessionId, async () => {
+            this.assertProjectManagementSession(state, stored);
+            const snapshot = await this.loadProjectManagementState(state, stored);
+            this.assertProjectManagementSession(state, stored);
+            return publicSnapshot(snapshot);
+        });
+    }
+    mutateProjectManagementState(state, stored, writeContext, mutation) {
+        return this.queueProjectManagementOperation(state.storageKey, stored.session.sessionId, async () => {
+            this.assertProjectManagementSession(state, stored);
+            const snapshot = await this.loadProjectManagementState(state, stored);
+            this.assertProjectManagementSession(state, stored);
+            const expectedRevision = snapshot.revision;
+            const result = mutation(snapshot);
+            if (result.changed) {
+                snapshot.revision = expectedRevision + 1;
+                assertFlexProjectManagementSnapshot(snapshot);
+                this.assertProjectManagementSession(state, stored);
+                await this.core.stores.projectManagement.save(state.storageKey, stored.session.sessionId, cloneSerializable(snapshot), expectedRevision, Object.freeze(cloneSerializable(writeContext)));
+            }
+            return {
+                snapshot: publicSnapshot(snapshot),
+                value: result.value === undefined ? result.value : publicSnapshot(result.value),
+            };
+        });
+    }
+    projectStateResult(snapshot) {
+        return publicSnapshot({ revision: snapshot.revision, state: snapshot });
+    }
+    createProjectManagementSessionContext(state, session) {
+        const source = 'deletedAt' in session
+            ? session.subagent
+            : this.core.subagentTasks.createSubagentProvenance(state, session);
+        const subagent = source === undefined
+            ? undefined
+            : Object.freeze({ ...cloneSerializable(source) });
+        return Object.freeze({
+            ...requireSessionGeneration(session),
+            ...(subagent === undefined ? {} : { subagent }),
+        });
+    }
+    projectTaskResult(snapshot, task) {
+        return publicSnapshot({ revision: snapshot.revision, task, state: snapshot });
+    }
+    projectTasksResult(snapshot, tasks) {
+        return publicSnapshot({ revision: snapshot.revision, tasks, state: snapshot });
+    }
+    projectGoalResult(snapshot) {
+        return publicSnapshot({
+            revision: snapshot.revision,
+            goal: snapshot.goal ?? null,
+            state: snapshot,
+        });
+    }
+    projectScratchpadResult(snapshot) {
+        return publicSnapshot({
+            revision: snapshot.revision,
+            scratchpad: snapshot.scratchpad,
+            state: snapshot,
+        });
+    }
+    async createProjectTaskInState(state, stored, input, writeContext) {
+        const status = input.status ?? 'pending';
+        const priority = input.priority ?? 'medium';
+        const result = await this.mutateProjectManagementState(state, stored, writeContext, (snapshot) => {
+            const existing = snapshot.tasks.find((task) => task.id === input.id);
+            if (existing) {
+                if (existing.content === input.content
+                    && existing.status === status
+                    && existing.priority === priority)
+                    return { changed: false, value: existing };
+                throw new FlexHarnessValidationError(`Project task "${input.id}" already exists with different creation data.`);
+            }
+            if (snapshot.tasks.length >= FLEX_PROJECT_MANAGEMENT_LIMITS.maxTasks) {
+                throw new FlexHarnessValidationError('Project task count has reached its limit.');
+            }
+            const timestamp = new Date().toISOString();
+            const task = {
+                id: input.id,
+                content: input.content,
+                status,
+                priority,
+                createdAt: timestamp,
+                updatedAt: timestamp,
+            };
+            snapshot.tasks.push(task);
+            return { changed: true, value: task };
+        });
+        return this.projectTaskResult(result.snapshot, result.value);
+    }
+    async updateProjectTaskInState(state, stored, input, writeContext) {
+        const result = await this.mutateProjectManagementState(state, stored, writeContext, (snapshot) => {
+            const task = snapshot.tasks.find((entry) => entry.id === input.id);
+            if (!task)
+                throw new FlexHarnessNotFoundError('Project task', input.id);
+            const changed = (input.content !== undefined && input.content !== task.content)
+                || (input.status !== undefined && input.status !== task.status)
+                || (input.priority !== undefined && input.priority !== task.priority);
+            if (!changed)
+                return { changed: false, value: task };
+            if (input.content !== undefined)
+                task.content = input.content;
+            if (input.status !== undefined)
+                task.status = input.status;
+            if (input.priority !== undefined)
+                task.priority = input.priority;
+            task.updatedAt = new Date().toISOString();
+            return { changed: true, value: task };
+        });
+        return this.projectTaskResult(result.snapshot, result.value);
+    }
+    async deleteProjectTaskInState(state, stored, taskId, writeContext) {
+        const result = await this.mutateProjectManagementState(state, stored, writeContext, (snapshot) => {
+            const index = snapshot.tasks.findIndex((task) => task.id === taskId);
+            if (index < 0)
+                throw new FlexHarnessNotFoundError('Project task', taskId);
+            const [task] = snapshot.tasks.splice(index, 1);
+            return { changed: true, value: task };
+        });
+        return this.projectTaskResult(result.snapshot, result.value);
+    }
+    async clearProjectTasksInState(state, stored, writeContext) {
+        const result = await this.mutateProjectManagementState(state, stored, writeContext, (snapshot) => {
+            const tasks = snapshot.tasks;
+            if (tasks.length === 0)
+                return { changed: false, value: [] };
+            snapshot.tasks = [];
+            return { changed: true, value: tasks };
+        });
+        return this.projectTasksResult(result.snapshot, result.value);
+    }
+    async setProjectGoalInState(state, stored, goal, writeContext) {
+        const result = await this.mutateProjectManagementState(state, stored, writeContext, (snapshot) => {
+            if (snapshot.goal === goal)
+                return { changed: false, value: undefined };
+            snapshot.goal = goal;
+            return { changed: true, value: undefined };
+        });
+        return this.projectGoalResult(result.snapshot);
+    }
+    async clearProjectGoalInState(state, stored, writeContext) {
+        const result = await this.mutateProjectManagementState(state, stored, writeContext, (snapshot) => {
+            if (snapshot.goal === undefined)
+                return { changed: false, value: undefined };
+            delete snapshot.goal;
+            return { changed: true, value: undefined };
+        });
+        return this.projectGoalResult(result.snapshot);
+    }
+    async setProjectScratchpadInState(state, stored, content, writeContext) {
+        const result = await this.mutateProjectManagementState(state, stored, writeContext, (snapshot) => {
+            if (snapshot.scratchpad === content)
+                return { changed: false, value: undefined };
+            snapshot.scratchpad = content;
+            return { changed: true, value: undefined };
+        });
+        return this.projectScratchpadResult(result.snapshot);
+    }
+    async appendProjectScratchpadInState(state, stored, content, writeContext) {
+        const result = await this.mutateProjectManagementState(state, stored, writeContext, (snapshot) => {
+            if (content.length === 0)
+                return { changed: false, value: undefined };
+            const appended = `${snapshot.scratchpad}${content}`;
+            validateUtf8String(appended, 'project scratchpad', FLEX_PROJECT_MANAGEMENT_LIMITS.maxScratchpadBytes);
+            snapshot.scratchpad = appended;
+            return { changed: true, value: undefined };
+        });
+        return this.projectScratchpadResult(result.snapshot);
+    }
+    async clearProjectScratchpadInState(state, stored, writeContext) {
+        const result = await this.mutateProjectManagementState(state, stored, writeContext, (snapshot) => {
+            if (snapshot.scratchpad.length === 0)
+                return { changed: false, value: undefined };
+            snapshot.scratchpad = '';
+            return { changed: true, value: undefined };
+        });
+        return this.projectScratchpadResult(result.snapshot);
+    }
+    createProjectTaskTool(run) {
+        const status = plugins.z.enum(['pending', 'in_progress', 'completed', 'cancelled']);
+        const priority = plugins.z.enum(['high', 'medium', 'low']);
+        const id = plugins.z.string().min(1).max(FLEX_PROJECT_MANAGEMENT_LIMITS.maxTaskIdBytes);
+        const content = plugins.z.string().min(1).max(FLEX_PROJECT_MANAGEMENT_LIMITS.maxTaskContentBytes);
+        return plugins.tool({
+            description: 'List, create, update, delete, or clear session-local project tasks.',
+            strict: false,
+            inputSchema: plugins.z.object({
+                action: plugins.z.enum(['list', 'create', 'update', 'delete', 'clear']),
+                id: id.optional(),
+                content: content.optional(),
+                status: status.optional(),
+                priority: priority.optional(),
+            }).strict().superRefine((input, context) => {
+                const rejectFields = (...fields) => {
+                    for (const field of fields) {
+                        if (input[field] === undefined)
+                            continue;
+                        context.addIssue({
+                            code: 'custom',
+                            path: [field],
+                            message: `Task action "${input.action}" does not accept ${field}.`,
+                        });
+                    }
+                };
+                if (input.action === 'list' || input.action === 'clear') {
+                    rejectFields('id', 'content', 'status', 'priority');
+                }
+                else if (input.action === 'create') {
+                    if (input.content === undefined) {
+                        context.addIssue({
+                            code: 'custom',
+                            path: ['content'],
+                            message: 'Task creation requires content.',
+                        });
+                    }
+                }
+                else if (input.action === 'update') {
+                    if (input.id === undefined) {
+                        context.addIssue({
+                            code: 'custom',
+                            path: ['id'],
+                            message: 'Task update requires an id.',
+                        });
+                    }
+                    if (input.content === undefined
+                        && input.status === undefined
+                        && input.priority === undefined) {
+                        context.addIssue({
+                            code: 'custom',
+                            message: 'Task update requires content, status, or priority.',
+                        });
+                    }
+                }
+                else {
+                    if (input.id === undefined) {
+                        context.addIssue({
+                            code: 'custom',
+                            path: ['id'],
+                            message: 'Task deletion requires an id.',
+                        });
+                    }
+                    rejectFields('content', 'status', 'priority');
+                }
+            }),
+            execute: (input, options) => this.executeProjectTaskTool(run, input, options?.toolCallId),
+        });
+    }
+    createProjectGoalTool(run) {
+        return plugins.tool({
+            description: 'Get, set, or clear the session-local project goal.',
+            strict: false,
+            inputSchema: plugins.z.object({
+                action: plugins.z.enum(['get', 'set', 'clear']),
+                goal: plugins.z.string()
+                    .min(1)
+                    .max(FLEX_PROJECT_MANAGEMENT_LIMITS.maxGoalBytes)
+                    .optional(),
+            }).strict().superRefine((input, context) => {
+                if (input.action === 'set' && input.goal === undefined) {
+                    context.addIssue({
+                        code: 'custom',
+                        path: ['goal'],
+                        message: 'Goal set requires a goal.',
+                    });
+                }
+                else if (input.action !== 'set' && input.goal !== undefined) {
+                    context.addIssue({
+                        code: 'custom',
+                        path: ['goal'],
+                        message: `Goal action "${input.action}" does not accept goal.`,
+                    });
+                }
+            }),
+            execute: (input, options) => this.executeProjectGoalTool(run, input, options?.toolCallId),
+        });
+    }
+    createProjectScratchpadTool(run) {
+        const content = plugins.z.string().max(FLEX_PROJECT_MANAGEMENT_LIMITS.maxScratchpadBytes);
+        return plugins.tool({
+            description: 'Get, set, append to, or clear the session-local project scratchpad.',
+            strict: false,
+            inputSchema: plugins.z.object({
+                action: plugins.z.enum(['get', 'set', 'append', 'clear']),
+                content: content.optional(),
+            }).strict().superRefine((input, context) => {
+                if ((input.action === 'set' || input.action === 'append')
+                    && input.content === undefined) {
+                    context.addIssue({
+                        code: 'custom',
+                        path: ['content'],
+                        message: `Scratchpad ${input.action} requires content.`,
+                    });
+                }
+                else if ((input.action === 'get' || input.action === 'clear')
+                    && input.content !== undefined) {
+                    context.addIssue({
+                        code: 'custom',
+                        path: ['content'],
+                        message: `Scratchpad action "${input.action}" does not accept content.`,
+                    });
+                }
+            }),
+            execute: (input, options) => this.executeProjectScratchpadTool(run, input, options?.toolCallId),
+        });
+    }
+    projectManagementAgentWriteContext(run, toolCallId) {
+        return Object.freeze({
+            actor: 'agent',
+            runId: run.runId,
+            ...(run.stored.session.agent === undefined ? {} : { agent: run.stored.session.agent }),
+            ...(toolCallId === undefined ? {} : { toolCallId }),
+        });
+    }
+    async executeProjectTaskTool(run, input, toolCallId) {
+        this.assertProjectManagementSession(run.state, run.stored);
+        if (input.action === 'list') {
+            const snapshot = await this.readProjectManagementState(run.state, run.stored);
+            return this.projectTasksResult(snapshot, snapshot.tasks);
+        }
+        const writeContext = this.projectManagementAgentWriteContext(run, toolCallId);
+        if (input.action === 'create') {
+            const id = input.id ?? (() => {
+                validateUtf8String(toolCallId, 'task toolCallId', maxTransferIdentifierBytes, true);
+                return this.createProjectTaskId(run.state.storageKey, run.sessionId, run.runId, toolCallId);
+            })();
+            const createInput = {
+                id,
+                content: input.content,
+                ...(input.status === undefined ? {} : { status: input.status }),
+                ...(input.priority === undefined ? {} : { priority: input.priority }),
+            };
+            validateCreateProjectTaskInput(createInput);
+            return this.createProjectTaskInState(run.state, run.stored, createInput, writeContext);
+        }
+        if (input.action === 'update') {
+            const updateInput = {
+                id: input.id,
+                ...(input.content === undefined ? {} : { content: input.content }),
+                ...(input.status === undefined ? {} : { status: input.status }),
+                ...(input.priority === undefined ? {} : { priority: input.priority }),
+            };
+            validateUpdateProjectTaskInput(updateInput);
+            return this.updateProjectTaskInState(run.state, run.stored, updateInput, writeContext);
+        }
+        if (input.action === 'delete') {
+            validateProjectTaskId(input.id);
+            return this.deleteProjectTaskInState(run.state, run.stored, input.id, writeContext);
+        }
+        return this.clearProjectTasksInState(run.state, run.stored, writeContext);
+    }
+    async executeProjectGoalTool(run, input, toolCallId) {
+        this.assertProjectManagementSession(run.state, run.stored);
+        if (input.action === 'get') {
+            return this.projectGoalResult(await this.readProjectManagementState(run.state, run.stored));
+        }
+        const writeContext = this.projectManagementAgentWriteContext(run, toolCallId);
+        if (input.action === 'set') {
+            validateUtf8String(input.goal, 'project goal', FLEX_PROJECT_MANAGEMENT_LIMITS.maxGoalBytes, true);
+            return this.setProjectGoalInState(run.state, run.stored, input.goal, writeContext);
+        }
+        return this.clearProjectGoalInState(run.state, run.stored, writeContext);
+    }
+    async executeProjectScratchpadTool(run, input, toolCallId) {
+        this.assertProjectManagementSession(run.state, run.stored);
+        if (input.action === 'get') {
+            return this.projectScratchpadResult(await this.readProjectManagementState(run.state, run.stored));
+        }
+        const writeContext = this.projectManagementAgentWriteContext(run, toolCallId);
+        if (input.action === 'set') {
+            validateUtf8String(input.content, 'project scratchpad', FLEX_PROJECT_MANAGEMENT_LIMITS.maxScratchpadBytes);
+            return this.setProjectScratchpadInState(run.state, run.stored, input.content, writeContext);
+        }
+        if (input.action === 'append') {
+            validateUtf8String(input.content, 'project scratchpad append', FLEX_PROJECT_MANAGEMENT_LIMITS.maxScratchpadBytes);
+            return this.appendProjectScratchpadInState(run.state, run.stored, input.content, writeContext);
+        }
+        return this.clearProjectScratchpadInState(run.state, run.stored, writeContext);
+    }
+    createProjectTaskId(storageKey, sessionId, runId, toolCallId) {
+        return `task_${sha256Hex(JSON.stringify([
+            'flexharness-project-task-v1',
+            storageKey,
+            sessionId,
+            runId,
+            toolCallId,
+        ]))}`;
+    }
+    async tombstoneProjectManagementSession(state, sessionTombstone) {
+        const storageKey = state.storageKey;
+        const store = this.core.stores.projectManagement;
+        const sessionId = sessionTombstone.sessionId;
+        const generation = requireSessionGeneration(sessionTombstone);
+        const sessionContext = this.createProjectManagementSessionContext(state, sessionTombstone);
+        let lastConflict;
+        for (let attempt = 0; attempt <= maxProjectManagementTombstoneConflicts; attempt++) {
+            const current = await store.load(storageKey, sessionId, sessionContext);
+            if (current !== undefined) {
+                assertFlexProjectManagementRecord(current);
+                if (current.sessionGenerationId === generation.sessionGenerationId) {
+                    if (current.sessionGenerationSequence !== generation.sessionGenerationSequence) {
+                        throw new FlexHarnessStoreConflictError(this.projectManagementKey(storageKey, sessionId), 0, current.revision);
+                    }
+                    if ('deletedAt' in current)
+                        return;
+                }
+                else if (!('deletedAt' in current)
+                    || current.sessionGenerationSequence >= generation.sessionGenerationSequence) {
+                    throw new FlexHarnessStoreConflictError(this.projectManagementKey(storageKey, sessionId), 0, current.revision);
+                }
+            }
+            if (attempt === maxProjectManagementTombstoneConflicts)
+                break;
+            const expectedRevision = current === undefined
+                || current.sessionGenerationId !== generation.sessionGenerationId
+                ? 0
+                : current.revision;
+            const tombstone = {
+                schemaVersion: 1,
+                revision: expectedRevision + 1,
+                ...generation,
+                deletedAt: sessionTombstone.deletedAt,
+            };
+            try {
+                await store.tombstoneSession(storageKey, sessionId, tombstone, expectedRevision, sessionContext);
+            }
+            catch (error) {
+                if (!(error instanceof FlexHarnessStoreConflictError))
+                    throw error;
+                lastConflict = error;
+            }
+        }
+        throw lastConflict ?? new FlexHarnessValidationError(`Project management tombstone for session "${sessionId}" could not be durably confirmed.`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexharness.projects.js","sourceRoot":"","sources":["../ts/classes.flexharness.projects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,EACL,wBAAwB,EACxB,6BAA6B,EAC7B,0BAA0B,GAC3B,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,8BAA8B,GAe/B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EACL,iCAAiC,EACjC,mCAAmC,EACnC,wCAAwC,GACzC,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EAAE,0BAA0B,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,EACL,8BAA8B,EAC9B,qBAAqB,EACrB,8BAA8B,EAC9B,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAS/B,OAAO,EAAE,cAAc,EAAE,wBAAwB,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAG7F,MAAM,sCAAsC,GAAG,CAAC,CAAC;AAEjD,gGAAgG;AAChG,MAAM,OAAO,4BAA4B;IAGV,IAAI;IAFjB,uBAAuB,GAAG,IAAI,GAAG,EAAyB,CAAC;IAE3E,YAA6B,IAA6B;oBAA7B,IAAI;IAA4B,CAAC;IAEvD,KAAK,CAAC,eAAe,CAC1B,OAAe,EACf,SAAiB;QAEjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;QACjG,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,0BAA0B,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACtE,OAAO,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC;IAC3C,CAAC;IAEM,KAAK,CAAC,gBAAgB,CAC3B,OAAe,EACf,SAAiB;QAEjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;QACjG,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,0BAA0B,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACtE,OAAO,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC3D,CAAC;IAEM,KAAK,CAAC,iBAAiB,CAC5B,OAAe,EACf,SAAiB,EACjB,KAAkC;QAElC,8BAA8B,CAAC,KAAK,CAAC,CAAC;QACtC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QAClG,OAAO,IAAI,CAAC,wBAAwB,CAClC,KAAK,EACL,MAAM,EACN,KAAK,EACL,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,CAAC,CACxC,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,iBAAiB,CAC5B,OAAe,EACf,SAAiB,EACjB,KAAkC;QAElC,8BAA8B,CAAC,KAAK,CAAC,CAAC;QACtC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QAClG,OAAO,IAAI,CAAC,wBAAwB,CAClC,KAAK,EACL,MAAM,EACN,KAAK,EACL,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,CAAC,CACxC,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,iBAAiB,CAC5B,OAAe,EACf,SAAiB,EACjB,MAAc;QAEd,qBAAqB,CAAC,MAAM,CAAC,CAAC;QAC9B,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QAClG,OAAO,IAAI,CAAC,wBAAwB,CAClC,KAAK,EACL,MAAM,EACN,MAAM,EACN,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,CAAC,CACxC,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,iBAAiB,CAC5B,OAAe,EACf,SAAiB;QAEjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QAClG,OAAO,IAAI,CAAC,wBAAwB,CAClC,KAAK,EACL,MAAM,EACN,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,CAAC,CACxC,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,cAAc,CACzB,OAAe,EACf,SAAiB;QAEjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;QACjG,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,0BAA0B,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACtE,OAAO,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC;IAC1C,CAAC;IAEM,KAAK,CAAC,cAAc,CACzB,OAAe,EACf,SAAiB,EACjB,IAAY;QAEZ,kBAAkB,CAChB,IAAI,EACJ,cAAc,EACd,8BAA8B,CAAC,YAAY,EAC3C,IAAI,CACL,CAAC;QACF,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QAClG,OAAO,IAAI,CAAC,qBAAqB,CAC/B,KAAK,EACL,MAAM,EACN,IAAI,EACJ,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,CAAC,CACxC,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,gBAAgB,CAC3B,OAAe,EACf,SAAiB;QAEjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QAClG,OAAO,IAAI,CAAC,uBAAuB,CACjC,KAAK,EACL,MAAM,EACN,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,CAAC,CACxC,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,oBAAoB,CAC/B,OAAe,EACf,SAAiB;QAEjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;QACjG,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,0BAA0B,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACtE,OAAO,IAAI,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC;IAChD,CAAC;IAEM,KAAK,CAAC,oBAAoB,CAC/B,OAAe,EACf,SAAiB,EACjB,OAAe;QAEf,kBAAkB,CAChB,OAAO,EACP,oBAAoB,EACpB,8BAA8B,CAAC,kBAAkB,CAClD,CAAC;QACF,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QAClG,OAAO,IAAI,CAAC,2BAA2B,CACrC,KAAK,EACL,MAAM,EACN,OAAO,EACP,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,CAAC,CACxC,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,uBAAuB,CAClC,OAAe,EACf,SAAiB,EACjB,OAAe;QAEf,kBAAkB,CAChB,OAAO,EACP,2BAA2B,EAC3B,8BAA8B,CAAC,kBAAkB,CAClD,CAAC;QACF,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QAClG,OAAO,IAAI,CAAC,8BAA8B,CACxC,KAAK,EACL,MAAM,EACN,OAAO,EACP,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,CAAC,CACxC,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,sBAAsB,CACjC,OAAe,EACf,SAAiB;QAEjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QAClG,OAAO,IAAI,CAAC,6BAA6B,CACvC,KAAK,EACL,MAAM,EACN,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,CAAC,CACxC,CAAC;IACJ,CAAC;IAEO,6BAA6B;QACnC,MAAM,iBAAiB,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC;QACnE,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACvB,MAAM,IAAI,0BAA0B,CAAC,4DAA4D,CAAC,CAAC;QACrG,CAAC;QACD,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAEM,oBAAoB,CAAC,UAAkB,EAAE,SAAiB;QAC/D,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC;IACjD,CAAC;IAEO,+BAA+B,CACrC,UAAkB,EAClB,SAAiB,EACjB,SAAiC;QAEjC,OAAO,cAAc,CAAC,IAAI,CAAC,uBAAuB,EAAE,IAAI,CAAC,oBAAoB,CAAC,UAAU,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,CAAC;IACnH,CAAC;IAEM,KAAK,CAAC,gCAAgC,CAC3C,UAAkB,EAClB,UAA4B;QAE5B,MAAM,QAAQ,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,CAAC;aACtC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAClD,IAAI,CAAC,oBAAoB,CAAC,UAAU,EAAE,SAAS,CAAC,CACjD,CAAC;aACD,MAAM,CAAC,CAAC,OAAO,EAA4B,EAAE,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC;QACxE,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC9B,CAAC;IAEO,KAAK,CAAC,+BAA+B,CAC3C,OAAe,EACf,SAAiB,EACjB,MAAwB;QAExB,IAAI,CAAC,6BAA6B,EAAE,CAAC;QACrC,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,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QAC1D,IAAI,MAAM,KAAK,OAAO;YAAE,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;QAChE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAC3B,CAAC;IAEO,8BAA8B,CACpC,KAAoB,EACpB,MAA2B;QAE3B,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;QACvB,IAAI,CAAC,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;QAC1C,IACE,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,MAAM;eACpD,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EACjD,CAAC;YACD,MAAM,IAAI,wBAAwB,CAAC,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAC1E,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,0BAA0B,CACtC,KAAoB,EACpB,MAA2B;QAE3B,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC;QACjD,MAAM,UAAU,GAAG,wBAAwB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC5D,MAAM,cAAc,GAAG,IAAI,CAAC,qCAAqC,CAAC,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;QACzF,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,IAAI,CAC7B,KAAK,CAAC,UAAU,EAChB,MAAM,CAAC,OAAO,CAAC,SAAS,EACxB,cAAc,CACf,CAAC;QACF,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,OAAO,wCAAwC,CAC7C,UAAU,CAAC,mBAAmB,EAC9B,UAAU,CAAC,yBAAyB,CACrC,CAAC;QACJ,CAAC;QACD,iCAAiC,CAAC,MAAM,CAAC,CAAC;QAC1C,IAAI,MAAM,CAAC,mBAAmB,KAAK,UAAU,CAAC,mBAAmB,EAAE,CAAC;YAClE,IAAI,MAAM,CAAC,yBAAyB,KAAK,UAAU,CAAC,yBAAyB,EAAE,CAAC;gBAC9E,MAAM,IAAI,6BAA6B,CACrC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EACrE,CAAC,EACD,MAAM,CAAC,QAAQ,CAChB,CAAC;YACJ,CAAC;YACD,IAAI,CAAC,CAAC,WAAW,IAAI,MAAM,CAAC;gBAAE,OAAO,iBAAiB,CAAC,MAAM,CAAC,CAAC;YAC/D,MAAM,IAAI,wBAAwB,CAAC,0BAA0B,EAAE,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAC3F,CAAC;QACD,IACE,WAAW,IAAI,MAAM;eAClB,MAAM,CAAC,yBAAyB,GAAG,UAAU,CAAC,yBAAyB,EAC1E,CAAC;YACD,OAAO,wCAAwC,CAC7C,UAAU,CAAC,mBAAmB,EAC9B,UAAU,CAAC,yBAAyB,CACrC,CAAC;QACJ,CAAC;QACD,MAAM,IAAI,6BAA6B,CACrC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EACrE,CAAC,EACD,MAAM,CAAC,QAAQ,CAChB,CAAC;IACJ,CAAC;IAEO,0BAA0B,CAChC,KAAoB,EACpB,MAA2B;QAE3B,OAAO,IAAI,CAAC,+BAA+B,CACzC,KAAK,CAAC,UAAU,EAChB,MAAM,CAAC,OAAO,CAAC,SAAS,EACxB,KAAK,IAAI,EAAE;YACT,IAAI,CAAC,8BAA8B,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YACnD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,0BAA0B,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YACtE,IAAI,CAAC,8BAA8B,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YACnD,OAAO,cAAc,CAAC,QAAQ,CAAC,CAAC;QAClC,CAAC,CACF,CAAC;IACJ,CAAC;IAEO,4BAA4B,CAClC,KAAoB,EACpB,MAA2B,EAC3B,YAAgD,EAChD,QAEyC;QAEzC,OAAO,IAAI,CAAC,+BAA+B,CACzC,KAAK,CAAC,UAAU,EAChB,MAAM,CAAC,OAAO,CAAC,SAAS,EACxB,KAAK,IAAI,EAAE;YACT,IAAI,CAAC,8BAA8B,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YACnD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,0BAA0B,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YACtE,IAAI,CAAC,8BAA8B,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YACnD,MAAM,gBAAgB,GAAG,QAAQ,CAAC,QAAQ,CAAC;YAC3C,MAAM,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC;YAClC,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBACnB,QAAQ,CAAC,QAAQ,GAAG,gBAAgB,GAAG,CAAC,CAAC;gBACzC,mCAAmC,CAAC,QAAQ,CAAC,CAAC;gBAC9C,IAAI,CAAC,8BAA8B,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;gBACnD,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,IAAI,CAC3C,KAAK,CAAC,UAAU,EAChB,MAAM,CAAC,OAAO,CAAC,SAAS,EACxB,iBAAiB,CAAC,QAAQ,CAAC,EAC3B,gBAAgB,EAChB,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC,CAC/C,CAAC;YACJ,CAAC;YACD,OAAO;gBACL,QAAQ,EAAE,cAAc,CAAC,QAAQ,CAAC;gBAClC,KAAK,EAAE,MAAM,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC;aAChF,CAAC;QACJ,CAAC,CACF,CAAC;IACJ,CAAC;IAEO,kBAAkB,CAAC,QAAwC;QACjE,OAAO,cAAc,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC1E,CAAC;IAEO,qCAAqC,CAC3C,KAAoB,EACpB,OAAuD;QAEvD,MAAM,MAAM,GAAG,WAAW,IAAI,OAAO;YACnC,CAAC,CAAC,OAAO,CAAC,QAAQ;YAClB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,wBAAwB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACrE,MAAM,QAAQ,GAAG,MAAM,KAAK,SAAS;YACnC,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,iBAAiB,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACpD,OAAO,MAAM,CAAC,MAAM,CAAC;YACnB,GAAG,wBAAwB,CAAC,OAAO,CAAC;YACpC,GAAG,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC;SAChD,CAAC,CAAC;IACL,CAAC;IAEO,iBAAiB,CACvB,QAAwC,EACxC,IAAsB;QAEtB,OAAO,cAAc,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;IAChF,CAAC;IAEO,kBAAkB,CACxB,QAAwC,EACxC,KAAyB;QAEzB,OAAO,cAAc,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;IACjF,CAAC;IAEO,iBAAiB,CAAC,QAAwC;QAChE,OAAO,cAAc,CAAC;YACpB,QAAQ,EAAE,QAAQ,CAAC,QAAQ;YAC3B,IAAI,EAAE,QAAQ,CAAC,IAAI,IAAI,IAAI;YAC3B,KAAK,EAAE,QAAQ;SAChB,CAAC,CAAC;IACL,CAAC;IAEO,uBAAuB,CAC7B,QAAwC;QAExC,OAAO,cAAc,CAAC;YACpB,QAAQ,EAAE,QAAQ,CAAC,QAAQ;YAC3B,UAAU,EAAE,QAAQ,CAAC,UAAU;YAC/B,KAAK,EAAE,QAAQ;SAChB,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,wBAAwB,CACpC,KAAoB,EACpB,MAA2B,EAC3B,KAAkC,EAClC,YAAgD;QAEhD,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,IAAI,SAAS,CAAC;QACzC,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,IAAI,QAAQ,CAAC;QAC5C,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,4BAA4B,CACpD,KAAK,EACL,MAAM,EACN,YAAY,EACZ,CAAC,QAAQ,EAAE,EAAE;YACX,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,KAAK,CAAC,EAAE,CAAC,CAAC;YACrE,IAAI,QAAQ,EAAE,CAAC;gBACb,IACE,QAAQ,CAAC,OAAO,KAAK,KAAK,CAAC,OAAO;uBAC/B,QAAQ,CAAC,MAAM,KAAK,MAAM;uBAC1B,QAAQ,CAAC,QAAQ,KAAK,QAAQ;oBACjC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;gBAC7C,MAAM,IAAI,0BAA0B,CAClC,iBAAiB,KAAK,CAAC,EAAE,gDAAgD,CAC1E,CAAC;YACJ,CAAC;YACD,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,IAAI,8BAA8B,CAAC,QAAQ,EAAE,CAAC;gBACrE,MAAM,IAAI,0BAA0B,CAAC,2CAA2C,CAAC,CAAC;YACpF,CAAC;YACD,MAAM,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;YAC3C,MAAM,IAAI,GAAqB;gBAC7B,EAAE,EAAE,KAAK,CAAC,EAAE;gBACZ,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,MAAM;gBACN,QAAQ;gBACR,SAAS,EAAE,SAAS;gBACpB,SAAS,EAAE,SAAS;aACrB,CAAC;YACF,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC1B,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QACxC,CAAC,CACF,CAAC;QACF,OAAO,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC/D,CAAC;IAEO,KAAK,CAAC,wBAAwB,CACpC,KAAoB,EACpB,MAA2B,EAC3B,KAAkC,EAClC,YAAgD;QAEhD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,4BAA4B,CACpD,KAAK,EACL,MAAM,EACN,YAAY,EACZ,CAAC,QAAQ,EAAE,EAAE;YACX,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,KAAK,CAAC,EAAE,CAAC,CAAC;YACnE,IAAI,CAAC,IAAI;gBAAE,MAAM,IAAI,wBAAwB,CAAC,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC;YACxE,MAAM,OAAO,GAAG,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI,CAAC,OAAO,CAAC;mBAC1E,CAAC,KAAK,CAAC,MAAM,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM,CAAC;mBAC5D,CAAC,KAAK,CAAC,QAAQ,KAAK,SAAS,IAAI,KAAK,CAAC,QAAQ,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC;YACxE,IAAI,CAAC,OAAO;gBAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;YACrD,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;gBAAE,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;YAC9D,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS;gBAAE,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;YAC3D,IAAI,KAAK,CAAC,QAAQ,KAAK,SAAS;gBAAE,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;YACjE,IAAI,CAAC,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;YAC1C,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QACxC,CAAC,CACF,CAAC;QACF,OAAO,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC/D,CAAC;IAEO,KAAK,CAAC,wBAAwB,CACpC,KAAoB,EACpB,MAA2B,EAC3B,MAAc,EACd,YAAgD;QAEhD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,4BAA4B,CACpD,KAAK,EACL,MAAM,EACN,YAAY,EACZ,CAAC,QAAQ,EAAE,EAAE;YACX,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,MAAM,CAAC,CAAC;YACrE,IAAI,KAAK,GAAG,CAAC;gBAAE,MAAM,IAAI,wBAAwB,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;YAC1E,MAAM,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAC/C,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QACxC,CAAC,CACF,CAAC;QACF,OAAO,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC/D,CAAC;IAEO,KAAK,CAAC,wBAAwB,CACpC,KAAoB,EACpB,MAA2B,EAC3B,YAAgD;QAEhD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,4BAA4B,CACpD,KAAK,EACL,MAAM,EACN,YAAY,EACZ,CAAC,QAAQ,EAAE,EAAE;YACX,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC;YAC7B,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,EAAwB,EAAE,CAAC;YACnF,QAAQ,CAAC,KAAK,GAAG,EAAE,CAAC;YACpB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;QACzC,CAAC,CACF,CAAC;QACF,OAAO,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAChE,CAAC;IAEO,KAAK,CAAC,qBAAqB,CACjC,KAAoB,EACpB,MAA2B,EAC3B,IAAY,EACZ,YAAgD;QAEhD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,4BAA4B,CACpD,KAAK,EACL,MAAM,EACN,YAAY,EACZ,CAAC,QAAQ,EAAE,EAAE;YACX,IAAI,QAAQ,CAAC,IAAI,KAAK,IAAI;gBAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;YACxE,QAAQ,CAAC,IAAI,GAAG,IAAI,CAAC;YACrB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;QAC7C,CAAC,CACF,CAAC;QACF,OAAO,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACjD,CAAC;IAEO,KAAK,CAAC,uBAAuB,CACnC,KAAoB,EACpB,MAA2B,EAC3B,YAAgD;QAEhD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,4BAA4B,CACpD,KAAK,EACL,MAAM,EACN,YAAY,EACZ,CAAC,QAAQ,EAAE,EAAE;YACX,IAAI,QAAQ,CAAC,IAAI,KAAK,SAAS;gBAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;YAC7E,OAAO,QAAQ,CAAC,IAAI,CAAC;YACrB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;QAC7C,CAAC,CACF,CAAC;QACF,OAAO,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACjD,CAAC;IAEO,KAAK,CAAC,2BAA2B,CACvC,KAAoB,EACpB,MAA2B,EAC3B,OAAe,EACf,YAAgD;QAEhD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,4BAA4B,CACpD,KAAK,EACL,MAAM,EACN,YAAY,EACZ,CAAC,QAAQ,EAAE,EAAE;YACX,IAAI,QAAQ,CAAC,UAAU,KAAK,OAAO;gBAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;YACjF,QAAQ,CAAC,UAAU,GAAG,OAAO,CAAC;YAC9B,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;QAC7C,CAAC,CACF,CAAC;QACF,OAAO,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACvD,CAAC;IAEO,KAAK,CAAC,8BAA8B,CAC1C,KAAoB,EACpB,MAA2B,EAC3B,OAAe,EACf,YAAgD;QAEhD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,4BAA4B,CACpD,KAAK,EACL,MAAM,EACN,YAAY,EACZ,CAAC,QAAQ,EAAE,EAAE;YACX,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;YACtE,MAAM,QAAQ,GAAG,GAAG,QAAQ,CAAC,UAAU,GAAG,OAAO,EAAE,CAAC;YACpD,kBAAkB,CAChB,QAAQ,EACR,oBAAoB,EACpB,8BAA8B,CAAC,kBAAkB,CAClD,CAAC;YACF,QAAQ,CAAC,UAAU,GAAG,QAAQ,CAAC;YAC/B,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;QAC7C,CAAC,CACF,CAAC;QACF,OAAO,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACvD,CAAC;IAEO,KAAK,CAAC,6BAA6B,CACzC,KAAoB,EACpB,MAA2B,EAC3B,YAAgD;QAEhD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,4BAA4B,CACpD,KAAK,EACL,MAAM,EACN,YAAY,EACZ,CAAC,QAAQ,EAAE,EAAE;YACX,IAAI,QAAQ,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;YAClF,QAAQ,CAAC,UAAU,GAAG,EAAE,CAAC;YACzB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;QAC7C,CAAC,CACF,CAAC;QACF,OAAO,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACvD,CAAC;IAEM,qBAAqB,CAAC,GAAe;QAC1C,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC;QACpF,MAAM,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC;QAC3D,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,8BAA8B,CAAC,cAAc,CAAC,CAAC;QACxF,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,8BAA8B,CAAC,mBAAmB,CAAC,CAAC;QAClG,OAAO,OAAO,CAAC,IAAI,CAAC;YAClB,WAAW,EAAE,qEAAqE;YAClF,MAAM,EAAE,KAAK;YACb,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC;gBAC5B,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;gBACvE,EAAE,EAAE,EAAE,CAAC,QAAQ,EAAE;gBACjB,OAAO,EAAE,OAAO,CAAC,QAAQ,EAAE;gBAC3B,MAAM,EAAE,MAAM,CAAC,QAAQ,EAAE;gBACzB,QAAQ,EAAE,QAAQ,CAAC,QAAQ,EAAE;aAC9B,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;gBACzC,MAAM,YAAY,GAAG,CAAC,GAAG,MAAiC,EAAQ,EAAE;oBAClE,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;wBAC3B,IAAI,KAAK,CAAC,KAAK,CAAC,KAAK,SAAS;4BAAE,SAAS;wBACzC,OAAO,CAAC,QAAQ,CAAC;4BACf,IAAI,EAAE,QAAQ;4BACd,IAAI,EAAE,CAAC,KAAK,CAAC;4BACb,OAAO,EAAE,gBAAgB,KAAK,CAAC,MAAM,qBAAqB,KAAK,GAAG;yBACnE,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC,CAAC;gBACF,IAAI,KAAK,CAAC,MAAM,KAAK,MAAM,IAAI,KAAK,CAAC,MAAM,KAAK,OAAO,EAAE,CAAC;oBACxD,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;gBACtD,CAAC;qBAAM,IAAI,KAAK,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;oBACrC,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;wBAChC,OAAO,CAAC,QAAQ,CAAC;4BACf,IAAI,EAAE,QAAQ;4BACd,IAAI,EAAE,CAAC,SAAS,CAAC;4BACjB,OAAO,EAAE,iCAAiC;yBAC3C,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC;qBAAM,IAAI,KAAK,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;oBACrC,IAAI,KAAK,CAAC,EAAE,KAAK,SAAS,EAAE,CAAC;wBAC3B,OAAO,CAAC,QAAQ,CAAC;4BACf,IAAI,EAAE,QAAQ;4BACd,IAAI,EAAE,CAAC,IAAI,CAAC;4BACZ,OAAO,EAAE,6BAA6B;yBACvC,CAAC,CAAC;oBACL,CAAC;oBACD,IACE,KAAK,CAAC,OAAO,KAAK,SAAS;2BACxB,KAAK,CAAC,MAAM,KAAK,SAAS;2BAC1B,KAAK,CAAC,QAAQ,KAAK,SAAS,EAC/B,CAAC;wBACD,OAAO,CAAC,QAAQ,CAAC;4BACf,IAAI,EAAE,QAAQ;4BACd,OAAO,EAAE,oDAAoD;yBAC9D,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,IAAI,KAAK,CAAC,EAAE,KAAK,SAAS,EAAE,CAAC;wBAC3B,OAAO,CAAC,QAAQ,CAAC;4BACf,IAAI,EAAE,QAAQ;4BACd,IAAI,EAAE,CAAC,IAAI,CAAC;4BACZ,OAAO,EAAE,+BAA+B;yBACzC,CAAC,CAAC;oBACL,CAAC;oBACD,YAAY,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;gBAChD,CAAC;YACH,CAAC,CAAC;YACF,OAAO,EAAE,CACP,KAAK,EACL,OAAiC,EACjC,EAAE,CAAC,IAAI,CAAC,sBAAsB,CAC9B,GAAG,EACH,KAA8B,EAC9B,OAAO,EAAE,UAAU,CACpB;SACF,CAAC,CAAC;IACL,CAAC;IAEM,qBAAqB,CAAC,GAAe;QAC1C,OAAO,OAAO,CAAC,IAAI,CAAC;YAClB,WAAW,EAAE,oDAAoD;YACjE,MAAM,EAAE,KAAK;YACb,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC;gBAC5B,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;gBAC/C,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,MAAM,EAAE;qBACrB,GAAG,CAAC,CAAC,CAAC;qBACN,GAAG,CAAC,8BAA8B,CAAC,YAAY,CAAC;qBAChD,QAAQ,EAAE;aACd,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;gBACzC,IAAI,KAAK,CAAC,MAAM,KAAK,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;oBACvD,OAAO,CAAC,QAAQ,CAAC;wBACf,IAAI,EAAE,QAAQ;wBACd,IAAI,EAAE,CAAC,MAAM,CAAC;wBACd,OAAO,EAAE,2BAA2B;qBACrC,CAAC,CAAC;gBACL,CAAC;qBAAM,IAAI,KAAK,CAAC,MAAM,KAAK,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;oBAC9D,OAAO,CAAC,QAAQ,CAAC;wBACf,IAAI,EAAE,QAAQ;wBACd,IAAI,EAAE,CAAC,MAAM,CAAC;wBACd,OAAO,EAAE,gBAAgB,KAAK,CAAC,MAAM,yBAAyB;qBAC/D,CAAC,CAAC;gBACL,CAAC;YACH,CAAC,CAAC;YACF,OAAO,EAAE,CACP,KAAK,EACL,OAAiC,EACjC,EAAE,CAAC,IAAI,CAAC,sBAAsB,CAC9B,GAAG,EACH,KAA8B,EAC9B,OAAO,EAAE,UAAU,CACpB;SACF,CAAC,CAAC;IACL,CAAC;IAEM,2BAA2B,CAAC,GAAe;QAChD,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,8BAA8B,CAAC,kBAAkB,CAAC,CAAC;QAC1F,OAAO,OAAO,CAAC,IAAI,CAAC;YAClB,WAAW,EAAE,qEAAqE;YAClF,MAAM,EAAE,KAAK;YACb,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC;gBAC5B,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;gBACzD,OAAO,EAAE,OAAO,CAAC,QAAQ,EAAE;aAC5B,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;gBACzC,IACE,CAAC,KAAK,CAAC,MAAM,KAAK,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,QAAQ,CAAC;uBAClD,KAAK,CAAC,OAAO,KAAK,SAAS,EAC9B,CAAC;oBACD,OAAO,CAAC,QAAQ,CAAC;wBACf,IAAI,EAAE,QAAQ;wBACd,IAAI,EAAE,CAAC,SAAS,CAAC;wBACjB,OAAO,EAAE,cAAc,KAAK,CAAC,MAAM,oBAAoB;qBACxD,CAAC,CAAC;gBACL,CAAC;qBAAM,IACL,CAAC,KAAK,CAAC,MAAM,KAAK,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,OAAO,CAAC;uBACjD,KAAK,CAAC,OAAO,KAAK,SAAS,EAC9B,CAAC;oBACD,OAAO,CAAC,QAAQ,CAAC;wBACf,IAAI,EAAE,QAAQ;wBACd,IAAI,EAAE,CAAC,SAAS,CAAC;wBACjB,OAAO,EAAE,sBAAsB,KAAK,CAAC,MAAM,4BAA4B;qBACxE,CAAC,CAAC;gBACL,CAAC;YACH,CAAC,CAAC;YACF,OAAO,EAAE,CACP,KAAK,EACL,OAAiC,EACjC,EAAE,CAAC,IAAI,CAAC,4BAA4B,CACpC,GAAG,EACH,KAAoC,EACpC,OAAO,EAAE,UAAU,CACpB;SACF,CAAC,CAAC;IACL,CAAC;IAEO,kCAAkC,CACxC,GAAe,EACf,UAA8B;QAE9B,OAAO,MAAM,CAAC,MAAM,CAAC;YACnB,KAAK,EAAE,OAAgB;YACvB,KAAK,EAAE,GAAG,CAAC,KAAK;YAChB,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;YACtF,GAAG,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC;SACpD,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,sBAAsB,CAClC,GAAe,EACf,KAA4B,EAC5B,UAA8B;QAE9B,IAAI,CAAC,8BAA8B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QAC3D,IAAI,KAAK,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC;YAC5B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,0BAA0B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;YAC9E,OAAO,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC3D,CAAC;QACD,MAAM,YAAY,GAAG,IAAI,CAAC,kCAAkC,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QAC9E,IAAI,KAAK,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC9B,MAAM,EAAE,GAAG,KAAK,CAAC,EAAE,IAAI,CAAC,GAAG,EAAE;gBAC3B,kBAAkB,CAChB,UAAU,EACV,iBAAiB,EACjB,0BAA0B,EAC1B,IAAI,CACL,CAAC;gBACF,OAAO,IAAI,CAAC,mBAAmB,CAC7B,GAAG,CAAC,KAAK,CAAC,UAAU,EACpB,GAAG,CAAC,SAAS,EACb,GAAG,CAAC,KAAK,EACT,UAAU,CACX,CAAC;YACJ,CAAC,CAAC,EAAE,CAAC;YACL,MAAM,WAAW,GAAgC;gBAC/C,EAAE;gBACF,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,GAAG,CAAC,KAAK,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;gBAC/D,GAAG,CAAC,KAAK,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC;aACtE,CAAC;YACF,8BAA8B,CAAC,WAAW,CAAC,CAAC;YAC5C,OAAO,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,YAAY,CAAC,CAAC;QACzF,CAAC;QACD,IAAI,KAAK,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC9B,MAAM,WAAW,GAAgC;gBAC/C,EAAE,EAAE,KAAK,CAAC,EAAE;gBACZ,GAAG,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;gBAClE,GAAG,CAAC,KAAK,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;gBAC/D,GAAG,CAAC,KAAK,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC;aACtE,CAAC;YACF,8BAA8B,CAAC,WAAW,CAAC,CAAC;YAC5C,OAAO,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,YAAY,CAAC,CAAC;QACzF,CAAC;QACD,IAAI,KAAK,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC9B,qBAAqB,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAChC,OAAO,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,EAAE,YAAY,CAAC,CAAC;QACtF,CAAC;QACD,OAAO,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC5E,CAAC;IAEO,KAAK,CAAC,sBAAsB,CAClC,GAAe,EACf,KAA4B,EAC5B,UAA8B;QAE9B,IAAI,CAAC,8BAA8B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QAC3D,IAAI,KAAK,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;YAC3B,OAAO,IAAI,CAAC,iBAAiB,CAAC,MAAM,IAAI,CAAC,0BAA0B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;QAC9F,CAAC;QACD,MAAM,YAAY,GAAG,IAAI,CAAC,kCAAkC,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QAC9E,IAAI,KAAK,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;YAC3B,kBAAkB,CAChB,KAAK,CAAC,IAAI,EACV,cAAc,EACd,8BAA8B,CAAC,YAAY,EAC3C,IAAI,CACL,CAAC;YACF,OAAO,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QACrF,CAAC;QACD,OAAO,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC3E,CAAC;IAEO,KAAK,CAAC,4BAA4B,CACxC,GAAe,EACf,KAAkC,EAClC,UAA8B;QAE9B,IAAI,CAAC,8BAA8B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QAC3D,IAAI,KAAK,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;YAC3B,OAAO,IAAI,CAAC,uBAAuB,CACjC,MAAM,IAAI,CAAC,0BAA0B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAC7D,CAAC;QACJ,CAAC;QACD,MAAM,YAAY,GAAG,IAAI,CAAC,kCAAkC,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QAC9E,IAAI,KAAK,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;YAC3B,kBAAkB,CAChB,KAAK,CAAC,OAAO,EACb,oBAAoB,EACpB,8BAA8B,CAAC,kBAAkB,CAClD,CAAC;YACF,OAAO,IAAI,CAAC,2BAA2B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;QAC9F,CAAC;QACD,IAAI,KAAK,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC9B,kBAAkB,CAChB,KAAK,CAAC,OAAO,EACb,2BAA2B,EAC3B,8BAA8B,CAAC,kBAAkB,CAClD,CAAC;YACF,OAAO,IAAI,CAAC,8BAA8B,CACxC,GAAG,CAAC,KAAK,EACT,GAAG,CAAC,MAAM,EACV,KAAK,CAAC,OAAO,EACb,YAAY,CACb,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC,6BAA6B,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACjF,CAAC;IAEO,mBAAmB,CACzB,UAAkB,EAClB,SAAiB,EACjB,KAAa,EACb,UAAkB;QAElB,OAAO,QAAQ,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC;YACtC,6BAA6B;YAC7B,UAAU;YACV,SAAS;YACT,KAAK;YACL,UAAU;SACX,CAAC,CAAC,EAAE,CAAC;IACR,CAAC;IAEM,KAAK,CAAC,iCAAiC,CAC5C,KAAoB,EACpB,gBAAuC;QAEvC,MAAM,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC;QACpC,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC;QACjD,MAAM,SAAS,GAAG,gBAAgB,CAAC,SAAS,CAAC;QAC7C,MAAM,UAAU,GAAG,wBAAwB,CAAC,gBAAgB,CAAC,CAAC;QAC9D,MAAM,cAAc,GAAG,IAAI,CAAC,qCAAqC,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC;QAC3F,IAAI,YAAuD,CAAC;QAC5D,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,sCAAsC,EAAE,OAAO,EAAE,EAAE,CAAC;YACnF,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,IAAI,CAC9B,UAAU,EACV,SAAS,EACT,cAAc,CACf,CAAC;YACF,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;gBAC1B,iCAAiC,CAAC,OAAO,CAAC,CAAC;gBAC3C,IAAI,OAAO,CAAC,mBAAmB,KAAK,UAAU,CAAC,mBAAmB,EAAE,CAAC;oBACnE,IAAI,OAAO,CAAC,yBAAyB,KAAK,UAAU,CAAC,yBAAyB,EAAE,CAAC;wBAC/E,MAAM,IAAI,6BAA6B,CACrC,IAAI,CAAC,oBAAoB,CAAC,UAAU,EAAE,SAAS,CAAC,EAChD,CAAC,EACD,OAAO,CAAC,QAAQ,CACjB,CAAC;oBACJ,CAAC;oBACD,IAAI,WAAW,IAAI,OAAO;wBAAE,OAAO;gBACrC,CAAC;qBAAM,IACL,CAAC,CAAC,WAAW,IAAI,OAAO,CAAC;uBACtB,OAAO,CAAC,yBAAyB,IAAI,UAAU,CAAC,yBAAyB,EAC5E,CAAC;oBACD,MAAM,IAAI,6BAA6B,CACrC,IAAI,CAAC,oBAAoB,CAAC,UAAU,EAAE,SAAS,CAAC,EAChD,CAAC,EACD,OAAO,CAAC,QAAQ,CACjB,CAAC;gBACJ,CAAC;YACH,CAAC;YACD,IAAI,OAAO,KAAK,sCAAsC;gBAAE,MAAM;YAC9D,MAAM,gBAAgB,GAAG,OAAO,KAAK,SAAS;mBACzC,OAAO,CAAC,mBAAmB,KAAK,UAAU,CAAC,mBAAmB;gBACjE,CAAC,CAAC,CAAC;gBACH,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;YACrB,MAAM,SAAS,GAAoC;gBACjD,aAAa,EAAE,CAAC;gBAChB,QAAQ,EAAE,gBAAgB,GAAG,CAAC;gBAC9B,GAAG,UAAU;gBACb,SAAS,EAAE,gBAAgB,CAAC,SAAS;aACtC,CAAC;YACF,IAAI,CAAC;gBACH,MAAM,KAAK,CAAC,gBAAgB,CAC1B,UAAU,EACV,SAAS,EACT,SAAS,EACT,gBAAgB,EAChB,cAAc,CACf,CAAC;YACJ,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,CAAC,KAAK,YAAY,6BAA6B,CAAC;oBAAE,MAAM,KAAK,CAAC;gBACnE,YAAY,GAAG,KAAK,CAAC;YACvB,CAAC;QACH,CAAC;QACD,MAAM,YAAY,IAAI,IAAI,0BAA0B,CAClD,6CAA6C,SAAS,mCAAmC,CAC1F,CAAC;IACJ,CAAC;CACF"}