@open-agent-toolkit/cli 0.2.65 → 0.2.67

package/dist/commands/pjm/remote/external-action.js

@@ -0,0 +1,367 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { containsSensitiveContentSignal, containsSensitiveContentSignalInValue, } from './credential-safety.js';
+import { requireCurrentOutboundSafety, } from './outbound-projection-safety.js';
+import { RemoteAccountContextSchema, WHOLE_FIELD_SUPPRESSION_MARKER, } from './schema.js';
+const MAX_ACTION_BYTES = 65_536;
+const MAX_OBSERVATION_BYTES = 65_536;
+const MAX_VALUE_DEPTH = 6;
+const SemanticFieldNameSchema = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[A-Za-z][A-Za-z0-9_-]*$/);
+const SuppressedFieldReferenceSchema = z.discriminatedUnion('kind', [
+    z
+        .object({
+        kind: z.literal('core'),
+        name: z.enum(['title', 'description', 'priority', 'status']),
+    })
+        .strict(),
+    z
+        .object({ kind: z.literal('extension'), key: SemanticFieldNameSchema })
+        .strict(),
+]);
+const DurableActionIdSchema = z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+const ProviderSchema = z.enum(['github', 'linear', 'jira']);
+const SemanticOperationSchema = z.enum([
+    'read',
+    'read-discussion',
+    'search-duplicates',
+    'create',
+    'update',
+    'transition',
+    'annotate',
+]);
+export const ExternalObservationEnvelopeSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    operationId: DurableActionIdSchema,
+    stepId: DurableActionIdSchema,
+    actionDigest: z.string().min(1).max(512),
+    observedAt: z.string().datetime({ offset: true }),
+    surfaceKind: z.enum(['connector', 'configured-cli']),
+    capabilityEvidenceDigest: z.string().min(1).max(512),
+    provider: ProviderSchema,
+    context: RemoteAccountContextSchema,
+    outcome: z
+        .object({
+        classification: z.enum([
+            'observed',
+            'not-committed',
+            'unknown',
+            'rejected',
+        ]),
+        identity: z
+            .object({
+            stableId: z.string().min(1).max(512),
+            aliases: z.array(z.string().max(2_048)).max(64),
+        })
+            .strict()
+            .nullable(),
+        fields: z.record(z.union([z.string(), z.number(), z.boolean(), z.null()])),
+        extensions: z
+            .record(z.union([z.string(), z.number(), z.boolean(), z.null()]))
+            .optional(),
+        revisionDigest: z.string().min(1).max(512).nullable(),
+        diagnosticCode: z.string().min(1).max(128).nullable(),
+    })
+        .strict(),
+})
+    .strict();
+const WritablePlanningFieldsSchema = z
+    .object({
+    title: z.string().max(8_192).optional(),
+    description: z.string().max(1_048_576).nullable().optional(),
+    priority: z.string().max(255).nullable().optional(),
+})
+    .strict();
+const IdentityIntentSchema = z
+    .object({
+    stableId: z.string().min(1).max(512),
+    localTarget: z
+        .object({
+        kind: z.literal('backlog'),
+        scope: z.literal('shared'),
+        id: z.string().min(1).max(255),
+        path: z.string().min(1).max(4_096),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+const ActionIntentSchemas = {
+    read: IdentityIntentSchema,
+    'read-discussion': z
+        .object({
+        stableId: z.string().min(1).max(512),
+        limit: z.number().int().min(1).max(100),
+        cursor: z.string().max(512).optional(),
+    })
+        .strict(),
+    'search-duplicates': z
+        .object({ query: z.string().min(1).max(8_192) })
+        .strict(),
+    create: z
+        .object({
+        target: z
+            .object({
+            kind: z.enum(['backlog', 'project']),
+            id: z.string().min(1).max(255),
+            scope: z.enum(['shared', 'synced', 'local']),
+        })
+            .strict(),
+        fields: WritablePlanningFieldsSchema,
+        provenanceToken: z.string().min(1).max(512),
+    })
+        .strict(),
+    update: z
+        .object({
+        stableId: z.string().min(1).max(512).nullable().optional(),
+        fields: WritablePlanningFieldsSchema,
+    })
+        .strict(),
+    transition: z
+        .object({
+        stableId: z.string().min(1).max(512),
+        transition: z.string().min(1).max(255),
+    })
+        .strict(),
+    annotate: z
+        .object({
+        stableId: z.string().min(1).max(512),
+        body: z.string().max(1_048_576),
+    })
+        .strict(),
+};
+const ExternalActionBaseSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    operationId: DurableActionIdSchema,
+    stepId: DurableActionIdSchema,
+    actionDigest: z.string().min(1).max(512),
+    provider: ProviderSchema,
+    semanticOperation: SemanticOperationSchema,
+    context: RemoteAccountContextSchema,
+    intent: z.record(z.unknown()),
+    expectedObservation: z
+        .object({
+        fields: z.array(SemanticFieldNameSchema).max(64),
+        extensionFields: z.array(SemanticFieldNameSchema).max(32).optional(),
+        requireIdentity: z.boolean(),
+        stableId: z.string().min(1).max(512).nullable().optional(),
+        capabilityEvidenceDigest: z.string().min(1).max(512).optional(),
+    })
+        .strict(),
+    outboundSafety: z
+        .object({
+        projectionDigest: z.string().min(1).max(512),
+        resultDigest: z.string().min(1).max(512),
+    })
+        .strict()
+        .nullable(),
+})
+    .strict();
+export function parseExternalAction(value) {
+    if (Buffer.byteLength(JSON.stringify(value), 'utf8') > MAX_ACTION_BYTES) {
+        throw new Error('External action exceeds the size limit.');
+    }
+    const action = ExternalActionBaseSchema.parse(value);
+    assertDepth(action.intent, 0);
+    ActionIntentSchemas[action.semanticOperation].parse(action.intent);
+    const { actionDigest, ...body } = action;
+    if (digest(body) !== actionDigest) {
+        throw new Error('External action digest is stale or mismatched.');
+    }
+    return action;
+}
+export function buildExternalAction(input) {
+    const mutation = ['create', 'update', 'transition', 'annotate'].includes(input.semanticOperation);
+    assertDepth(input.intent, 0);
+    const intent = ActionIntentSchemas[input.semanticOperation].parse(input.intent);
+    let outboundSafety = null;
+    if (mutation) {
+        if (!input.projection)
+            throw new Error('Mutation action requires an explicit outbound projection.');
+        if (canonicalJson(writableProjection(input.semanticOperation, intent)) !==
+            canonicalJson(input.projection)) {
+            throw new Error('Mutation action writable fields must exactly match its gated projection.');
+        }
+        requireCurrentOutboundSafety(input.projection, input.outboundSafety);
+        if (input.persistedPreview.projectionDigest !==
+            input.outboundSafety.projectionDigest ||
+            input.persistedPreview.safetyResultDigest !==
+                input.outboundSafety.resultDigest) {
+            throw new Error('Mutation action safety evidence does not match the persisted preview.');
+        }
+        outboundSafety = {
+            projectionDigest: input.outboundSafety.projectionDigest,
+            resultDigest: input.outboundSafety.resultDigest,
+        };
+    }
+    const expectedFields = input.expectedObservation.fields.map((field) => SemanticFieldNameSchema.parse(field));
+    const expectedExtensionFields = (input.expectedObservation.extensionFields ?? []).map((field) => SemanticFieldNameSchema.parse(field));
+    if (new Set(expectedExtensionFields).size !== expectedExtensionFields.length) {
+        throw new Error('External action extension fields must be unique and bounded.');
+    }
+    if (new Set(expectedFields).size !== expectedFields.length ||
+        expectedFields.length > 64) {
+        throw new Error('External action expected fields must be unique and bounded.');
+    }
+    if (mutation &&
+        expectedFields.some((field) => !Object.hasOwn(input.projection, field))) {
+        throw new Error('Mutation action expected fields must match its projection.');
+    }
+    const actionWithoutDigest = {
+        schemaVersion: 1,
+        operationId: input.operationId,
+        stepId: input.stepId,
+        provider: input.provider,
+        semanticOperation: SemanticOperationSchema.parse(input.semanticOperation),
+        context: RemoteAccountContextSchema.parse(input.context),
+        intent,
+        expectedObservation: {
+            ...input.expectedObservation,
+            fields: expectedFields,
+            ...(expectedExtensionFields.length > 0
+                ? { extensionFields: expectedExtensionFields }
+                : {}),
+            stableId: input.expectedObservation.stableId,
+            capabilityEvidenceDigest: input.expectedObservation.capabilityEvidenceDigest,
+        },
+        outboundSafety,
+    };
+    if (Buffer.byteLength(canonicalJson(actionWithoutDigest), 'utf8') >
+        MAX_ACTION_BYTES) {
+        throw new Error('External action exceeds the size limit.');
+    }
+    return { ...actionWithoutDigest, actionDigest: digest(actionWithoutDigest) };
+}
+export function acceptExternalObservation(input) {
+    const bytes = Buffer.byteLength(JSON.stringify(input.observation), 'utf8');
+    if (bytes > MAX_OBSERVATION_BYTES)
+        throw new Error('External observation exceeds the size limit.');
+    const observation = ExternalObservationEnvelopeSchema.parse(input.observation);
+    if (input.acceptedStepDigests?.has(observation.actionDigest)) {
+        throw new Error('External observation duplicates an accepted action.');
+    }
+    if (observation.operationId !== input.action.operationId ||
+        observation.stepId !== input.action.stepId ||
+        observation.actionDigest !== input.action.actionDigest) {
+        throw new Error('External observation is stale or mismatched.');
+    }
+    if (observation.provider !== input.action.provider ||
+        canonicalJson(observation.context) !== canonicalJson(input.action.context)) {
+        throw new Error('External observation provider context is mismatched.');
+    }
+    if (observation.capabilityEvidenceDigest !==
+        input.action.expectedObservation.capabilityEvidenceDigest) {
+        throw new Error('External observation capability evidence is mismatched.');
+    }
+    const expected = new Set(input.action.expectedObservation.fields);
+    const actual = Object.keys(observation.outcome.fields);
+    if (actual.some((field) => !expected.has(field))) {
+        throw new Error('External observation contains an unexpected field.');
+    }
+    const expectedExtensions = new Set(input.action.expectedObservation.extensionFields ?? []);
+    const actualExtensions = Object.keys(observation.outcome.extensions ?? {});
+    if (actualExtensions.some((field) => !expectedExtensions.has(field))) {
+        throw new Error('External observation contains an unexpected adapter extension.');
+    }
+    if (observation.outcome.classification === 'observed' &&
+        input.action.expectedObservation.requireIdentity &&
+        !observation.outcome.identity) {
+        throw new Error('External observation is missing required identity.');
+    }
+    if (input.action.expectedObservation.stableId !== null &&
+        observation.outcome.identity?.stableId !==
+            input.action.expectedObservation.stableId) {
+        throw new Error('External observation stable identity is mismatched.');
+    }
+    if (observation.outcome.identity &&
+        [
+            observation.outcome.identity.stableId,
+            ...observation.outcome.identity.aliases,
+        ].some((value) => containsSensitiveContentSignal(value))) {
+        throw new Error('External observation identity evidence is unsafe.');
+    }
+    if (Object.values(observation.context).some((value) => containsSensitiveContentSignal(value))) {
+        throw new Error('External observation context evidence is unsafe.');
+    }
+    if (observation.outcome.diagnosticCode &&
+        containsSensitiveContentSignal(observation.outcome.diagnosticCode)) {
+        throw new Error('External observation diagnostic evidence is unsafe.');
+    }
+    const suppressedFields = [];
+    const fields = Object.fromEntries(actual.map((field) => {
+        const value = observation.outcome.fields[field] ?? null;
+        const suppressed = typeof value === 'string' &&
+            containsSensitiveContentSignalInValue(value);
+        if (suppressed) {
+            if (!isCoreObservationField(field)) {
+                throw new Error(`Sensitive observation field '${field}' requires a declared adapter extension.`);
+            }
+            suppressedFields.push({ kind: 'core', name: field });
+        }
+        return [field, suppressed ? WHOLE_FIELD_SUPPRESSION_MARKER : value];
+    }));
+    const extensions = Object.fromEntries(actualExtensions.map((key) => {
+        const value = observation.outcome.extensions?.[key] ?? null;
+        const suppressed = containsSensitiveContentSignalInValue(value);
+        if (suppressed)
+            suppressedFields.push({ kind: 'extension', key });
+        return [key, suppressed ? WHOLE_FIELD_SUPPRESSION_MARKER : value];
+    }));
+    return {
+        ...observation,
+        outcome: {
+            ...observation.outcome,
+            fields,
+            ...(actualExtensions.length > 0 ? { extensions } : {}),
+            suppressedFields,
+        },
+    };
+}
+function isCoreObservationField(field) {
+    return ['title', 'description', 'priority', 'status'].includes(field);
+}
+function writableProjection(semanticOperation, intent) {
+    switch (semanticOperation) {
+        case 'create':
+        case 'update':
+            return intent.fields;
+        case 'transition':
+            return { status: intent.transition };
+        case 'annotate':
+            return { annotation: intent.body };
+        default:
+            return null;
+    }
+}
+function assertDepth(value, depth) {
+    if (depth > MAX_VALUE_DEPTH)
+        throw new Error('External action exceeds the depth limit.');
+    if (!value || typeof value !== 'object')
+        return;
+    for (const item of Object.values(value))
+        assertDepth(item, depth + 1);
+}
+function digest(value) {
+    return `sha256:${createHash('sha256').update(canonicalJson(value)).digest('hex')}`;
+}
+function canonicalJson(value) {
+    return JSON.stringify(value && typeof value === 'object' && !Array.isArray(value)
+        ? Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, item]) => [
+            key,
+            item && typeof item === 'object'
+                ? JSON.parse(canonicalJson(item))
+                : item,
+        ]))
+        : value);
+}

package/dist/commands/pjm/remote/host-execution.d.ts

@@ -0,0 +1,28 @@
+import { type ProviderContext, type RemoteProvider, type SemanticOperation } from './provider.js';
+export type HostSurfaceKind = 'connector' | 'configured-cli';
+export interface HostCapabilityEvidence {
+    provider: RemoteProvider;
+    context: ProviderContext;
+    surfaceKind: HostSurfaceKind;
+    availability: 'available' | 'authorization-required' | 'unsupported-or-unresolved' | 'disabled';
+    semanticCapabilities: SemanticOperation[];
+    evidenceDigest: string;
+    observedAt: string;
+}
+export declare function parseHostCapabilityEvidence(value: unknown): HostCapabilityEvidence;
+export type HostExecutionSelection = {
+    selected: true;
+    evidence: HostCapabilityEvidence;
+    fallbackUsed: boolean;
+} | {
+    selected: false;
+    reason: 'unavailable' | 'authorization-required' | 'context-mismatch' | 'capability-missing' | 'disabled' | 'attempt-started';
+};
+export declare function selectHostExecution(input: {
+    provider: RemoteProvider;
+    context: ProviderContext;
+    operation: SemanticOperation;
+    candidates: readonly HostCapabilityEvidence[];
+    attemptStarted: boolean;
+}): HostExecutionSelection;
+//# sourceMappingURL=host-execution.d.ts.map

package/dist/commands/pjm/remote/host-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-execution.d.ts","sourceRoot":"","sources":["../../../../src/commands/pjm/remote/host-execution.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACvB,MAAM,YAAY,CAAC;AAGpB,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,gBAAgB,CAAC;AAE7D,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,cAAc,CAAC;IACzB,OAAO,EAAE,eAAe,CAAC;IACzB,WAAW,EAAE,eAAe,CAAC;IAC7B,YAAY,EACR,WAAW,GACX,wBAAwB,GACxB,2BAA2B,GAC3B,UAAU,CAAC;IACf,oBAAoB,EAAE,iBAAiB,EAAE,CAAC;IAC1C,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB;AA+BD,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,OAAO,GACb,sBAAsB,CAExB;AAED,MAAM,MAAM,sBAAsB,GAC9B;IAAE,QAAQ,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,sBAAsB,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAAE,GAC3E;IACE,QAAQ,EAAE,KAAK,CAAC;IAChB,MAAM,EACF,aAAa,GACb,wBAAwB,GACxB,kBAAkB,GAClB,oBAAoB,GACpB,UAAU,GACV,iBAAiB,CAAC;CACvB,CAAC;AAEN,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,QAAQ,EAAE,cAAc,CAAC;IACzB,OAAO,EAAE,eAAe,CAAC;IACzB,SAAS,EAAE,iBAAiB,CAAC;IAC7B,UAAU,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAC9C,cAAc,EAAE,OAAO,CAAC;CACzB,GAAG,sBAAsB,CA6CzB"}

package/dist/commands/pjm/remote/host-execution.js

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import { contextsEqual, } from './provider.js';
+import { RemoteAccountContextSchema } from './schema.js';
+const HostCapabilityEvidenceSchema = z
+    .object({
+    provider: z.enum(['github', 'linear', 'jira']),
+    context: RemoteAccountContextSchema,
+    surfaceKind: z.enum(['connector', 'configured-cli']),
+    availability: z.enum([
+        'available',
+        'authorization-required',
+        'unsupported-or-unresolved',
+        'disabled',
+    ]),
+    semanticCapabilities: z
+        .array(z.enum([
+        'read',
+        'read-discussion',
+        'search-duplicates',
+        'create',
+        'update',
+        'transition',
+        'annotate',
+    ]))
+        .max(32),
+    evidenceDigest: z.string().min(1).max(512),
+    observedAt: z.string().datetime({ offset: true }),
+})
+    .strict();
+export function parseHostCapabilityEvidence(value) {
+    return HostCapabilityEvidenceSchema.parse(value);
+}
+export function selectHostExecution(input) {
+    const relevant = input.candidates.filter((candidate) => candidate.provider === input.provider);
+    if (relevant.some((candidate) => candidate.availability === 'disabled')) {
+        return { selected: false, reason: 'disabled' };
+    }
+    if (input.attemptStarted)
+        return { selected: false, reason: 'attempt-started' };
+    const contextual = relevant.filter((candidate) => contextsEqual(candidate.context, input.context));
+    if (relevant.length > 0 && contextual.length === 0) {
+        return { selected: false, reason: 'context-mismatch' };
+    }
+    const capable = contextual.filter((candidate) => candidate.semanticCapabilities.includes(input.operation));
+    if (contextual.length > 0 && capable.length === 0) {
+        return { selected: false, reason: 'capability-missing' };
+    }
+    const available = capable.filter((candidate) => candidate.availability === 'available');
+    const connector = available.find((candidate) => candidate.surfaceKind === 'connector');
+    const selected = connector ??
+        available.find((candidate) => candidate.surfaceKind === 'configured-cli');
+    if (selected) {
+        return {
+            selected: true,
+            evidence: selected,
+            fallbackUsed: selected.surfaceKind === 'configured-cli',
+        };
+    }
+    if (capable.some((candidate) => candidate.availability === 'authorization-required')) {
+        return { selected: false, reason: 'authorization-required' };
+    }
+    return { selected: false, reason: 'unavailable' };
+}

package/dist/commands/pjm/remote/index.d.ts

@@ -0,0 +1,41 @@
+import { Command } from 'commander';
+import { type RemoteCommandEnvelope } from './output.js';
+export type RemoteLifecycleOperation = 'intake' | 'publish' | 'refresh' | 'reconcile' | 'closeout' | 'discussion' | 'resolve' | 'doctor' | 'migrate' | 'storage-transition' | 'operation-continue';
+export interface RemoteCommandRequest {
+    operation: RemoteLifecycleOperation;
+    projectRoot: string;
+    bindingId?: string;
+    operationId?: string;
+    previewOperationId?: string;
+    providerRef?: string;
+    backlogId?: string;
+    projectPath?: string;
+    discussionLimit?: number;
+    resolutionKind?: 'relink' | 'detach' | 'recreate';
+    migrationMode?: 'check' | 'apply';
+    migrationApprovalDigest?: string;
+    createTarget?: {
+        provider: string;
+        localKind: 'backlog' | 'project';
+        localId: string;
+        publicationFile?: string;
+    };
+    observationStdin?: boolean;
+    capabilityEvidenceStdin?: boolean;
+    authorityEvidenceFile?: string;
+    storage?: {
+        repositoryFingerprint: string;
+        configTarget: string;
+        currentMode: 'local' | 'shared';
+        proposedPaths: string[];
+        apply: boolean;
+    };
+    storageApprovalDigest?: string;
+}
+export interface PjmRemoteCommandDependencies {
+    resolveProjectRoot(cwd: string): Promise<string>;
+    checkAdoption(projectRoot: string): Promise<'complete' | 'partial' | 'absent'>;
+    run(request: RemoteCommandRequest): Promise<RemoteCommandEnvelope>;
+}
+export declare function createPjmRemoteCommand(overrides?: Partial<PjmRemoteCommandDependencies>): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/pjm/remote/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/pjm/remote/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,OAAO,EAAuB,KAAK,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAG3E,MAAM,MAAM,wBAAwB,GAChC,QAAQ,GACR,SAAS,GACT,SAAS,GACT,WAAW,GACX,UAAU,GACV,YAAY,GACZ,SAAS,GACT,QAAQ,GACR,SAAS,GACT,oBAAoB,GACpB,oBAAoB,CAAC;AAEzB,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,wBAAwB,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAC;IAClD,aAAa,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;IAClC,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,YAAY,CAAC,EAAE;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,SAAS,GAAG,SAAS,CAAC;QACjC,OAAO,EAAE,MAAM,CAAC;QAChB,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B,CAAC;IACF,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,OAAO,CAAC,EAAE;QACR,qBAAqB,EAAE,MAAM,CAAC;QAC9B,YAAY,EAAE,MAAM,CAAC;QACrB,WAAW,EAAE,OAAO,GAAG,QAAQ,CAAC;QAChC,aAAa,EAAE,MAAM,EAAE,CAAC;QACxB,KAAK,EAAE,OAAO,CAAC;KAChB,CAAC;IACF,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,4BAA4B;IAC3C,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACjD,aAAa,CACX,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC,CAAC;IAC9C,GAAG,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC;CACpE;AAkBD,wBAAgB,sBAAsB,CACpC,SAAS,GAAE,OAAO,CAAC,4BAA4B,CAAM,GACpD,OAAO,CA+WT"}