@open-agent-toolkit/cli 0.2.65 → 0.2.66

package/dist/commands/pjm/remote/doctor.js

@@ -0,0 +1,380 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { RemoteBindingMetadataSchema, RemoteBindingStateSchema, RemoteOperationRecordSchema, assertRecordIdMatchesFilename, } from './schema.js';
+const REMOTE_CONTEXT_FIELDS = [
+    'host',
+    'owner',
+    'repositoryId',
+    'workspaceId',
+    'teamId',
+    'cloudId',
+    'siteId',
+    'projectId',
+];
+export async function runRemoteDoctorChecks(input) {
+    const [metadataFiles, stateFiles, operationFiles] = await Promise.all([
+        loadRecords(input.portableBindingsDir, RemoteBindingMetadataSchema),
+        loadRecords(input.operationalBindingsDir, RemoteBindingStateSchema),
+        loadRecords(input.operationsDir, RemoteOperationRecordSchema),
+    ]);
+    const adopted = metadataFiles.length > 0 ||
+        stateFiles.length > 0 ||
+        operationFiles.length > 0 ||
+        (input.associatedBindingIds?.length ?? 0) > 0 ||
+        input.policy !== undefined ||
+        (input.retentionBreaches?.length ?? 0) > 0 ||
+        (input.hostCapabilityAvailability?.length ?? 0) > 0;
+    if (!adopted)
+        return [];
+    const schemaFindings = collectSchemaFindings(metadataFiles, stateFiles, operationFiles);
+    const metadata = metadataFiles.flatMap((file) => file.parsed ? [file.parsed] : []);
+    const states = stateFiles.flatMap((file) => file.parsed ? [file.parsed] : []);
+    const operations = operationFiles.flatMap((file) => file.parsed ? [file.parsed] : []);
+    const identityFindings = collectIdentityFindings(metadata, states, input.associatedBindingIds ?? []);
+    const metadataStateFindings = collectMetadataStateFindings(metadata, states);
+    const forbiddenContent = metadataFiles
+        .filter((file) => containsForbiddenPortableKey(file.raw))
+        .map((file) => file.filename);
+    const policyFindings = collectRemotePolicyFindings(input.policy);
+    const concurrentBindings = collectConcurrentBindings(operations);
+    const operationalFindings = collectOperationalFindings(operations, input);
+    const retentionFindings = [...(input.retentionBreaches ?? [])].sort();
+    const unavailableCapabilities = (input.hostCapabilityAvailability ?? [])
+        .filter((entry) => !entry.available)
+        .map((entry) => entry.bindingId)
+        .sort();
+    if (input.evidenceAvailability?.associations === false) {
+        identityFindings.push('association-evidence-unavailable');
+    }
+    if (input.evidenceAvailability?.retention === false) {
+        retentionFindings.push('retention-evidence-unavailable');
+    }
+    if (input.evidenceAvailability?.hostCapabilities === false) {
+        unavailableCapabilities.push('host-capability-evidence-unavailable');
+    }
+    return [
+        findingCheck('pjm:remote_schema', 'Remote record schema and filename identity', schemaFindings),
+        findingCheck('pjm:remote_binding_ids', 'Remote binding references and stable identities', identityFindings),
+        findingCheck('pjm:remote_metadata_state', 'Portable metadata and operational state agreement', metadataStateFindings),
+        findingCheck('pjm:remote_storage_content', 'Portable metadata excludes operational or sensitive content', forbiddenContent),
+        {
+            name: 'pjm:remote_policy',
+            description: 'Remote repository policy is valid and fail-closed',
+            status: policyFindings.length === 0 ? 'pass' : 'fail',
+            message: policyFindings.length === 0
+                ? 'Remote policy is valid or not configured.'
+                : `Remote policy contains invalid or unknown fields: ${policyFindings.join(', ')}.`,
+            fix: policyFindings.length === 0
+                ? undefined
+                : 'Repair pjm.remote policy in shared .oat/config.json before any remote mutation.',
+        },
+        findingCheck('pjm:remote_concurrent_intents', 'Concurrent active remote operation intents', concurrentBindings),
+        findingCheck('pjm:remote_operations', 'Remote operation freshness, terminal state, and verification evidence', operationalFindings),
+        findingCheck('pjm:remote_retention', 'Remote operational-state retention boundary', retentionFindings),
+        findingCheck('pjm:remote_host_capability', 'Current host semantic capability availability', unavailableCapabilities),
+    ];
+}
+function collectOperationalFindings(operations, input) {
+    const findings = [];
+    const visibleStates = new Set([
+        'pending',
+        'partial',
+        'uncertain',
+        'attempt-started',
+        'verification-pending',
+    ]);
+    const now = input.now ? Date.parse(input.now) : Number.NaN;
+    const staleAfterMs = input.staleAfterMs ?? Number.POSITIVE_INFINITY;
+    for (const operation of operations) {
+        if (visibleStates.has(operation.state)) {
+            findings.push(`${operation.operationId}:${operation.state}`);
+        }
+        const age = now - Date.parse(operation.updatedAt);
+        if (Number.isFinite(age) && age > staleAfterMs) {
+            findings.push(`${operation.operationId}:stale`);
+        }
+        if (operation.state === 'verified' && operation.verification.length === 0) {
+            findings.push(`${operation.operationId}:missing-verification`);
+        }
+    }
+    return [...new Set(findings)].sort();
+}
+async function loadRecords(directory, schema) {
+    let filenames;
+    try {
+        filenames = (await readdir(directory)).filter((name) => name.endsWith('.json'));
+    }
+    catch (error) {
+        if (isFilesystemError(error, 'ENOENT'))
+            return [];
+        throw error;
+    }
+    const records = [];
+    for (const filename of filenames.sort()) {
+        let raw = null;
+        try {
+            raw = JSON.parse(await readFile(join(directory, filename), 'utf8'));
+        }
+        catch {
+            records.push({ filename, raw: null, parsed: null });
+            continue;
+        }
+        const result = schema.safeParse(raw);
+        records.push({
+            filename,
+            raw,
+            parsed: result.success ? result.data : null,
+        });
+    }
+    return records;
+}
+function collectSchemaFindings(metadata, states, operations) {
+    const findings = [];
+    for (const [files, idFor] of [
+        [metadata, (record) => record.bindingId],
+        [states, (record) => record.bindingId],
+        [operations, (record) => record.operationId],
+    ]) {
+        for (const file of files) {
+            if (!file.parsed) {
+                findings.push(file.filename);
+                continue;
+            }
+            try {
+                assertRecordIdMatchesFilename(file.filename, idFor(file.parsed));
+            }
+            catch {
+                findings.push(file.filename);
+            }
+        }
+    }
+    return findings;
+}
+function collectIdentityFindings(metadata, states, associatedBindingIds) {
+    const findings = [];
+    const known = new Set(metadata.map((record) => record.bindingId));
+    for (const bindingId of associatedBindingIds) {
+        if (!known.has(bindingId))
+            findings.push(`dangling:${bindingId}`);
+    }
+    for (const state of states) {
+        if (!known.has(state.bindingId))
+            findings.push(`dangling-state:${state.bindingId}`);
+    }
+    const byIdentity = new Map();
+    for (const record of metadata) {
+        const key = `${record.provider}:${record.remoteIdentity.stableId}`;
+        const ids = byIdentity.get(key) ?? [];
+        ids.push(record.bindingId);
+        byIdentity.set(key, ids);
+    }
+    for (const ids of byIdentity.values()) {
+        if (ids.length > 1)
+            findings.push(`duplicate:${ids.join(',')}`);
+    }
+    return findings;
+}
+function collectMetadataStateFindings(metadata, states) {
+    const metadataById = new Map(metadata.map((record) => [record.bindingId, record]));
+    const statesById = new Map(states.map((record) => [record.bindingId, record]));
+    const findings = [];
+    for (const record of metadata) {
+        const state = statesById.get(record.bindingId);
+        if (!state)
+            continue;
+        if (state.metadataUpdatedAt !== record.updatedAt) {
+            findings.push(`${record.bindingId}:metadata-timestamp`);
+        }
+        if (state.provider !== record.provider) {
+            findings.push(`${record.bindingId}:provider`);
+        }
+        if (state.snapshot) {
+            if (state.snapshot.identity.stableId !== record.remoteIdentity.stableId) {
+                findings.push(`${record.bindingId}:identity`);
+            }
+            if (!remoteContextsMatch(state.snapshot.identity.context, record.remoteIdentity.context)) {
+                findings.push(`${record.bindingId}:identity-context`);
+            }
+        }
+        if (state.capability &&
+            !remoteContextsMatch(state.capability.context, record.remoteIdentity.context)) {
+            findings.push(`${record.bindingId}:capability-context`);
+        }
+    }
+    for (const state of states) {
+        if (!metadataById.has(state.bindingId))
+            findings.push(state.bindingId);
+    }
+    return [...new Set(findings)];
+}
+function remoteContextsMatch(left, right) {
+    return REMOTE_CONTEXT_FIELDS.every((field) => left[field] === right[field]);
+}
+function containsForbiddenPortableKey(value, path = []) {
+    if (Array.isArray(value)) {
+        return value.some((entry) => containsForbiddenPortableKey(entry, path));
+    }
+    if (!isRecord(value))
+        return false;
+    const forbidden = new Set([
+        'snapshot',
+        'baseline',
+        'attempts',
+        'receipt',
+        'rawPayload',
+        'credential',
+        'authorization',
+    ]);
+    return Object.entries(value).some(([key, child]) => forbidden.has(key) ||
+        (key === 'description' && path.length === 0) ||
+        containsForbiddenPortableKey(child, [...path, key]));
+}
+function collectRemotePolicyFindings(value) {
+    if (value === undefined)
+        return [];
+    const findings = [];
+    if (!isRecord(value))
+        return ['pjm.remote'];
+    collectUnknownKeys(value, ['schemaVersion', 'storage', 'policy'], 'pjm.remote', findings);
+    if (value.schemaVersion !== 1)
+        findings.push('pjm.remote.schemaVersion');
+    if ('storage' in value) {
+        if (!isRecord(value.storage)) {
+            findings.push('pjm.remote.storage');
+        }
+        else {
+            collectUnknownKeys(value.storage, ['state'], 'pjm.remote.storage', findings);
+            if (!['local', 'shared'].includes(String(value.storage.state))) {
+                findings.push('pjm.remote.storage.state');
+            }
+        }
+    }
+    if (!isRecord(value.policy)) {
+        findings.push('pjm.remote.policy');
+        return [...new Set(findings)];
+    }
+    collectUnknownKeys(value.policy, ['description', 'authority', 'providers'], 'pjm.remote.policy', findings);
+    if (!isDescriptionMode(value.policy.description)) {
+        findings.push('pjm.remote.policy.description');
+    }
+    collectAuthorityFindings(value.policy.authority, 'pjm.remote.policy.authority', findings, true);
+    if ('providers' in value.policy) {
+        if (!isRecord(value.policy.providers)) {
+            findings.push('pjm.remote.policy.providers');
+        }
+        else {
+            const providers = new Set(['github', 'linear', 'jira']);
+            for (const [provider, providerPolicy] of Object.entries(value.policy.providers)) {
+                const path = `pjm.remote.policy.providers.${provider}`;
+                if (!providers.has(provider) || !isRecord(providerPolicy)) {
+                    findings.push(path);
+                    continue;
+                }
+                collectUnknownKeys(providerPolicy, ['description', 'authority'], path, findings);
+                if ('description' in providerPolicy &&
+                    !isDescriptionMode(providerPolicy.description)) {
+                    findings.push(`${path}.description`);
+                }
+                if ('authority' in providerPolicy) {
+                    collectAuthorityFindings(providerPolicy.authority, `${path}.authority`, findings, false);
+                }
+            }
+        }
+    }
+    return [...new Set(findings)].sort();
+}
+function collectAuthorityFindings(value, path, findings, requireDefault) {
+    if (!isRecord(value)) {
+        findings.push(path);
+        return;
+    }
+    collectUnknownKeys(value, ['default', 'operations'], path, findings);
+    if (requireDefault && !('default' in value))
+        findings.push(`${path}.default`);
+    if ('default' in value && !isAuthority(value.default)) {
+        findings.push(`${path}.default`);
+    }
+    if ('operations' in value) {
+        if (!isRecord(value.operations)) {
+            findings.push(`${path}.operations`);
+            return;
+        }
+        const operations = new Set([
+            'create',
+            'update-fields',
+            'transition',
+            'annotate',
+            'delete',
+            'relink',
+            'detach',
+            'recreate',
+        ]);
+        for (const [operation, authority] of Object.entries(value.operations)) {
+            const operationPath = `${path}.operations.${operation}`;
+            if (!operations.has(operation) || !isAuthority(authority)) {
+                findings.push(operationPath);
+            }
+        }
+    }
+}
+function collectUnknownKeys(value, allowed, path, findings) {
+    const keys = new Set(allowed);
+    for (const key of Object.keys(value)) {
+        if (!keys.has(key))
+            findings.push(`${path}.${key}`);
+    }
+}
+function isDescriptionMode(value) {
+    return ['none', 'managed-section', 'replace'].includes(String(value));
+}
+function isAuthority(value) {
+    return [
+        'read-only',
+        'user-approved',
+        'user-authorized',
+        'autonomous',
+    ].includes(String(value));
+}
+function collectConcurrentBindings(operations) {
+    const counts = new Map();
+    const active = new Set([
+        'planned',
+        'pending',
+        'authorized',
+        'attempt-started',
+        'verification-pending',
+        'partial',
+        'uncertain',
+    ]);
+    for (const operation of operations) {
+        if (active.has(operation.state)) {
+            counts.set(operation.bindingId, (counts.get(operation.bindingId) ?? 0) + 1);
+        }
+    }
+    return [...counts.entries()]
+        .filter(([, count]) => count > 1)
+        .map(([bindingId]) => bindingId)
+        .sort();
+}
+function findingCheck(name, description, findings) {
+    return {
+        name,
+        description,
+        status: findings.length === 0 ? 'pass' : 'fail',
+        message: findings.length === 0
+            ? `${description} passed.`
+            : `${description} findings: ${findings.join(', ')}`,
+        fix: findings.length === 0
+            ? undefined
+            : 'Inspect the named local record identifiers and reconcile them before remote mutation.',
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isFilesystemError(error, code) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === code);
+}

package/dist/commands/pjm/remote/external-action.d.ts

@@ -0,0 +1,208 @@
+import { z } from 'zod';
+import { type OutboundProjection, type OutboundProjectionSafetyResult } from './outbound-projection-safety.js';
+import { RemoteAccountContextSchema } from './schema.js';
+declare const SuppressedFieldReferenceSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"core">;
+    name: z.ZodEnum<["title", "description", "priority", "status"]>;
+}, "strict", z.ZodTypeAny, {
+    kind: "core";
+    name: "description" | "priority" | "status" | "title";
+}, {
+    kind: "core";
+    name: "description" | "priority" | "status" | "title";
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"extension">;
+    key: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "extension";
+    key: string;
+}, {
+    kind: "extension";
+    key: string;
+}>]>;
+declare const SemanticOperationSchema: z.ZodEnum<["read", "read-discussion", "search-duplicates", "create", "update", "transition", "annotate"]>;
+export declare const ExternalObservationEnvelopeSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    operationId: z.ZodString;
+    stepId: z.ZodString;
+    actionDigest: z.ZodString;
+    observedAt: z.ZodString;
+    surfaceKind: z.ZodEnum<["connector", "configured-cli"]>;
+    capabilityEvidenceDigest: z.ZodString;
+    provider: z.ZodEnum<["github", "linear", "jira"]>;
+    context: z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        owner: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        workspaceId: z.ZodOptional<z.ZodString>;
+        teamId: z.ZodOptional<z.ZodString>;
+        cloudId: z.ZodOptional<z.ZodString>;
+        siteId: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        host?: string | undefined;
+        owner?: string | undefined;
+        repositoryId?: string | undefined;
+        workspaceId?: string | undefined;
+        teamId?: string | undefined;
+        cloudId?: string | undefined;
+        siteId?: string | undefined;
+        projectId?: string | undefined;
+    }, {
+        host?: string | undefined;
+        owner?: string | undefined;
+        repositoryId?: string | undefined;
+        workspaceId?: string | undefined;
+        teamId?: string | undefined;
+        cloudId?: string | undefined;
+        siteId?: string | undefined;
+        projectId?: string | undefined;
+    }>;
+    outcome: z.ZodObject<{
+        classification: z.ZodEnum<["observed", "not-committed", "unknown", "rejected"]>;
+        identity: z.ZodNullable<z.ZodObject<{
+            stableId: z.ZodString;
+            aliases: z.ZodArray<z.ZodString, "many">;
+        }, "strict", z.ZodTypeAny, {
+            stableId: string;
+            aliases: string[];
+        }, {
+            stableId: string;
+            aliases: string[];
+        }>>;
+        fields: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+        revisionDigest: z.ZodNullable<z.ZodString>;
+        diagnosticCode: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        classification: "not-committed" | "observed" | "rejected" | "unknown";
+        identity: {
+            stableId: string;
+            aliases: string[];
+        } | null;
+        fields: Record<string, string | number | boolean | null>;
+        extensions?: Record<string, string | number | boolean | null> | undefined;
+        revisionDigest: string | null;
+        diagnosticCode: string | null;
+    }, {
+        classification: "not-committed" | "observed" | "rejected" | "unknown";
+        identity: {
+            stableId: string;
+            aliases: string[];
+        } | null;
+        fields: Record<string, string | number | boolean | null>;
+        extensions?: Record<string, string | number | boolean | null> | undefined;
+        revisionDigest: string | null;
+        diagnosticCode: string | null;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: 1;
+    operationId: string;
+    stepId: string;
+    actionDigest: string;
+    observedAt: string;
+    surfaceKind: "configured-cli" | "connector";
+    capabilityEvidenceDigest: string;
+    provider: "github" | "jira" | "linear";
+    context: {
+        host?: string | undefined;
+        owner?: string | undefined;
+        repositoryId?: string | undefined;
+        workspaceId?: string | undefined;
+        teamId?: string | undefined;
+        cloudId?: string | undefined;
+        siteId?: string | undefined;
+        projectId?: string | undefined;
+    };
+    outcome: {
+        classification: "not-committed" | "observed" | "rejected" | "unknown";
+        identity: {
+            stableId: string;
+            aliases: string[];
+        } | null;
+        fields: Record<string, string | number | boolean | null>;
+        extensions?: Record<string, string | number | boolean | null> | undefined;
+        revisionDigest: string | null;
+        diagnosticCode: string | null;
+    };
+}, {
+    schemaVersion: 1;
+    operationId: string;
+    stepId: string;
+    actionDigest: string;
+    observedAt: string;
+    surfaceKind: "configured-cli" | "connector";
+    capabilityEvidenceDigest: string;
+    provider: "github" | "jira" | "linear";
+    context: {
+        host?: string | undefined;
+        owner?: string | undefined;
+        repositoryId?: string | undefined;
+        workspaceId?: string | undefined;
+        teamId?: string | undefined;
+        cloudId?: string | undefined;
+        siteId?: string | undefined;
+        projectId?: string | undefined;
+    };
+    outcome: {
+        classification: "not-committed" | "observed" | "rejected" | "unknown";
+        identity: {
+            stableId: string;
+            aliases: string[];
+        } | null;
+        fields: Record<string, string | number | boolean | null>;
+        extensions?: Record<string, string | number | boolean | null> | undefined;
+        revisionDigest: string | null;
+        diagnosticCode: string | null;
+    };
+}>;
+export interface ExternalActionEnvelope {
+    schemaVersion: 1;
+    operationId: string;
+    stepId: string;
+    actionDigest: string;
+    provider: 'github' | 'linear' | 'jira';
+    semanticOperation: z.infer<typeof SemanticOperationSchema>;
+    context: z.infer<typeof RemoteAccountContextSchema>;
+    intent: Record<string, unknown>;
+    expectedObservation: {
+        fields: string[];
+        extensionFields?: string[];
+        requireIdentity: boolean;
+        stableId: string | null;
+        capabilityEvidenceDigest: string;
+    };
+    outboundSafety: {
+        projectionDigest: string;
+        resultDigest: string;
+    } | null;
+}
+export type ExternalObservationEnvelope = z.infer<typeof ExternalObservationEnvelopeSchema>;
+export declare function parseExternalAction(value: unknown): ExternalActionEnvelope;
+export declare function buildExternalAction(input: {
+    operationId: string;
+    stepId: string;
+    provider: ExternalActionEnvelope['provider'];
+    semanticOperation: ExternalActionEnvelope['semanticOperation'];
+    context: ExternalActionEnvelope['context'];
+    intent: Record<string, unknown>;
+    expectedObservation: ExternalActionEnvelope['expectedObservation'];
+    persistedPreview: {
+        projectionDigest?: string | null;
+        safetyResultDigest?: string | null;
+    };
+    projection?: OutboundProjection;
+    outboundSafety?: OutboundProjectionSafetyResult | null;
+}): ExternalActionEnvelope;
+export declare function acceptExternalObservation(input: {
+    action: ExternalActionEnvelope;
+    observation: unknown;
+    acceptedStepDigests?: ReadonlySet<string>;
+}): AcceptedExternalObservationEnvelope;
+export interface AcceptedExternalObservationEnvelope extends ExternalObservationEnvelope {
+    outcome: ExternalObservationEnvelope['outcome'] & {
+        suppressedFields: Array<z.infer<typeof SuppressedFieldReferenceSchema>>;
+    };
+}
+export {};
+//# sourceMappingURL=external-action.d.ts.map

package/dist/commands/pjm/remote/external-action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"external-action.d.ts","sourceRoot":"","sources":["../../../../src/commands/pjm/remote/external-action.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,8BAA8B,EACpC,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,0BAA0B,EAE3B,MAAM,UAAU,CAAC;AAUlB,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;IAUlC,CAAC;AAOH,QAAA,MAAM,uBAAuB,2GAQ3B,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCnC,CAAC;AAEZ,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,CAAC,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;IACvC,iBAAiB,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;IAC3D,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;IACpD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,mBAAmB,EAAE;QACnB,MAAM,EAAE,MAAM,EAAE,CAAC;QACjB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;QAC3B,eAAe,EAAE,OAAO,CAAC;QACzB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;QACxB,wBAAwB,EAAE,MAAM,CAAC;KAClC,CAAC;IACF,cAAc,EAAE;QACd,gBAAgB,EAAE,MAAM,CAAC;QACzB,YAAY,EAAE,MAAM,CAAC;KACtB,GAAG,IAAI,CAAC;CACV;AAuED,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC;AA+BF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,sBAAsB,CAY1E;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,sBAAsB,CAAC,UAAU,CAAC,CAAC;IAC7C,iBAAiB,EAAE,sBAAsB,CAAC,mBAAmB,CAAC,CAAC;IAC/D,OAAO,EAAE,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAC3C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,mBAAmB,EAAE,sBAAsB,CAAC,qBAAqB,CAAC,CAAC;IACnE,gBAAgB,EAAE;QAChB,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACjC,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KACpC,CAAC;IACF,UAAU,CAAC,EAAE,kBAAkB,CAAC;IAChC,cAAc,CAAC,EAAE,8BAA8B,GAAG,IAAI,CAAC;CACxD,GAAG,sBAAsB,CA8FzB;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,MAAM,EAAE,sBAAsB,CAAC;IAC/B,WAAW,EAAE,OAAO,CAAC;IACrB,mBAAmB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC3C,GAAG,mCAAmC,CAoHtC;AAQD,MAAM,WAAW,mCAAoC,SAAQ,2BAA2B;IACtF,OAAO,EAAE,2BAA2B,CAAC,SAAS,CAAC,GAAG;QAChD,gBAAgB,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC,CAAC;KACzE,CAAC;CACH"}