vidspotai-shared 1.0.67 → 1.0.69-dev.0

package/lib/services/agent/qualityGate.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * AG-45 — quality gate. Decides whether a generated video (per-scene or
+ * stitched) is ship-worthy, needs a cheap re-mux, needs a surgical re-gen on
+ * specific scenes, or needs a full replan.
+ *
+ * Why this exists: the original critic-driven loop in `repairTrace.ts` treated
+ * any `severity: 'fail'` finding as a regen trigger. That cost Test 1 4×
+ * scene regenerations (~16 credits) over a SINGLE prompt-vs-reference-image
+ * misalignment that didn't actually break the video — the bottle was just a
+ * different shade of green than the brief said. The user's point was sharp:
+ * "if the result was too bad then only regenerate", and the natural rule is
+ * a score band + severity floor:
+ *
+ *   per-scene score
+ *     ≥ 7        ship as-is
+ *     5.0–6.9    ship-with-caveats (no auto-regen)
+ *     3.0–4.9    surgical regen (scenes the critic flagged)
+ *     < 3.0      critical — bypass cost-confirmation if cheap
+ *
+ *   stitched score
+ *     ≥ 7 + shippable   deliver
+ *     5.0–6.9 no FAIL   text/music re-mux only ($0)
+ *     < 5.0 or FAIL     surgical regen on flagged scenes
+ *     < 3.0             replan (very rare; last resort)
+ *
+ *   guardrails (orthogonal to score):
+ *     - WARN severity is informational; only FAIL counts toward actions
+ *     - actionPlausibility FAIL is always actionable, regardless of score —
+ *       sealed-cap-while-drinking type errors break user trust at any score
+ *     - max 2 regen attempts per scene per run (`scene.regenCount`)
+ *     - cumulative cost budget: stop retrying when retry $ > 1.5× original $
+ *
+ * Every decision is returned as a structured object so the caller (repairTrace,
+ * videoJobProcessor, or any future UI) can log it to trace under
+ * `qualityGate: GateDecision[]` and let us tune the thresholds from data.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBudgetState = makeBudgetState;
+exports.decidePerSceneAction = decidePerSceneAction;
+exports.decideStitchedAction = decideStitchedAction;
+function makeBudgetState(initial) {
+    return {
+        totalCreditsSpent: initial.totalCreditsSpent ?? initial.originalCreditsBudget,
+        originalCreditsBudget: initial.originalCreditsBudget,
+        regenCountByScene: initial.regenCountByScene ?? {},
+        maxRegenPerScene: initial.maxRegenPerScene ?? 2,
+        retryBudgetMultiplier: initial.retryBudgetMultiplier ?? 1.5,
+    };
+}
+// ---------------------------------------------------------------------------
+// Thresholds — single source of truth so we can tune from data later.
+// ---------------------------------------------------------------------------
+const PER_SCENE_SHIP = 7.0;
+const PER_SCENE_ACCEPTABLE = 5.0;
+const PER_SCENE_CRITICAL = 3.0;
+const STITCHED_SHIP = 7.0;
+const STITCHED_ACCEPTABLE = 5.0;
+const STITCHED_REPLAN = 3.0;
+/** Dimensions that always trigger action when FAIL, regardless of score. */
+const ALWAYS_ACTIONABLE_FAIL_DIMENSIONS = new Set([
+    "actionPlausibility", // sealed cap while drinking, doors that open the wrong way
+    "promptAdherence", // explicit user-requested element missing
+    "brandTextLegibility", // user can't read the brand → ad is broken
+]);
+// ---------------------------------------------------------------------------
+// Per-scene decision
+// ---------------------------------------------------------------------------
+function decidePerSceneAction(review, budget, opts = {}) {
+    const fails = review.findings.filter((f) => f.severity === "fail");
+    const warns = review.findings.filter((f) => f.severity === "warn");
+    const hardActionableFail = fails.find((f) => ALWAYS_ACTIONABLE_FAIL_DIMENSIONS.has(f.dimension));
+    const attemptedTimes = budget.regenCountByScene[review.sceneIndex] ?? 0;
+    const overAttemptCap = attemptedTimes >= budget.maxRegenPerScene;
+    const retryBudgetCap = budget.originalCreditsBudget * budget.retryBudgetMultiplier;
+    const overCostBudget = budget.totalCreditsSpent + (opts.perSceneRegenCostCredits ?? 4) > retryBudgetCap;
+    const overGuardrail = overAttemptCap || overCostBudget;
+    const baseCaveats = warns.map((w) => `${w.dimension}: ${w.message}`);
+    if (review.score >= PER_SCENE_SHIP) {
+        return {
+            action: "ship",
+            score: review.score,
+            reason: `score ${review.score.toFixed(1)} ≥ ${PER_SCENE_SHIP} → ship`,
+            drivingFindings: warns.map(findingToTelemetry(review.sceneIndex)),
+        };
+    }
+    if (review.score >= PER_SCENE_ACCEPTABLE && !hardActionableFail) {
+        return {
+            action: "ship-with-caveats",
+            score: review.score,
+            reason: `score ${review.score.toFixed(1)} in [${PER_SCENE_ACCEPTABLE}, ${PER_SCENE_SHIP}) with no actionable FAIL — ship with caveats`,
+            caveats: baseCaveats,
+            drivingFindings: [...warns, ...fails].map(findingToTelemetry(review.sceneIndex)),
+        };
+    }
+    // From here we'd like to regen, but guardrails might block it.
+    if (overGuardrail) {
+        const why = overAttemptCap
+            ? `scene already retried ${attemptedTimes}/${budget.maxRegenPerScene} times — ship best-effort`
+            : `retry would exceed ${budget.retryBudgetMultiplier}× cost cap — ship best-effort`;
+        return {
+            action: "ship-with-caveats",
+            score: review.score,
+            reason: `score ${review.score.toFixed(1)} below ${PER_SCENE_ACCEPTABLE} BUT ${why}`,
+            caveats: [
+                `Quality below preferred threshold (${review.score.toFixed(1)}/10).`,
+                ...fails.map((f) => `${f.dimension} FAIL: ${f.message}`),
+            ],
+            drivingFindings: fails.map(findingToTelemetry(review.sceneIndex)),
+        };
+    }
+    const driving = hardActionableFail ? [hardActionableFail] : fails;
+    const critical = review.score < PER_SCENE_CRITICAL;
+    return {
+        action: "regen-scenes",
+        score: review.score,
+        reason: critical
+            ? `score ${review.score.toFixed(1)} < ${PER_SCENE_CRITICAL} (critical) → regen scene ${review.sceneIndex}`
+            : hardActionableFail
+                ? `${hardActionableFail.dimension} FAIL is always actionable → regen scene ${review.sceneIndex}`
+                : `score ${review.score.toFixed(1)} < ${PER_SCENE_ACCEPTABLE} → regen scene ${review.sceneIndex}`,
+        sceneIndices: [review.sceneIndex],
+        estimatedRegenCredits: opts.perSceneRegenCostCredits ?? 4,
+        drivingFindings: driving.map(findingToTelemetry(review.sceneIndex)),
+    };
+}
+// ---------------------------------------------------------------------------
+// Stitched (final video) decision
+// ---------------------------------------------------------------------------
+function decideStitchedAction(stitched, perScene, budget, opts = {}) {
+    const fails = stitched.findings.filter((f) => f.severity === "fail");
+    const warns = stitched.findings.filter((f) => f.severity === "warn");
+    const hardActionableFail = fails.find((f) => ALWAYS_ACTIONABLE_FAIL_DIMENSIONS.has(f.dimension));
+    if (stitched.score >= STITCHED_SHIP && stitched.shippable) {
+        return {
+            action: "ship",
+            score: stitched.score,
+            reason: `stitched score ${stitched.score.toFixed(1)} ≥ ${STITCHED_SHIP} + shippable=true → ship`,
+            drivingFindings: warns.map(stitchedFindingToTelemetry),
+        };
+    }
+    // Replan band — only when score is awful AND structural issues (not just
+    // bad bottle texture) — that's `voiceoverPacing`, `cutRhythm`, `audioMixBalance`
+    // or `overallImpression` FAILs.
+    const structuralFail = fails.find((f) => ["voiceoverPacing", "cutRhythm", "audioMixBalance", "overallImpression"].includes(f.dimension));
+    if (stitched.score < STITCHED_REPLAN && structuralFail) {
+        return {
+            action: "replan",
+            score: stitched.score,
+            reason: `stitched score ${stitched.score.toFixed(1)} < ${STITCHED_REPLAN} with structural FAIL (${structuralFail.dimension}) → replan`,
+            drivingFindings: fails.map(stitchedFindingToTelemetry),
+        };
+    }
+    // Acceptable band with no FAILs → text/music re-mux only (cheap polish).
+    if (stitched.score >= STITCHED_ACCEPTABLE && fails.length === 0) {
+        return {
+            action: "ship-with-caveats",
+            score: stitched.score,
+            reason: `stitched score ${stitched.score.toFixed(1)} in [${STITCHED_ACCEPTABLE}, ${STITCHED_SHIP}) with zero FAIL → ship with caveats (no regen)`,
+            caveats: warns.map((w) => `${w.dimension}: ${w.message}`),
+            drivingFindings: warns.map(stitchedFindingToTelemetry),
+        };
+    }
+    // Surgical regen band — find which scenes need it.
+    const sceneIndicesFromStitched = new Set();
+    for (const f of fails) {
+        if (typeof f.sceneIndexHint === "number")
+            sceneIndicesFromStitched.add(f.sceneIndexHint);
+    }
+    // Cross-reference per-scene critic for scenes that scored badly.
+    for (const r of perScene) {
+        if (r.score < PER_SCENE_ACCEPTABLE)
+            sceneIndicesFromStitched.add(r.sceneIndex);
+    }
+    // Honour user-intent scope when present.
+    let sceneIndices = Array.from(sceneIndicesFromStitched).sort((a, b) => a - b);
+    if (opts.userIntentScope?.length) {
+        sceneIndices = sceneIndices.filter((i) => opts.userIntentScope.includes(i));
+    }
+    if (sceneIndices.length === 0) {
+        // FAIL findings but none locatable to a scene + outside user scope.
+        return {
+            action: "remix",
+            score: stitched.score,
+            reason: `stitched score ${stitched.score.toFixed(1)} with FAILs that don't map to any in-scope scene → re-mux only`,
+            drivingFindings: fails.map(stitchedFindingToTelemetry),
+        };
+    }
+    const retryCost = sceneIndices.length * (opts.perSceneRegenCostCredits ?? 4);
+    const retryBudgetCap = budget.originalCreditsBudget * budget.retryBudgetMultiplier;
+    if (budget.totalCreditsSpent + retryCost > retryBudgetCap) {
+        return {
+            action: "ship-with-caveats",
+            score: stitched.score,
+            reason: `regen would cost ${retryCost} credits, exceeding ${budget.retryBudgetMultiplier}× original budget → ship best-effort`,
+            caveats: [
+                `Score ${stitched.score.toFixed(1)}/10 below ideal but regen cost capped.`,
+                ...fails.map((f) => `${f.dimension} FAIL: ${f.message}`),
+            ],
+            drivingFindings: fails.map(stitchedFindingToTelemetry),
+        };
+    }
+    return {
+        action: "regen-scenes",
+        score: stitched.score,
+        reason: hardActionableFail
+            ? `${hardActionableFail.dimension} FAIL is always actionable → regen ${sceneIndices.length} scene(s)`
+            : `stitched score ${stitched.score.toFixed(1)} < ${STITCHED_ACCEPTABLE} with FAILs → regen ${sceneIndices.length} scene(s)`,
+        sceneIndices,
+        estimatedRegenCredits: retryCost,
+        drivingFindings: fails.map(stitchedFindingToTelemetry),
+    };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function findingToTelemetry(sceneIndex) {
+    return (f) => ({
+        sceneIndex,
+        dimension: f.dimension,
+        severity: f.severity,
+        message: f.message,
+    });
+}
+function stitchedFindingToTelemetry(f) {
+    return {
+        sceneIndex: f.sceneIndexHint,
+        dimension: f.dimension,
+        severity: f.severity,
+        message: f.message,
+    };
+}

package/lib/services/agent/referenceImageRenderer.d.ts

@@ -0,0 +1,37 @@
+/**
+ * referenceImageRenderer — AG-13 (C2 tier) pre-pass.
+ *
+ * Walks the AgentVisualBible and renders ONE reference image per entity via
+ * the generate_image tool. The resulting URLs are written back onto each
+ * entity's `referenceImageUrl` field so the executor can thread them into
+ * scene-level image-gen calls (image-to-image / subject-reference) to lock
+ * identity across scenes.
+ *
+ * Cost model: ~$0.04 × N entities for nano-banana (1 image each). On a
+ * typical UGC brief with 1 character + 1 product + 1 environment, this is
+ * ~$0.12 added to the run — paid once, amortised across every scene.
+ *
+ * Failure mode: per-entity isolated. If CHAR_1 renders fail, the bible still
+ * gets returned with CHAR_1.referenceImageUrl=undefined; the executor falls
+ * back to text-only consistency for that one entity. We do NOT block the
+ * whole run for one entity miss.
+ */
+import type { AgentVisualBible } from "../../schemas/videoPlan.schema";
+import type { RunToolFn } from "./executor";
+import type { ToolContext } from "./toolRegistry";
+export interface RenderReferenceImagesOptions {
+    /** Image model key. Default google-nano-banana — cheap + supports multi-ref. */
+    modelKey?: string;
+    /** Aspect ratio for the reference still. Default 1:1 (good for identity refs). */
+    aspectRatio?: "1:1" | "9:16" | "16:9" | "4:5" | "3:4" | "4:3";
+    /** Inject for tracing / replay (eval harness). */
+    runTool?: RunToolFn;
+}
+export declare function renderReferenceImages(bible: AgentVisualBible, ctx: ToolContext, opts?: RenderReferenceImagesOptions): Promise<AgentVisualBible>;
+/**
+ * Helper used by the executor to pluck the referenceImageUrls for a given
+ * scene's bibleEntityIds. Returns up to `cap` URLs (provider limits vary —
+ * Nano Banana 14, OpenAI 16, Seedream 10, Qwen 3, MiniMax 1).
+ */
+export declare function collectReferenceImageUrls(bible: AgentVisualBible | undefined, entityIds: string[], cap?: number): string[];
+//# sourceMappingURL=referenceImageRenderer.d.ts.map

package/lib/services/agent/referenceImageRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"referenceImageRenderer.d.ts","sourceRoot":"","sources":["../../../src/services/agent/referenceImageRenderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAe,MAAM,gCAAgC,CAAC;AACpF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,MAAM,WAAW,4BAA4B;IAC3C,gFAAgF;IAChF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kFAAkF;IAClF,WAAW,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;IAC9D,kDAAkD;IAClD,OAAO,CAAC,EAAE,SAAS,CAAC;CACrB;AAED,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,gBAAgB,EACvB,GAAG,EAAE,WAAW,EAChB,IAAI,GAAE,4BAAiC,GACtC,OAAO,CAAC,gBAAgB,CAAC,CA2C3B;AAkCD;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,gBAAgB,GAAG,SAAS,EACnC,SAAS,EAAE,MAAM,EAAE,EACnB,GAAG,SAAI,GACN,MAAM,EAAE,CAcV"}

package/lib/services/agent/referenceImageRenderer.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderReferenceImages = renderReferenceImages;
+exports.collectReferenceImageUrls = collectReferenceImageUrls;
+const toolRegistry_1 = require("./toolRegistry");
+async function renderReferenceImages(bible, ctx, opts = {}) {
+    if (bible.consistencyTier !== "C2") {
+        // No-op for C0 / C1.
+        return bible;
+    }
+    const runTool = opts.runTool ?? toolRegistry_1.runTool;
+    const modelKey = opts.modelKey ?? "google-nano-banana";
+    const aspectRatio = opts.aspectRatio ?? "1:1";
+    const renderOne = async (entity, kind) => {
+        if (entity.referenceImageUrl)
+            return entity; // pre-supplied (e.g. brandKit.presenterFaceUrl wired in)
+        const prompt = buildReferencePrompt(entity, kind);
+        try {
+            const out = await runTool("generate_image", {
+                prompt,
+                modelKey,
+                aspectRatio,
+                numImages: 1,
+            }, { ...ctx, idempotencyKey: `${ctx.idempotencyKey}:ref-${entity.id}` });
+            if (out.ok && out.output.imageUrl) {
+                return { ...entity, referenceImageUrl: out.output.imageUrl };
+            }
+            return entity;
+        }
+        catch {
+            // Per-entity miss is non-fatal — degrade to text-only for this entity.
+            return entity;
+        }
+    };
+    const [characters, objects, environments] = await Promise.all([
+        Promise.all(bible.characters.map((c) => renderOne(c, "character"))),
+        Promise.all(bible.objects.map((o) => renderOne(o, "object"))),
+        Promise.all(bible.environments.map((e) => renderOne(e, "environment"))),
+    ]);
+    return { ...bible, characters, objects, environments };
+}
+function buildReferencePrompt(entity, kind) {
+    switch (kind) {
+        case "character":
+            // Portrait-style reference so the subject's face + wardrobe + build
+            // are all clearly visible for downstream identity transfer.
+            return [
+                "Reference portrait, full-body, neutral background, soft even studio lighting,",
+                "subject centered, looking at camera, no props.",
+                entity.description,
+            ].join(" ");
+        case "object":
+            // Product-shot style reference — single subject, clean background, all
+            // identifying labels / colors / proportions visible.
+            return [
+                "Reference product shot, single subject centered on a clean neutral seamless background,",
+                "soft even studio lighting, all labels and details clearly visible, no props.",
+                entity.description,
+            ].join(" ");
+        case "environment":
+            // Wide environmental establishing shot — establishes the palette and
+            // lighting the executor will match in subsequent scenes.
+            return [
+                "Reference establishing shot of an environment, wide angle, no people, no products,",
+                "showing the dominant palette and lighting clearly.",
+                entity.description,
+            ].join(" ");
+    }
+}
+/**
+ * Helper used by the executor to pluck the referenceImageUrls for a given
+ * scene's bibleEntityIds. Returns up to `cap` URLs (provider limits vary —
+ * Nano Banana 14, OpenAI 16, Seedream 10, Qwen 3, MiniMax 1).
+ */
+function collectReferenceImageUrls(bible, entityIds, cap = 3) {
+    if (!bible || !entityIds.length)
+        return [];
+    const all = [
+        ...bible.characters,
+        ...bible.objects,
+        ...bible.environments,
+    ];
+    const urls = [];
+    for (const id of entityIds) {
+        const ent = all.find((e) => e.id === id);
+        if (ent?.referenceImageUrl)
+            urls.push(ent.referenceImageUrl);
+        if (urls.length >= cap)
+            break;
+    }
+    return urls;
+}

package/lib/services/agent/regenCore.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Stage 7 (Session H) — shared core for single-target regen.
+ *
+ * Mirrors `runRegenTarget` in apps/firebase-functions/src/controllers/
+ * agent.controller.ts so both the synchronous Function endpoints AND the
+ * new AGENT_REGEN_JOBS worker call the same code path. Until Stage 8
+ * deletes the in-controller copy, this file is the authoritative
+ * implementation; the controller copy stays for backwards-compatibility
+ * with the existing sync endpoints (they keep working unchanged).
+ *
+ * Pure logic — never reads from / writes to Firestore. The caller threads
+ * project state (the bulk executor reuses one in-memory snapshot across
+ * targets) and persists once. Per-target cache mints go via `ctx.cacheMints`
+ * which the caller writes back as `providerTaskCache.<clipId>` dot-paths.
+ */
+import { Project } from "../../schemas/project.schema";
+import { VideoPlan } from "../../schemas/videoPlan.schema";
+import { IAgentProjectModel } from "../../models/agent.model";
+import { ProviderTaskCacheEntry } from "./providerTaskCache";
+import type { RegenTarget } from "./planDiff";
+import type { RegenCostEstimate } from "../credits/pricing";
+export interface RegenCoreOptions {
+    /** Voiceover-only: if provided, rewrites scene.voiceoverLine and emits nextPlan. */
+    overrideLine?: string;
+    /** Voiceover-only: passthrough to cost estimation when captions will be re-cut afterward. */
+    captionsAlsoChange?: boolean;
+    /** Overlays-only: free-text user instruction handed to the planner. */
+    instruction?: string;
+}
+export interface RegenCoreSuccess {
+    ok: true;
+    nextPlan?: VideoPlan;
+    nextProjectJson: Project;
+    runId?: string;
+    toolCalls: unknown[];
+    cost: RegenCostEstimate;
+    details: Record<string, unknown>;
+}
+export interface RegenCoreError {
+    ok: false;
+    error: string;
+    code?: string;
+    /** Suggested HTTP status if surfaced by an HTTP wrapper. */
+    status?: number;
+}
+export type RegenCoreResult = RegenCoreSuccess | RegenCoreError;
+export interface RegenCoreContext {
+    projectId: string;
+    userId: string;
+    /** Per-clipId cache mints; caller persists these as `providerTaskCache.<clipId>` patches. */
+    cacheMints: Record<string, ProviderTaskCacheEntry>;
+}
+/**
+ * Run a single regen target against an in-memory project snapshot.
+ * Behavioural parity with each per-component HTTP handler in the
+ * controller so the bulk executor and the per-component path produce
+ * identical projectJson / plan mutations.
+ */
+export declare function executeRegenTarget(target: RegenTarget, project: IAgentProjectModel, ctx: RegenCoreContext, options?: RegenCoreOptions): Promise<RegenCoreResult>;
+//# sourceMappingURL=regenCore.d.ts.map

package/lib/services/agent/regenCore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regenCore.d.ts","sourceRoot":"","sources":["../../../src/services/agent/regenCore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAQ,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAW9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAI5D,MAAM,WAAW,gBAAgB;IAC/B,oFAAoF;IACpF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,6FAA6F;IAC7F,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,IAAI,CAAC;IACT,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,eAAe,EAAE,OAAO,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,OAAO,EAAE,CAAC;IACrB,IAAI,EAAE,iBAAiB,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,KAAK,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,eAAe,GAAG,gBAAgB,GAAG,cAAc,CAAC;AAEhE,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,6FAA6F;IAC7F,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;CACpD;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,kBAAkB,EAC3B,GAAG,EAAE,gBAAgB,EACrB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,eAAe,CAAC,CAsd1B"}