@cursor/july 0.1.109 → 0.1.112

package/dist/internal/hosted-delivery.js

@@ -14,14 +14,16 @@ import { createDeferredChannelSession, DeferredChannelSessionError, } from "./de
 import { formatGuestNetworkServerTiming, GUEST_CONNECT_STALLED, GUEST_NETWORK_UNAVAILABLE, GuestNetworkUnavailableError, waitForGuestNetworkReady, } from "./guest-network.js";
 import { getHostedAdmissionAdapter, } from "./hosted-admission-adapter.js";
 import { HostedAdmissionLocalSendError, runDuringHostedAdmission, } from "./hosted-admission-context.js";
-import { HOSTED_ADMISSION_PATH, HOSTED_DELIVERY_HEADER, HOSTED_DELIVERY_PROTOCOL_VERSION, HOSTED_EXECUTION_PATH, HOSTED_GUEST_RETRY_TERMINAL, HOSTED_GUEST_RETRY_TRANSIENT, hostedFailureClassification, hostedGuestErrorResponse, isHostedReminderAdmission, parseHostedAdmission, parseHostedExecution, parseHostedReminderFireDescriptorPayload, parseHostedReminderFirePayload, } from "./hosted-delivery-protocol.js";
+import { HOSTED_ADMISSION_PATH, HOSTED_DELIVERY_HEADER, HOSTED_DELIVERY_PROTOCOL_VERSION, HOSTED_EXECUTION_PATH, HOSTED_GUEST_RETRY_TERMINAL, HOSTED_GUEST_RETRY_TRANSIENT, HOSTED_MAX_CONSUMED_DELIVERY_IDS, hostedFailureClassification, hostedGuestErrorResponse, isHostedReminderAdmission, parseHostedAdmission, parseHostedExecution, parseHostedReminderFireDescriptorPayload, parseHostedReminderFirePayload, } from "./hosted-delivery-protocol.js";
 import { abortReasonFromTurnStatus, HOSTED_EXECUTION_DIAG_RUNNING_STATUS, hostedExecutionDiagId, } from "./hosted-execution-diag.js";
 import { flushHostedExecutionRecord, } from "./hosted-execution-flush.js";
+import { finalizeHostedExecutionLatency, formatHostedExecutionLatencyServerTiming, hostedExecutionNow, runWithHostedExecutionLatency, } from "./hosted-execution-latency.js";
 import { recordHostedManagedAutomation } from "./hosted-managed-automation.js";
 import { readJsonObject } from "./http-channel.js";
 import { endActiveHttpSpan } from "./otel/http.js";
 import { ReminderValidationError, UnknownReminderError, } from "./reminder-runner.js";
 import { mapThrownRequestError, statusForThrownRequestError, } from "./request-error-status.js";
+import { HostedEnqueueNotActiveError, } from "./session-engine.js";
 /**
  * A second `send()` in one delivery is a deterministic authored bug — the
  * wire protocol carries exactly one pending send per delivery — so it must
@@ -200,7 +202,7 @@ function runAdmission(input, adapter) {
                 }
                 captured = { message, options };
                 return createDeferredChannelSession();
-            }), waitUntil: (promise) => {
+            }), waitUntil: promise => {
                 background.push(promise);
             } });
         const args = (_b = (_a = adapter.prepareArgs) === null || _a === void 0 ? void 0 : _a.call(adapter, capturingArgs)) !== null && _b !== void 0 ? _b : capturingArgs;
@@ -212,6 +214,8 @@ function runAdmission(input, adapter) {
                 payload: input.delivery.payload,
                 deliveryId: input.delivery.deliveryId,
                 args,
+                mailboxContinuationKey: input.delivery.mailboxContinuationKey,
+                platformHandoff: input.delivery.platformHandoff,
             });
         }
         catch (error) {
@@ -272,13 +276,16 @@ function runAdmission(input, adapter) {
         };
     });
 }
-function withServerTiming(response, durationMs, guestNetwork) {
+function withServerTiming(response, durationMs, guestNetwork, latency) {
     const parts = [
         `agent_sdk;desc="hosted";dur=${Math.max(0, durationMs).toFixed(1)}`,
     ];
     if (guestNetwork !== undefined) {
         parts.push(formatGuestNetworkServerTiming(guestNetwork));
     }
+    if (latency !== undefined) {
+        parts.push(...formatHostedExecutionLatencyServerTiming(latency));
+    }
     const headers = new Headers(response.headers);
     headers.set("Server-Timing", parts.join(", "));
     return new Response(response.body, {
@@ -326,6 +333,7 @@ function logGuestNetworkWait(phase, stats) {
 export function registerHostedDeliveryRoute(input) {
     var _a, _b;
     const pending = new Map();
+    const activeOwners = new Map();
     const pendingTtlMs = 10 * 60000;
     const waitForNetwork = (_a = input.waitForGuestNetwork) !== null && _a !== void 0 ? _a : (() => waitForGuestNetworkReady());
     const consumeBoundSecrets = (_b = input.consumeBoundSecrets) !== null && _b !== void 0 ? _b : (() => consumeHostedBoundSecrets());
@@ -370,7 +378,7 @@ export function registerHostedDeliveryRoute(input) {
     };
     // Hosted callers reach this only through AnyRun's signed pod-port URL.
     // The marker is a second, route-specific fence distinct from channel auth.
-    const auth = (request) => {
+    const auth = request => {
         if (request.headers.get(HOSTED_DELIVERY_HEADER) !== "1") {
             return null;
         }
@@ -414,7 +422,7 @@ export function registerHostedDeliveryRoute(input) {
                     }
                     return finish(yield dispatchHostedReminderAdmission(input, delivery));
                 }
-                const channel = input.channels.find((candidate) => candidate.id === delivery.channelId);
+                const channel = input.channels.find(candidate => candidate.id === delivery.channelId);
                 if (channel === undefined) {
                     return finish(terminalHostedError(404, "channel_not_found", `No channel named "${delivery.channelId}" is mounted.`));
                 }
@@ -435,7 +443,9 @@ export function registerHostedDeliveryRoute(input) {
                 const admissionToken = randomBytes(24).toString("hex");
                 pending.set(admissionToken, {
                     send: admitted.pendingSend,
+                    channelKind: delivery.channelKind,
                     expiresAt: Date.now() + pendingTtlMs,
+                    deliveryId: delivery.deliveryId,
                 });
                 return finish(Response.json({
                     ok: true,
@@ -455,7 +465,8 @@ export function registerHostedDeliveryRoute(input) {
                 var _a;
                 const startedAt = performance.now();
                 let guestNetwork;
-                const finish = (response) => withServerTiming(response, performance.now() - startedAt, guestNetwork);
+                let latencySnapshot;
+                const finish = (response) => withServerTiming(response, performance.now() - startedAt, guestNetwork, latencySnapshot);
                 const unconsumed = finishBoundSecrets();
                 if (unconsumed !== undefined) {
                     return finish(unconsumed);
@@ -479,8 +490,17 @@ export function registerHostedDeliveryRoute(input) {
                     return finish(network.response);
                 }
                 admitted.sessionPublicId = execution.sessionPublicId;
+                if (execution.mode === "enqueue") {
+                    const enqueueOutcome = yield enqueueIntoActiveOwner({
+                        activeOwners,
+                        sessionPublicId: execution.sessionPublicId,
+                        deliveryId: admitted.deliveryId,
+                        send: admitted.send,
+                        buildHandlerArgs: input.buildHandlerArgs,
+                    });
+                    return finish(Response.json(Object.assign({ ok: true, v: HOSTED_DELIVERY_PROTOCOL_VERSION }, enqueueOutcome)));
+                }
                 (_a = admitted.execution) !== null && _a !== void 0 ? _a : (admitted.execution = (() => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
                     const startedAt = performance.now();
                     const executionId = hostedExecutionDiagId(execution.admissionToken);
                     const sinks = Object.assign(Object.assign(Object.assign(Object.assign({}, (input.stateRoot === undefined
@@ -511,64 +531,128 @@ export function registerHostedDeliveryRoute(input) {
                         turnStatus: HOSTED_EXECUTION_DIAG_RUNNING_STATUS,
                     });
                     let sessionId = "";
-                    try {
-                        const args = input.buildHandlerArgs(admitted.send.channelId, execution.sessionPublicId);
-                        const session = yield args.send(admitted.send.message, Object.assign(Object.assign({}, admitted.send.options), { mailboxContinuation: {
-                                key: admitted.send.mailboxContinuationKey,
-                            } }));
-                        sessionId = session.id;
-                        const outcome = yield session.waitForCompletion();
-                        // Failed turns drain too: their record/continuation updates must
-                        // survive the park just like a finished turn's.
-                        yield (_a = input.drainSessionDurability) === null || _a === void 0 ? void 0 : _a.call(input, session.id);
-                        // Evict before the reply: TAS parks and hibernates this process
-                        // as soon as the POST returns. A leftover SDK handle freezes a
-                        // dead Connect/HTTP2 session that the next wake then reuses.
-                        evictHostedSdkSessions(input.evictSdkSession, session.id, execution.sessionPublicId);
-                        const hostedFailure = outcome.status === "finished"
-                            ? undefined
-                            : hostedFailureForUnfinishedTurn(outcome);
-                        yield writeDiag({
-                            sessionId: session.id,
-                            turnStatus: outcome.status,
-                            message: outcome.errorMessage,
-                            abortReason: abortReasonFromTurnStatus(outcome.status, outcome.cancellationReason),
-                            failureCode: hostedFailure === null || hostedFailure === void 0 ? void 0 : hostedFailure.error,
-                        });
-                        if (hostedFailure !== undefined) {
-                            return {
-                                status: 503,
-                                body: {
-                                    ok: false,
-                                    error: hostedFailure.error,
-                                    retry: hostedFailure.retry,
-                                    classification: hostedFailureClassification(hostedFailure.error),
-                                    turnStatus: outcome.status,
-                                    message: outcome.errorMessage,
-                                },
-                            };
+                    const owner = {
+                        primaryDeliveryId: admitted.deliveryId,
+                        acceptedDeliveryIds: [],
+                        accepting: true,
+                        inflightInjects: new Set(),
+                        enqueueResults: new Map(),
+                    };
+                    activeOwners.set(execution.sessionPublicId, owner);
+                    return yield runWithHostedExecutionLatency({ channelKind: admitted.channelKind }, () => __awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        let completionAt;
+                        let drainAt;
+                        try {
+                            const args = input.buildHandlerArgs(admitted.send.channelId, execution.sessionPublicId);
+                            const session = yield args.send(admitted.send.message, Object.assign(Object.assign({}, admitted.send.options), { mailboxContinuation: {
+                                    key: admitted.send.mailboxContinuationKey,
+                                } }));
+                            sessionId = session.id;
+                            // The pre-turn claim used an empty sessionId. Stamp the
+                            // engine id now so a dashboard / session-view poll that
+                            // only has the factory `ses_…` can follow `session-events/`.
+                            yield writeDiag({
+                                sessionId,
+                                turnStatus: HOSTED_EXECUTION_DIAG_RUNNING_STATUS,
+                            });
+                            const outcome = yield session.waitForCompletion();
+                            completionAt = hostedExecutionNow();
+                            // Status is the owner turn. waitForCompletion still waited
+                            // for any drained successor so this process is not parked
+                            // mid-follow-up; a successor failure must not 503-retry the
+                            // owner after satellites already ran.
+                            // Close acceptance at the turn boundary, before durability
+                            // work creates an idle-but-still-addressable window.
+                            owner.accepting = false;
+                            if (owner.inflightInjects.size > 0) {
+                                yield Promise.allSettled([...owner.inflightInjects]);
+                            }
+                            // Failed turns drain too: their record/continuation updates must
+                            // survive the park just like a finished turn's.
+                            yield (_a = input.drainSessionDurability) === null || _a === void 0 ? void 0 : _a.call(input, session.id);
+                            drainAt = hostedExecutionNow();
+                            const consumedDeliveryIds = [
+                                owner.primaryDeliveryId,
+                                ...owner.acceptedDeliveryIds,
+                            ];
+                            if (consumedDeliveryIds.length > HOSTED_MAX_CONSUMED_DELIVERY_IDS) {
+                                throw new Error(`hosted execute consumedDeliveryIds length ${String(consumedDeliveryIds.length)} exceeds cap ${String(HOSTED_MAX_CONSUMED_DELIVERY_IDS)}`);
+                            }
+                            // Evict before the reply: TAS parks and hibernates this process
+                            // as soon as the POST returns. A leftover SDK handle freezes a
+                            // dead Connect/HTTP2 session that the next wake then reuses.
+                            evictHostedSdkSessions(input.evictSdkSession, session.id, execution.sessionPublicId);
+                            const hostedFailure = outcome.status === "finished"
+                                ? undefined
+                                : hostedFailureForUnfinishedTurn(outcome);
+                            yield writeDiag({
+                                sessionId: session.id,
+                                turnStatus: outcome.status,
+                                message: outcome.errorMessage,
+                                abortReason: abortReasonFromTurnStatus(outcome.status, outcome.cancellationReason),
+                                failureCode: hostedFailure === null || hostedFailure === void 0 ? void 0 : hostedFailure.error,
+                            });
+                            const reply = hostedFailure !== undefined
+                                ? {
+                                    status: 503,
+                                    body: {
+                                        ok: false,
+                                        error: hostedFailure.error,
+                                        retry: hostedFailure.retry,
+                                        classification: hostedFailureClassification(hostedFailure.error),
+                                        turnStatus: outcome.status,
+                                        message: outcome.errorMessage,
+                                    },
+                                }
+                                : {
+                                    status: 200,
+                                    body: {
+                                        ok: true,
+                                        v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+                                        outcome: "send",
+                                        consumedDeliveryIds,
+                                    },
+                                };
+                            // Finalize as late as possible so `post_drain` and `total`
+                            // include eviction + diag write after durability drain.
+                            latencySnapshot = finalizeHostedExecutionLatency({
+                                completionAt,
+                                drainAt,
+                                endedAt: hostedExecutionNow(),
+                            });
+                            return reply;
                         }
-                        return {
-                            status: 200,
-                            body: {
-                                ok: true,
-                                v: HOSTED_DELIVERY_PROTOCOL_VERSION,
-                                outcome: "send",
-                            },
-                        };
-                    }
-                    catch (error) {
-                        evictHostedSdkSessions(input.evictSdkSession, sessionId, execution.sessionPublicId);
-                        yield writeDiag({
-                            sessionId: "",
-                            turnStatus: "error",
-                            message: error instanceof Error ? error.message : String(error),
-                            abortReason: "execute_throw",
-                            failureCode: "internal_error",
-                            error,
-                        });
-                        throw error;
-                    }
+                        catch (error) {
+                            owner.accepting = false;
+                            if (owner.inflightInjects.size > 0) {
+                                yield Promise.allSettled([...owner.inflightInjects]);
+                            }
+                            evictHostedSdkSessions(input.evictSdkSession, sessionId, execution.sessionPublicId);
+                            yield writeDiag({
+                                sessionId: "",
+                                turnStatus: "error",
+                                message: error instanceof Error ? error.message : String(error),
+                                abortReason: "execute_throw",
+                                failureCode: "internal_error",
+                                error,
+                            });
+                            const endedAt = hostedExecutionNow();
+                            // Preserve completion/drain marks when the failure happened
+                            // during post-drain work; otherwise collapse to endedAt.
+                            latencySnapshot = finalizeHostedExecutionLatency({
+                                completionAt: completionAt !== null && completionAt !== void 0 ? completionAt : endedAt,
+                                drainAt: drainAt !== null && drainAt !== void 0 ? drainAt : endedAt,
+                                endedAt,
+                            });
+                            throw error;
+                        }
+                        finally {
+                            if (activeOwners.get(execution.sessionPublicId) === owner) {
+                                activeOwners.delete(execution.sessionPublicId);
+                            }
+                        }
+                    }));
                 }))());
                 const reply = yield admitted.execution;
                 return finish(Response.json(reply.body, { status: reply.status }));
@@ -576,6 +660,67 @@ export function registerHostedDeliveryRoute(input) {
         }),
     });
 }
+function enqueueIntoActiveOwner(input) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const owner = input.activeOwners.get(input.sessionPublicId);
+        if (owner === undefined || !owner.accepting) {
+            return { outcome: "not_active" };
+        }
+        const existing = owner.enqueueResults.get(input.deliveryId);
+        if (existing !== undefined) {
+            const shared = yield existing;
+            if (shared.outcome === "enqueued" || shared.outcome === "not_active") {
+                return { outcome: shared.outcome };
+            }
+            return { outcome: "not_active" };
+        }
+        let resolveResult;
+        const resultPromise = new Promise(resolve => {
+            resolveResult = resolve;
+        });
+        owner.enqueueResults.set(input.deliveryId, resultPromise);
+        // Capacity includes the primary delivery id.
+        if (1 + owner.acceptedDeliveryIds.length >=
+            HOSTED_MAX_CONSUMED_DELIVERY_IDS) {
+            const outcome = { outcome: "not_active" };
+            resolveResult(outcome);
+            return outcome;
+        }
+        // Reserve before send so concurrent enqueues cannot oversubscribe.
+        owner.acceptedDeliveryIds.push(input.deliveryId);
+        const inject = (() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const args = input.buildHandlerArgs(input.send.channelId, input.sessionPublicId);
+                const enqueueOptions = Object.assign(Object.assign({}, input.send.options), { mailboxContinuation: {
+                        key: input.send.mailboxContinuationKey,
+                    }, hostedEnqueueOnly: true });
+                const session = yield args.send(input.send.message, enqueueOptions);
+                if (session.coalesced !== true) {
+                    throw new HostedEnqueueNotActiveError(input.sessionPublicId);
+                }
+                resolveResult({ outcome: "enqueued" });
+            }
+            catch (error) {
+                const idx = owner.acceptedDeliveryIds.lastIndexOf(input.deliveryId);
+                if (idx >= 0) {
+                    owner.acceptedDeliveryIds.splice(idx, 1);
+                }
+                resolveResult({ outcome: "not_active" });
+                if (!(error instanceof HostedEnqueueNotActiveError)) {
+                    console.warn(`[agent-sdk] hosted enqueue inject failed deliveryId=${input.deliveryId}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }))();
+        owner.inflightInjects.add(inject);
+        try {
+            yield inject;
+        }
+        finally {
+            owner.inflightInjects.delete(inject);
+        }
+        return yield resultPromise;
+    });
+}
 function evictHostedSdkSessions(evict, ...ids) {
     if (evict === undefined) {
         return;

package/dist/internal/hosted-execution-diag.js

@@ -80,8 +80,8 @@ export function hostedErrorStackSnippet(error) {
         if (stack !== undefined && stack.length > 0) {
             const lines = stack
                 .split("\n")
-                .map((line) => line.trimEnd())
-                .filter((line) => line.trim().length > 0)
+                .map(line => line.trimEnd())
+                .filter(line => line.trim().length > 0)
                 .slice(0, HOSTED_ERROR_STACK_LINE_COUNT);
             const text = lines.join("\n");
             return text.length > HOSTED_ERROR_SNIPPET_MAX_CHARS
@@ -129,7 +129,7 @@ export function parseHostedExecutionDiag(raw) {
         return undefined;
     }
     const body = parsed;
-    if (Object.keys(body).some((key) => !DIAG_KEYS.has(key))) {
+    if (Object.keys(body).some(key => !DIAG_KEYS.has(key))) {
         return undefined;
     }
     if (body.v !== HOSTED_EXECUTION_DIAG_VERSION ||

package/dist/internal/hosted-execution-latency.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Hosted-execution interactive latency: first user-visible outbound and
+ * phase timings (send → waitForCompletion → durability drain → post-drain →
+ * total).
+ *
+ * Guest OTel (`agent_sdk.hosted_execution.*`) follows the package's existing
+ * guest-side OTel meter conventions (same pattern as `agent_sdk.http.duration`
+ * / process-memory histograms) so guest exporters can chart phases without
+ * waiting on control-plane scrape.
+ *
+ * Control-plane scrape of `as_hex` Server-Timing into
+ * `agent_sdk.runtime.hosted_execution.*` follows the established
+ * `guest_duration_ms` / `guest_network_wait_ms` path so Datadog control-plane
+ * dashboards can join execute wall time with guest phases. Both are retained
+ * because they feed different scrape surfaces already used in production.
+ *
+ * Tags stay low-cardinality: channel_kind, phase, outcome, delivery_surface.
+ * Never tag message content, Slack IDs, tokens, workflow/request/session IDs.
+ */
+import { type Meter } from "@opentelemetry/api";
+export declare const HOSTED_EXECUTION_DURATION_METRIC = "agent_sdk.hosted_execution.duration_ms";
+export declare const HOSTED_EXECUTION_VISIBLE_REPLY_METRIC = "agent_sdk.hosted_execution.visible_reply";
+/** Server-Timing metric name scraped by the control plane. */
+export declare const HOSTED_EXECUTION_SERVER_TIMING = "as_hex";
+export type HostedVisibleReplyOutcome = "none" | "progress_update" | "final_post" | "error";
+export type HostedLatencyPhase = "to_first_visible" | "first_visible_to_completion" | "durability_drain" | "post_drain" | "total";
+export type HostedDeliverySurface = "slack" | "none";
+export type HostedExecutionLatencySnapshot = {
+    channelKind: string;
+    outcome: HostedVisibleReplyOutcome;
+    deliverySurface: HostedDeliverySurface;
+    phases: Partial<Record<HostedLatencyPhase, number>>;
+};
+/** Monotonic clock used for latency marks (injectable in tests). */
+export declare function hostedExecutionNow(): number;
+/** @internal */
+export declare function setHostedExecutionLatencyNowForTests(now: (() => number) | undefined): void;
+/** @internal */
+export declare function setHostedExecutionLatencyMeterForTests(meter: Meter | undefined): void;
+/** @internal */
+export declare function resetHostedExecutionLatencyForTests(): void;
+export declare function sanitizeHostedChannelKind(value: string): string;
+/**
+ * Run hosted execution work inside the latency ALS. Slack delivery marks
+ * first-visible against this store; no-ops outside the window.
+ */
+export declare function runWithHostedExecutionLatency<T>(args: {
+    channelKind: string;
+}, work: () => T): T;
+export declare function isDuringHostedExecutionLatency(): boolean;
+/**
+ * Mark the first user-visible Slack outbound success. Exact-once: later
+ * progress updates and final fallback posts are ignored.
+ */
+export declare function markHostedFirstVisibleReply(args: {
+    outcome: "progress_update" | "final_post";
+    deliverySurface?: HostedDeliverySurface;
+}): boolean;
+/**
+ * Count a visible-outbound failure when nothing user-visible succeeded yet.
+ * Exact-once; ignored after a first-visible mark or a prior error.
+ */
+export declare function noteHostedVisibleReplyError(args?: {
+    deliverySurface?: HostedDeliverySurface;
+}): void;
+/**
+ * Emit phase histograms + optional none counter; return a snapshot for
+ * Server-Timing. Safe to call once per ALS window.
+ *
+ * `endedAt` should be taken as late as possible before the execution reply
+ * (or rethrow) is returned so `total` and `post_drain` include eviction and
+ * diagnostic write work after durability drain.
+ */
+export declare function finalizeHostedExecutionLatency(marks: {
+    completionAt: number;
+    drainAt: number;
+    endedAt: number;
+}): HostedExecutionLatencySnapshot | undefined;
+export declare function formatHostedExecutionLatencyServerTiming(snapshot: HostedExecutionLatencySnapshot): string[];
+//# sourceMappingURL=hosted-execution-latency.d.ts.map

package/dist/internal/hosted-execution-latency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-execution-latency.d.ts","sourceRoot":"","sources":["../../src/internal/hosted-execution-latency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EAIL,KAAK,KAAK,EAEX,MAAM,oBAAoB,CAAC;AAE5B,eAAO,MAAM,gCAAgC,2CACH,CAAC;AAC3C,eAAO,MAAM,qCAAqC,6CACN,CAAC;AAE7C,8DAA8D;AAC9D,eAAO,MAAM,8BAA8B,WAAW,CAAC;AAEvD,MAAM,MAAM,yBAAyB,GACjC,MAAM,GACN,iBAAiB,GACjB,YAAY,GACZ,OAAO,CAAC;AAEZ,MAAM,MAAM,kBAAkB,GAC1B,kBAAkB,GAClB,6BAA6B,GAC7B,kBAAkB,GAClB,YAAY,GACZ,OAAO,CAAC;AAEZ,MAAM,MAAM,qBAAqB,GAAG,OAAO,GAAG,MAAM,CAAC;AAErD,MAAM,MAAM,8BAA8B,GAAG;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,yBAAyB,CAAC;IACnC,eAAe,EAAE,qBAAqB,CAAC;IACvC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC,CAAC;CACrD,CAAC;AAwBF,oEAAoE;AACpE,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED,gBAAgB;AAChB,wBAAgB,oCAAoC,CAClD,GAAG,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,GAC9B,IAAI,CAEN;AAED,gBAAgB;AAChB,wBAAgB,sCAAsC,CACpD,KAAK,EAAE,KAAK,GAAG,SAAS,GACvB,IAAI,CAIN;AAED,gBAAgB;AAChB,wBAAgB,mCAAmC,IAAI,IAAI,CAK1D;AAiCD,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ/D;AASD;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,EAC7C,IAAI,EAAE;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,EAC7B,IAAI,EAAE,MAAM,CAAC,GACZ,CAAC,CAYH;AAED,wBAAgB,8BAA8B,IAAI,OAAO,CAExD;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE;IAChD,OAAO,EAAE,iBAAiB,GAAG,YAAY,CAAC;IAC1C,eAAe,CAAC,EAAE,qBAAqB,CAAC;CACzC,GAAG,OAAO,CAgBV;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,CAAC,EAAE;IACjD,eAAe,CAAC,EAAE,qBAAqB,CAAC;CACzC,GAAG,IAAI,CAsBP;AAYD;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,EAAE;IACpD,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,8BAA8B,GAAG,SAAS,CAkD7C;AAED,wBAAgB,wCAAwC,CACtD,QAAQ,EAAE,8BAA8B,GACvC,MAAM,EAAE,CAmBV"}