@open-agent-toolkit/cli 0.1.45 → 0.1.48

package/dist/providers/codex/codec/sync-extension.js

@@ -1,17 +1,20 @@
 import { createHash } from 'node:crypto';
-import { readFile, rm, writeFile } from 'node:fs/promises';
-import { dirname, join, relative, resolve } from 'node:path';
+import { readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { basename, dirname, join, relative, resolve } from 'node:path';
 import { parseCanonicalAgentFile } from '../../../agents/canonical/index.js';
+import { isCodexMaterializedRouteTarget, isWorkflowDispatchCandidateLadder, isWorkflowDispatchFallbackRoute, normalizeProjectPath, resolveActiveProject, validateDispatchRouteTarget, } from '../../../config/oat-config.js';
+import { resolveEffectiveConfig } from '../../../config/resolve.js';
+import { CliError } from '../../../errors/index.js';
 import { ensureDir, fileExists } from '../../../fs/io.js';
+import { validateRealPathWithinScope } from '../../../fs/paths.js';
 import TOML from '@iarna/toml';
+import YAML from 'yaml';
+import { SUPPORTED_CODEX_BASE_ROLES, SUPPORTED_CODEX_ROLE_TARGETS, } from './catalog.js';
 import { mergeCodexConfig } from './config-merge.js';
 import { exportCanonicalAgentToCodexRole } from './export-to-codex.js';
-import { isOatManagedCodexRoleFile } from './shared.js';
-const CODEX_EFFORT_VARIANTS = ['low', 'medium', 'high', 'xhigh'];
-const CODEX_EFFORT_VARIANT_BASE_ROLES = new Set([
-    'oat-phase-implementer',
-    'oat-reviewer',
-]);
+import { materializeCodexRole } from './materialize.js';
+import { isOatManagedCodexRoleFile, readOatManagedCodexRoleOwner, withOatManagedCodexRoleOwner, } from './shared.js';
+const CODEX_MATERIALIZED_BASE_ROLES = new Set(SUPPORTED_CODEX_BASE_ROLES);
 function hashContent(content) {
     return createHash('sha256').update(content).digest('hex');
 }
@@ -42,41 +45,7 @@ function normalizeManagedRolesConfig(desiredRoles) {
         configFile: role.configFile,
     }));
 }
-function codexEffortVariantContent(baseContent, baseRoleName, variantRoleName, effort) {
-    return baseContent
-        .replace(`# oat-role: ${baseRoleName}`, `# oat-role: ${variantRoleName}`)
-        .replace('developer_instructions =', `model_reasoning_effort = "${effort}"\ndeveloper_instructions =`);
-}
-function codexEffortVariantDescription(baseRoleName, effort) {
-    const roleLabel = baseRoleName === 'oat-reviewer' ? 'reviewer' : 'phase implementer';
-    if (effort === 'low') {
-        return `OAT ${roleLabel} pinned to low reasoning effort for narrow mechanical implementation, fix, or review phases.`;
-    }
-    if (effort === 'medium') {
-        return `OAT ${roleLabel} pinned to medium reasoning effort for normal multi-file implementation, fix, or review phases.`;
-    }
-    if (effort === 'high') {
-        return `OAT ${roleLabel} pinned to high reasoning effort for broad, subtle, or higher-risk implementation, fix, or review phases.`;
-    }
-    return `OAT ${roleLabel} pinned to xhigh reasoning effort for the highest configured Codex dispatch policy cap.`;
-}
-function codexEffortVariantsFromBase(exported) {
-    if (!CODEX_EFFORT_VARIANT_BASE_ROLES.has(exported.roleName)) {
-        return [];
-    }
-    return CODEX_EFFORT_VARIANTS.map((effort) => {
-        const variantRoleName = `${exported.roleName}-${effort}`;
-        const configFile = `agents/${variantRoleName}.toml`;
-        return {
-            roleName: variantRoleName,
-            description: codexEffortVariantDescription(exported.roleName, effort),
-            configFile,
-            rolePath: join(dirname(exported.rolePath), `${variantRoleName}.toml`),
-            content: codexEffortVariantContent(exported.content, exported.roleName, variantRoleName, effort),
-        };
-    });
-}
-async function desiredRolesFromCanonical(canonicalEntries, scopeRoot) {
+async function desiredRolesFromCanonical(canonicalEntries, scopeRoot, materializationTargets) {
     const roles = [];
     for (const entry of canonicalEntries) {
         if (entry.type !== 'agent' ||
@@ -93,10 +62,239 @@ async function desiredRolesFromCanonical(canonicalEntries, scopeRoot) {
             rolePath: join(scopeRoot, '.codex', exported.configFile),
             content: exported.content,
         });
-        roles.push(...codexEffortVariantsFromBase(roles[roles.length - 1]));
+        if (CODEX_MATERIALIZED_BASE_ROLES.has(exported.roleName)) {
+            for (const target of materializationTargets) {
+                const materialized = materializeCodexRole({
+                    agent: parsed,
+                    model: target.model,
+                    effort: target.effort,
+                });
+                roles.push({
+                    roleName: materialized.roleName,
+                    description: materialized.description,
+                    configFile: materialized.configFile,
+                    rolePath: join(scopeRoot, '.codex', materialized.configFile),
+                    content: withOatManagedCodexRoleOwner(materialized.content, target.owner),
+                });
+            }
+        }
+    }
+    const roleContents = new Map();
+    for (const role of roles) {
+        const existing = roleContents.get(role.roleName);
+        if (existing !== undefined && existing !== role.content) {
+            throw new CliError(`Distinct Codex targets produced the same role name ${role.roleName}. Refusing ambiguous role writes.`);
+        }
+        roleContents.set(role.roleName, role.content);
     }
     return roles.sort((left, right) => left.roleName.localeCompare(right.roleName));
 }
+function collectCodexTargetFromEntry(entry, targets, owner) {
+    if (typeof entry === 'string') {
+        return;
+    }
+    if (!isCodexMaterializedRouteTarget('codex', entry)) {
+        return;
+    }
+    const validation = validateDispatchRouteTarget('codex', entry);
+    if (!validation.valid || !entry.model || !entry.effort) {
+        return;
+    }
+    const key = `${entry.model}\0${entry.effort}`;
+    if (!targets.has(key)) {
+        targets.set(key, {
+            model: entry.model,
+            effort: entry.effort,
+            owner,
+        });
+    }
+}
+function collectCodexTargetsFromCell(cell, targets, owner) {
+    if (typeof cell === 'string') {
+        return;
+    }
+    if (isWorkflowDispatchCandidateLadder(cell)) {
+        for (const candidate of cell.candidates) {
+            if (isWorkflowDispatchFallbackRoute(candidate)) {
+                for (const entry of candidate.route) {
+                    collectCodexTargetFromEntry(entry, targets, owner);
+                }
+                continue;
+            }
+            collectCodexTargetFromEntry(candidate, targets, owner);
+        }
+        return;
+    }
+    for (const entry of cell) {
+        collectCodexTargetFromEntry(entry, targets, owner);
+    }
+}
+function collectCodexMaterializationTargetsFromProvider(providerValue, targets, owner) {
+    if (providerValue === undefined || typeof providerValue === 'string') {
+        return;
+    }
+    for (const cell of Object.values(providerValue)) {
+        if (cell !== undefined) {
+            collectCodexTargetsFromCell(cell, targets, owner);
+        }
+    }
+}
+function sortCodexMaterializationTargets(targets) {
+    return [...targets.values()].sort((left, right) => {
+        const modelOrder = left.model.localeCompare(right.model);
+        return modelOrder === 0
+            ? left.effort.localeCompare(right.effort)
+            : modelOrder;
+    });
+}
+function routeTargetFromUnknown(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    const target = {};
+    for (const key of ['harness', 'model', 'effort']) {
+        const rawValue = record[key];
+        if (typeof rawValue === 'string' && rawValue.trim()) {
+            target[key] = rawValue.trim();
+        }
+    }
+    return Object.keys(target).length > 0 ? target : null;
+}
+function collectCodexTargetsFromUnknownCell(value, targets, owner) {
+    const collectCandidate = (candidate) => {
+        if (!candidate ||
+            typeof candidate !== 'object' ||
+            Array.isArray(candidate)) {
+            return;
+        }
+        const route = candidate['route'];
+        if (Array.isArray(route)) {
+            for (const entry of route) {
+                const target = routeTargetFromUnknown(entry);
+                if (target) {
+                    collectCodexTargetFromEntry(target, targets, owner);
+                }
+            }
+            return;
+        }
+        const target = routeTargetFromUnknown(candidate);
+        if (target) {
+            collectCodexTargetFromEntry(target, targets, owner);
+        }
+    };
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            collectCandidate(entry);
+        }
+        return;
+    }
+    if (!value || typeof value !== 'object') {
+        return;
+    }
+    const candidates = value['candidates'];
+    if (!Array.isArray(candidates)) {
+        return;
+    }
+    for (const entry of candidates) {
+        if (typeof entry === 'string') {
+            continue;
+        }
+        collectCandidate(entry);
+    }
+}
+function collectCodexTargetsFromUnknownProvider(value, targets, owner) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return;
+    }
+    for (const cell of Object.values(value)) {
+        collectCodexTargetsFromUnknownCell(cell, targets, owner);
+    }
+}
+function frontmatterBlock(content) {
+    const normalized = content.startsWith('\uFEFF') ? content.slice(1) : content;
+    if (!normalized.startsWith('---\n')) {
+        return null;
+    }
+    const end = normalized.indexOf('\n---', 4);
+    return end > 0 ? normalized.slice(4, end) : null;
+}
+async function collectProjectStateCodexTargets(scopeRoot, options, targets) {
+    const projectPathCandidate = options.projectPath === undefined
+        ? (await resolveActiveProject(scopeRoot)).path
+        : options.projectPath;
+    if (!projectPathCandidate) {
+        return;
+    }
+    const projectPath = normalizeProjectPath(scopeRoot, projectPathCandidate);
+    if (!projectPath) {
+        if (options.projectPath !== undefined) {
+            throw new CliError(`Project-scoped Codex materialization path must be repo-relative or inside repo root: ${projectPathCandidate}`);
+        }
+        return;
+    }
+    let realProjectPath;
+    try {
+        const validated = await validateRealPathWithinScope(join(scopeRoot, projectPath), scopeRoot);
+        realProjectPath = validated.realPath;
+    }
+    catch {
+        if (options.projectPath !== undefined) {
+            throw new CliError(`Project-scoped Codex materialization path must be repo-relative or inside repo root: ${projectPathCandidate}`);
+        }
+        return;
+    }
+    const statePath = join(realProjectPath, 'state.md');
+    const stateContent = await readOptionalFile(statePath);
+    if (!stateContent) {
+        return;
+    }
+    const frontmatter = frontmatterBlock(stateContent);
+    if (!frontmatter) {
+        return;
+    }
+    const parsed = YAML.parse(frontmatter);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return;
+    }
+    const policy = parsed['oat_dispatch_policy'];
+    if (!policy || typeof policy !== 'object' || Array.isArray(policy)) {
+        return;
+    }
+    const matrix = policy['matrix'];
+    if (!matrix || typeof matrix !== 'object' || Array.isArray(matrix)) {
+        return;
+    }
+    collectCodexTargetsFromUnknownProvider(matrix['codex'], targets, 'project-config');
+}
+function isUserCodexScope(scopeRoot, options) {
+    if (!options.userConfigDir) {
+        return false;
+    }
+    return resolve(scopeRoot) === resolve(options.userConfigDir, '..');
+}
+async function readCodexMaterializationTargets(scopeRoot, options = {}) {
+    const targets = new Map();
+    const effectiveConfig = await resolveEffectiveConfig(scopeRoot, options.userConfigDir ?? join(scopeRoot, '.oat', '__no-user-config__'), options.env);
+    if (isUserCodexScope(scopeRoot, options)) {
+        collectCodexMaterializationTargetsFromProvider(effectiveConfig.user.workflow?.dispatchCeiling?.providers?.codex, targets, 'user-config');
+        return sortCodexMaterializationTargets(targets);
+    }
+    for (const target of SUPPORTED_CODEX_ROLE_TARGETS) {
+        targets.set(`${target.model}\0${target.effort}`, {
+            ...target,
+            owner: 'supported-catalogue',
+        });
+    }
+    for (const providerValue of [
+        effectiveConfig.shared.workflow?.dispatchCeiling?.providers?.codex,
+        effectiveConfig.local.workflow?.dispatchCeiling?.providers?.codex,
+    ]) {
+        collectCodexMaterializationTargetsFromProvider(providerValue, targets, 'project-config');
+    }
+    await collectProjectStateCodexTargets(scopeRoot, options, targets);
+    return sortCodexMaterializationTargets(targets);
+}
 function parseConfigAgentTable(content) {
     if (!content || content.trim() === '') {
         return {};
@@ -122,9 +320,9 @@ function parseConfigAgentTable(content) {
         return {};
     }
 }
-async function collectStaleManagedRoles(scopeRoot, existingConfigContent, desiredRoleNames) {
+async function collectStaleManagedRoles(scopeRoot, existingConfigContent, desiredRoleNames, cleanupOwner, removeLegacyProjectRoles) {
     const agents = parseConfigAgentTable(existingConfigContent);
-    const stale = [];
+    const stale = new Set();
     for (const [roleName, roleConfig] of Object.entries(agents)) {
         if (desiredRoleNames.has(roleName)) {
             continue;
@@ -138,19 +336,68 @@ async function collectStaleManagedRoles(scopeRoot, existingConfigContent, desire
         if (!roleContent || !isOatManagedCodexRoleFile(roleContent, roleName)) {
             continue;
         }
-        stale.push(roleName);
+        const owner = readOatManagedCodexRoleOwner(roleContent);
+        const legacyProjectRole = removeLegacyProjectRoles &&
+            owner === null &&
+            SUPPORTED_CODEX_BASE_ROLES.some((baseRole) => roleName.startsWith(`${baseRole}-`));
+        if (owner !== cleanupOwner && !legacyProjectRole) {
+            continue;
+        }
+        stale.add(roleName);
+    }
+    const agentsDir = join(scopeRoot, '.codex', 'agents');
+    let roleFiles;
+    try {
+        roleFiles = await readdir(agentsDir);
+    }
+    catch {
+        roleFiles = [];
+    }
+    for (const roleFile of roleFiles) {
+        if (!roleFile.endsWith('.toml')) {
+            continue;
+        }
+        const roleName = basename(roleFile, '.toml');
+        if (desiredRoleNames.has(roleName) || stale.has(roleName)) {
+            continue;
+        }
+        const rolePath = join(agentsDir, roleFile);
+        const roleContent = await readOptionalFile(rolePath);
+        if (!roleContent || !isOatManagedCodexRoleFile(roleContent, roleName)) {
+            continue;
+        }
+        const owner = readOatManagedCodexRoleOwner(roleContent);
+        const legacyProjectRole = removeLegacyProjectRoles &&
+            owner === null &&
+            SUPPORTED_CODEX_BASE_ROLES.some((baseRole) => roleName.startsWith(`${baseRole}-`));
+        if (owner !== cleanupOwner && !legacyProjectRole) {
+            continue;
+        }
+        stale.add(roleName);
     }
-    return stale.sort((left, right) => left.localeCompare(right));
+    return [...stale].sort((left, right) => left.localeCompare(right));
 }
-export async function computeCodexProjectExtensionPlan(scopeRoot, canonicalEntries, allowedCanonicalPaths) {
+export async function computeCodexProjectExtensionPlan(scopeRoot, canonicalEntries, allowedCanonicalPaths, options = {}) {
     const isPartialSync = allowedCanonicalPaths !== undefined && allowedCanonicalPaths.length > 0;
-    const desiredRoles = await desiredRolesFromCanonical(canonicalEntries.filter((entry) => canonicalPathAllowed(scopeRoot, entry, allowedCanonicalPaths)), scopeRoot);
+    const materializationTargets = await readCodexMaterializationTargets(scopeRoot, options);
+    if (!isPartialSync &&
+        isUserCodexScope(scopeRoot, options) &&
+        materializationTargets.length > 0) {
+        const canonicalBaseRoles = new Set(canonicalEntries
+            .filter((entry) => entry.type === 'agent' && entry.isFile)
+            .map((entry) => entry.name.replace(/\.md$/i, '')));
+        const missingBaseRoles = SUPPORTED_CODEX_BASE_ROLES.filter((role) => !canonicalBaseRoles.has(role));
+        if (missingBaseRoles.length > 0) {
+            throw new CliError(`Bundled managed Codex role definitions are unavailable for user sync: ${missingBaseRoles.join(', ')}. Refusing stale user-role cleanup.`);
+        }
+    }
+    const desiredRoles = await desiredRolesFromCanonical(canonicalEntries.filter((entry) => canonicalPathAllowed(scopeRoot, entry, allowedCanonicalPaths)), scopeRoot, materializationTargets);
     const desiredRoleNames = new Set(desiredRoles.map((role) => role.roleName));
     const existingConfigPath = configPath(scopeRoot);
     const existingConfigContent = await readOptionalFile(existingConfigPath);
     const staleRoles = isPartialSync
         ? []
-        : await collectStaleManagedRoles(scopeRoot, existingConfigContent, desiredRoleNames);
+        : await collectStaleManagedRoles(scopeRoot, existingConfigContent, desiredRoleNames, isUserCodexScope(scopeRoot, options) ? 'user-config' : 'project-config', !isUserCodexScope(scopeRoot, options));
     if (isPartialSync && desiredRoles.length === 0) {
         return {
             operations: [],
@@ -227,7 +474,7 @@ export async function computeCodexProjectExtensionPlan(scopeRoot, canonicalEntri
     });
     return {
         operations,
-        managedRoles: desiredRoles.map((role) => role.roleName),
+        managedRoles: [...desiredRoles.map((role) => role.roleName), ...staleRoles],
         aggregateConfigHash: hashContent(configMerge.mergedContent),
     };
 }

package/dist/providers/identity/availability.d.ts

@@ -1,4 +1,10 @@
 export type MatrixCellAvailability = 'valid' | 'unknown-value' | 'unvalidated';
+export interface MatrixCellAvailabilityResult {
+    availability: MatrixCellAvailability;
+    allowedValues?: string[];
+    message?: string;
+}
+export type MatrixCellAvailabilityResponse = MatrixCellAvailability | MatrixCellAvailabilityResult;
 export interface CursorAgentRunOptions {
     cwd: string;
     env: NodeJS.ProcessEnv;
@@ -8,15 +14,32 @@ export interface CursorAgentRunResult {
     stdout: string;
     stderr: string;
 }
+export interface CodexRunOptions {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}
+export interface CodexRunResult {
+    ok: boolean;
+    stdout: string;
+    stderr: string;
+}
 export interface AvailabilityOracleDependencies {
     pathExists: (path: string) => Promise<boolean>;
     runCursorAgent: (args: string[], options: CursorAgentRunOptions) => Promise<CursorAgentRunResult>;
+    runCodex: (args: string[], options: CodexRunOptions) => Promise<CodexRunResult>;
     env?: NodeJS.ProcessEnv;
 }
 export interface ValidateMatrixCellOptions {
     cwd: string;
+    detailed?: boolean;
     env?: NodeJS.ProcessEnv;
     dependencies?: Partial<AvailabilityOracleDependencies>;
+    target?: {
+        model?: string;
+        effort?: string;
+    } | null;
 }
-export declare function validateMatrixCell(provider: string, value: string, options: ValidateMatrixCellOptions): Promise<MatrixCellAvailability>;
+export declare function normalizeMatrixCellAvailability(result: MatrixCellAvailabilityResponse): MatrixCellAvailabilityResult;
+export declare function validateCursorSubagentModel(value: string, options: ValidateMatrixCellOptions): Promise<MatrixCellAvailabilityResult>;
+export declare function validateMatrixCell(provider: string, value: string, options: ValidateMatrixCellOptions): Promise<MatrixCellAvailabilityResponse>;
 //# sourceMappingURL=availability.d.ts.map

package/dist/providers/identity/availability.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"availability.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/availability.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,sBAAsB,GAAG,OAAO,GAAG,eAAe,GAAG,aAAa,CAAC;AAE/E,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,8BAA8B;IAC7C,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/C,cAAc,EAAE,CACd,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,qBAAqB,KAC3B,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACnC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB;AAED,MAAM,WAAW,yBAAyB;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,YAAY,CAAC,EAAE,OAAO,CAAC,8BAA8B,CAAC,CAAC;CACxD;AAwID,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,sBAAsB,CAAC,CA8BjC"}
+{"version":3,"file":"availability.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/availability.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,sBAAsB,GAAG,OAAO,GAAG,eAAe,GAAG,aAAa,CAAC;AAE/E,MAAM,WAAW,4BAA4B;IAC3C,YAAY,EAAE,sBAAsB,CAAC;IACrC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,8BAA8B,GACtC,sBAAsB,GACtB,4BAA4B,CAAC;AAEjC,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,8BAA8B;IAC7C,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/C,cAAc,EAAE,CACd,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,qBAAqB,KAC3B,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACnC,QAAQ,EAAE,CACR,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,eAAe,KACrB,OAAO,CAAC,cAAc,CAAC,CAAC;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB;AAED,MAAM,WAAW,yBAAyB;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,YAAY,CAAC,EAAE,OAAO,CAAC,8BAA8B,CAAC,CAAC;IACvD,MAAM,CAAC,EAAE;QACP,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,GAAG,IAAI,CAAC;CACV;AAWD,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,8BAA8B,GACrC,4BAA4B,CAE9B;AA+VD,wBAAsB,2BAA2B,CAC/C,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,4BAA4B,CAAC,CAsEvC;AAED,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,8BAA8B,CAAC,CA2CzC"}