@cargo-ai/cdk 0.1.1

package/build/src/deploy/executors.live.js

@@ -0,0 +1,623 @@
+// Live executors — bind the apply engine's `Executors` contract to @cargo-ai/api.
+// Each executor receives the token-resolved spec (real uuids in place of tokens)
+// and the prior state entry, and decides: prior uuid → update; else (connector/
+// model, which have addressable slugs) exists-by-slug → adopt; else create.
+//
+// This is the only file that imports @cargo-ai/api. Workspace is implicit — the
+// authenticated client already sends the selected-workspace-uuid header.
+import { readFileSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import { readBundle } from "../resources/bundle.js";
+const str = (v) => v;
+const optStr = (v) => v === undefined || v === null ? undefined : v;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// Poll a hosting deployment until its build finishes; throw if it fails.
+async function waitForDeployment(api, uuid, attemptsLeft = 150) {
+    const { deployment } = await api.hosting.deployment.get(uuid);
+    if (deployment.status === "success")
+        return;
+    if (deployment.status === "error" || deployment.status === "cancelled") {
+        throw new Error(`deployment ${uuid} ${deployment.status}`);
+    }
+    if (attemptsLeft <= 0) {
+        throw new Error(`deployment ${uuid} did not finish building in time`);
+    }
+    await sleep(2000);
+    return waitForDeployment(api, uuid, attemptsLeft - 1);
+}
+export function liveExecutors(api) {
+    // Resolve the dataset uuid auto-created alongside a connector — needed when a
+    // connector is ADOPTED (create returns it directly; list/adopt does not).
+    async function connectorDatasetUuid(connectorUuid) {
+        const { datasets } = await api.storage.dataset.all();
+        const match = datasets.find((d) => d.kind === "connector" && d.connectorUuid === connectorUuid);
+        if (match === undefined) {
+            throw new Error(`could not resolve the dataset for adopted connector ${connectorUuid}`);
+        }
+        return match.uuid;
+    }
+    return {
+        async connector(spec, prior) {
+            const slug = str(spec["slug"]);
+            const integrationSlug = str(spec["integrationSlug"]);
+            const config = spec["config"];
+            const rateLimit = spec["rateLimit"];
+            const cacheTtlMilliseconds = spec["cacheTtlMilliseconds"];
+            if (prior !== undefined) {
+                await api.connection.connector.update({
+                    uuid: prior.uuid,
+                    name: str(spec["name"]),
+                    config: config ?? null,
+                    rateLimit: rateLimit ?? null,
+                    cacheTtlMilliseconds: cacheTtlMilliseconds ?? null,
+                });
+                // Preserve the adopted marker so destroy keeps releasing (not deleting).
+                const out = {
+                    uuid: prior.uuid,
+                    datasetUuid: prior.outputs["datasetUuid"],
+                };
+                if (prior.outputs["adopted"] !== undefined) {
+                    out["adopted"] = prior.outputs["adopted"];
+                }
+                return out;
+            }
+            const adopt = spec["adopt"] === true ||
+                (await api.connection.connector.existsBySlug({ slug })).exists;
+            if (adopt) {
+                const { connectors } = await api.connection.connector.list({
+                    integrationSlug,
+                });
+                const found = connectors.find((c) => c.slug === slug);
+                if (found === undefined) {
+                    throw new Error(`connector "${slug}" reported to exist but was not found`);
+                }
+                // Mark as adopted — the CDK linked an existing connector it didn't
+                // create, so destroy must release it rather than delete it.
+                return {
+                    uuid: found.uuid,
+                    datasetUuid: await connectorDatasetUuid(found.uuid),
+                    adopted: "true",
+                };
+            }
+            const created = await api.connection.connector.create({
+                name: str(spec["name"]),
+                slug,
+                integrationSlug,
+                config,
+                rateLimit,
+                cacheTtlMilliseconds,
+            });
+            return {
+                uuid: created.connector.uuid,
+                datasetUuid: created.dataset.uuid,
+            };
+        },
+        async model(spec, prior) {
+            const slug = str(spec["slug"]);
+            const datasetUuid = str(spec["datasetUuid"]);
+            const schedule = spec["schedule"];
+            if (prior !== undefined) {
+                // No extractorSlug — a model's extractor is immutable post-create
+                // (it's not part of UpdateModelPayload).
+                await api.storage.model.update({
+                    uuid: prior.uuid,
+                    name: str(spec["name"]),
+                    description: optStr(spec["description"]) ?? null,
+                    config: spec["config"] ?? {},
+                    schedule: schedule ?? null,
+                });
+                const out = { uuid: prior.uuid };
+                if (prior.outputs["adopted"] !== undefined) {
+                    out["adopted"] = prior.outputs["adopted"];
+                }
+                return out;
+            }
+            const exists = (await api.storage.model.existsBySlug({ slug, datasetUuid })).exists;
+            if (exists) {
+                const { models } = await api.storage.model.all();
+                const found = models.find((m) => m.slug === slug && m.datasetUuid === datasetUuid);
+                if (found === undefined) {
+                    throw new Error(`model "${slug}" reported to exist but was not found`);
+                }
+                // Adopted an existing model — release on destroy, don't delete.
+                return { uuid: found.uuid, adopted: "true" };
+            }
+            const created = await api.storage.model.create({
+                slug,
+                name: str(spec["name"]),
+                description: optStr(spec["description"]),
+                datasetUuid,
+                extractorSlug: str(spec["extractorSlug"]),
+                config: spec["config"] ?? {},
+                schedule,
+                folderUuid: optStr(spec["folderUuid"]),
+            });
+            return { uuid: created.model.uuid };
+        },
+        async play(spec, prior) {
+            // Play has no slug — identity is purely the prior state uuid.
+            const base = {
+                name: str(spec["name"]),
+                description: optStr(spec["description"]),
+                modelUuid: str(spec["modelUuid"]),
+                changeKinds: spec["changeKinds"],
+                runCreationRule: spec["runCreationRule"],
+                filter: spec["filter"],
+                sort: spec["sort"],
+                limit: spec["limit"],
+                trackingColumnSlugs: spec["trackingColumnSlugs"],
+                schedule: spec["schedule"],
+                folderUuid: optStr(spec["folderUuid"]),
+            };
+            let uuid;
+            let workflowUuid;
+            if (prior !== undefined) {
+                // play.update rejects modelUuid (a play's model is fixed at creation) —
+                // strip it from the update payload.
+                const { modelUuid: _modelUuid, ...updateBase } = base;
+                await api.orchestration.play.update({
+                    uuid: prior.uuid,
+                    ...updateBase,
+                });
+                uuid = prior.uuid;
+                workflowUuid = prior.outputs["workflowUuid"];
+            }
+            else {
+                const created = await api.orchestration.play.create(base);
+                uuid = created.play.uuid;
+                workflowUuid = created.play.workflowUuid;
+            }
+            // Deploy the play's backing workflow graph as its release, if provided.
+            const nodes = spec["nodes"];
+            if (nodes !== undefined && workflowUuid !== undefined) {
+                await api.orchestration.draftRelease.deploy({
+                    workflowUuid,
+                    nodes: nodes,
+                    formFields: (spec["formFields"] ?? null),
+                });
+            }
+            const result = { uuid };
+            if (workflowUuid !== undefined)
+                result["workflowUuid"] = workflowUuid;
+            return result;
+        },
+        async agent(spec, prior) {
+            const connectorUuid = optStr(spec["connectorUuid"]);
+            const languageModelSlug = optStr(spec["languageModelSlug"]);
+            if (connectorUuid === undefined || languageModelSlug === undefined) {
+                throw new Error(`agent "${str(spec["slug"])}" needs a connectorUuid + languageModel to deploy.`);
+            }
+            // The release needs the integration slug — resolve it from the connector.
+            const integrationSlug = (await api.connection.connector.get({ uuid: connectorUuid })).connector.integrationSlug;
+            // ── phase A: ensure the agent row exists ──
+            // NOTE: agent + release are two calls. A crash between them orphans the
+            // agent (no slug to re-find it). Acceptable for v1; a partial-persist hook
+            // would close the window.
+            let agentUuid;
+            if (prior !== undefined) {
+                agentUuid = prior.uuid;
+                await api.ai.agent.update({
+                    uuid: agentUuid,
+                    name: str(spec["name"]),
+                    icon: spec["icon"],
+                    description: optStr(spec["description"]) ?? null,
+                    triggers: mapAgentTriggers(spec["triggers"]),
+                });
+            }
+            else {
+                const created = await api.ai.agent.create({
+                    name: str(spec["name"]),
+                    icon: spec["icon"],
+                    description: optStr(spec["description"]),
+                    triggers: mapAgentTriggers(spec["triggers"]),
+                    folderUuid: optStr(spec["folderUuid"]),
+                });
+                agentUuid = created.agent.uuid;
+            }
+            // ── phase B: deploy the config release (full desired state) ──
+            // No explicit version — the backend auto-bumps (an explicit wrong value
+            // throws invalidReleaseVersion).
+            await api.ai.release.deployDraft({
+                agentUuid,
+                integrationSlug,
+                connectorUuid,
+                languageModelSlug,
+                systemPrompt: optStr(spec["systemPrompt"]),
+                withReasoning: spec["withReasoning"],
+                temperature: spec["temperature"],
+                maxSteps: spec["maxSteps"],
+                capabilities: spec["capabilities"],
+                mcpClients: spec["mcpClients"],
+                suggestedActions: [],
+                resources: mapModelResources(spec["models"]),
+                actions: [
+                    ...mapTools(spec["tools"]),
+                    ...mapSubAgents(spec["subAgents"]),
+                    ...mapConnectorActions(spec["connectorActions"]),
+                ],
+                output: spec["output"],
+                heartbeat: spec["heartbeat"],
+                evaluator: spec["evaluator"],
+            });
+            return { uuid: agentUuid };
+        },
+        async folder(spec, prior) {
+            const name = str(spec["name"]);
+            const folderKind = str(spec["folderKind"]);
+            const parentUuid = optStr(spec["parentUuid"]);
+            if (prior !== undefined) {
+                await api.workspaceManagement.folder.update({
+                    uuid: prior.uuid,
+                    name,
+                    emojiSlug: str(spec["emojiSlug"]),
+                });
+                return { uuid: prior.uuid };
+            }
+            // Adopt by (parentUuid, name, kind) — folder names are unique per location.
+            // Mark adopted: a folder matched by name is shared workspace structure the
+            // CDK linked but didn't create, so destroy must release (not delete) it.
+            const { folders } = await api.workspaceManagement.folder.all();
+            const found = folders.find((f) => f.name === name &&
+                f.kind === folderKind &&
+                (f.parentUuid ?? undefined) === parentUuid);
+            if (found !== undefined) {
+                const out = {
+                    uuid: found.uuid,
+                    adopted: "true",
+                };
+                return out;
+            }
+            const created = await api.workspaceManagement.folder.create({
+                name,
+                emojiSlug: str(spec["emojiSlug"]),
+                kind: folderKind,
+                parentUuid,
+            });
+            return { uuid: created.folder.uuid };
+        },
+        async tool(spec, prior) {
+            const nodes = spec["nodes"];
+            const formFields = spec["formFields"];
+            const triggers = mapToolTriggers(spec["triggers"]);
+            const publicForm = spec["publicForm"];
+            let toolUuid;
+            let workflowUuid;
+            if (prior !== undefined) {
+                toolUuid = prior.uuid;
+                workflowUuid = prior.outputs["workflowUuid"];
+                await api.orchestration.tool.update({
+                    uuid: toolUuid,
+                    name: str(spec["name"]),
+                    icon: spec["icon"],
+                    description: optStr(spec["description"]) ?? null,
+                    triggers,
+                    publicForm,
+                });
+            }
+            else {
+                const created = await api.orchestration.tool.create({
+                    name: str(spec["name"]),
+                    icon: spec["icon"],
+                    description: optStr(spec["description"]),
+                    triggers,
+                    folderUuid: optStr(spec["folderUuid"]),
+                });
+                toolUuid = created.tool.uuid;
+                workflowUuid = created.tool.workflowUuid;
+                // publicForm isn't a create param — apply it via update when set.
+                if (publicForm !== null && publicForm !== undefined) {
+                    await api.orchestration.tool.update({ uuid: toolUuid, publicForm });
+                }
+            }
+            // Deploy the backing workflow's graph as the tool's release.
+            await api.orchestration.draftRelease.deploy({
+                workflowUuid,
+                nodes,
+                formFields,
+            });
+            return { uuid: toolUuid, workflowUuid };
+        },
+        async mcpServer(spec, prior) {
+            const base = {
+                name: str(spec["name"]),
+                description: optStr(spec["description"]),
+                actions: [
+                    ...mapTools(spec["tools"]),
+                    ...mapSubAgents(spec["subAgents"]),
+                    ...mapConnectorActions(spec["connectorActions"]),
+                ],
+                resources: mapModelResources(spec["models"]),
+                folderUuid: optStr(spec["folderUuid"]),
+            };
+            if (prior !== undefined) {
+                await api.ai.mcpServer.update({ uuid: prior.uuid, ...base });
+                return { uuid: prior.uuid };
+            }
+            const created = await api.ai.mcpServer.create(base);
+            return { uuid: created.mcpServer.uuid };
+        },
+        async worker(spec, prior) {
+            const files = readBundle(str(spec["path"]));
+            const slug = str(spec["slug"]);
+            let uuid;
+            let adopted = false;
+            if (prior !== undefined) {
+                uuid = prior.uuid;
+            }
+            else {
+                // Recover our own slot if a prior deploy created it but crashed before
+                // persisting (e.g. a failed build). The slug is CDK-chosen, so a worker
+                // with the same slug is *probably* ours — reuse it instead of
+                // conflicting. We can't be certain it isn't a foreign same-slug worker,
+                // so mark it adopted: destroy will release (not delete) it.
+                const { workers } = await api.hosting.worker.list();
+                const existing = workers.find((w) => w.slug === slug);
+                if (existing !== undefined) {
+                    uuid = existing.uuid;
+                    adopted = true;
+                }
+                else {
+                    uuid = (await api.hosting.worker.create({
+                        name: str(spec["name"]),
+                        slug,
+                        description: optStr(spec["description"]) ?? null,
+                        folderUuid: optStr(spec["folderUuid"]),
+                    })).worker.uuid;
+                }
+            }
+            const { deployment } = await api.hosting.deployment.create({
+                kind: "worker",
+                workerUuid: uuid,
+                files,
+            });
+            // Wait for the build to succeed before promoting (don't promote a
+            // still-building or failed deployment).
+            await waitForDeployment(api, deployment.uuid);
+            const { deployment: promoted } = await api.hosting.deployment.promote({
+                uuid: deployment.uuid,
+            });
+            const out = {
+                uuid,
+                url: promoted.url,
+            };
+            if (adopted)
+                out["adopted"] = "true";
+            return out;
+        },
+        async app(spec, prior) {
+            const files = readBundle(str(spec["path"]));
+            const slug = str(spec["slug"]);
+            let uuid;
+            let adopted = false;
+            if (prior !== undefined) {
+                uuid = prior.uuid;
+            }
+            else {
+                // Recover our own slot if a prior deploy created it but crashed before
+                // persisting — same-slug app is *probably* ours (the slug is
+                // CDK-chosen). We can't be certain, so mark it adopted: destroy will
+                // release (not delete) it.
+                const { apps } = await api.hosting.app.list();
+                const existing = apps.find((a) => a.slug === slug);
+                if (existing !== undefined) {
+                    uuid = existing.uuid;
+                    adopted = true;
+                }
+                else {
+                    uuid = (await api.hosting.app.create({
+                        name: str(spec["name"]),
+                        slug,
+                        description: optStr(spec["description"]),
+                        folderUuid: optStr(spec["folderUuid"]),
+                    })).app.uuid;
+                }
+            }
+            const { deployment } = await api.hosting.deployment.create({
+                kind: "app",
+                appUuid: uuid,
+                files,
+            });
+            // Wait for the build to succeed before promoting (don't promote a
+            // still-building or failed deployment).
+            await waitForDeployment(api, deployment.uuid);
+            const { deployment: promoted } = await api.hosting.deployment.promote({
+                uuid: deployment.uuid,
+            });
+            const out = {
+                uuid,
+                url: promoted.url,
+            };
+            if (adopted)
+                out["adopted"] = "true";
+            return out;
+        },
+        async file(spec, prior) {
+            const name = str(spec["name"]);
+            const folderUuid = optStr(spec["folderUuid"]);
+            const contentHash = str(spec["contentHash"]);
+            // Uploads the local file's current bytes and reconciles the new uuid by
+            // its s3Filename. Cargo mints a fresh uuid on every upload, so this is the
+            // only way to get content into a file — both for create and for replace.
+            const uploadContent = async () => {
+                const path = str(spec["path"]);
+                const abs = isAbsolute(path) ? path : resolve(process.cwd(), path);
+                const upload = new File([readFileSync(abs)], name);
+                // The upload client is fire-and-forget (it resolves before the request
+                // finishes and reports the result through callbacks), so wait on the
+                // callback — not the returned promise — for the real completion signal.
+                // onComplete now carries the created uuid; reconcile by s3Filename only
+                // as a fallback for older clients that didn't surface it.
+                const created = await new Promise((complete, fail) => {
+                    void api.content.file.upload({
+                        file: upload,
+                        folderUuid,
+                        onProgress: () => { },
+                        onComplete: (p) => {
+                            complete({ uuid: p.uuid, s3Filename: p.s3Filename });
+                        },
+                        onError: () => {
+                            fail(new Error(`upload of file "${name}" failed`));
+                        },
+                    });
+                });
+                if (created.uuid !== undefined)
+                    return created.uuid;
+                const { files } = await api.content.file.all(folderUuid === undefined ? undefined : { folderUuid });
+                const found = files.find((f) => f.s3Filename === created.s3Filename);
+                if (found === undefined) {
+                    throw new Error(`uploaded file "${name}" was not found after upload`);
+                }
+                return found.uuid;
+            };
+            if (prior !== undefined) {
+                if (prior.outputs["contentHash"] === contentHash) {
+                    // Content unchanged — only name/folder can drift, so reconcile that
+                    // metadata in place and keep the same uuid.
+                    await api.content.file.update({
+                        uuid: prior.uuid,
+                        name,
+                        folderUuid: folderUuid === undefined ? null : folderUuid,
+                    });
+                    return { uuid: prior.uuid, contentHash };
+                }
+                // Content changed. Files are immutable (no replace endpoint), so upload
+                // a fresh file and delete the old one. The uuid changes; any resource
+                // referencing this file by token resolves to the new uuid on this same
+                // apply run (apply runs in topological order from current outputs).
+                const uuid = await uploadContent();
+                await api.content.file.remove(prior.uuid);
+                return { uuid, contentHash };
+            }
+            const uuid = await uploadContent();
+            return { uuid, contentHash };
+        },
+        // The workspace's single context repository. Writes each declared file into
+        // the repo via the runtime, only when its content differs from what's live.
+        // Additive: files removed from code are left in place.
+        async context(spec, _prior) {
+            const files = (spec["files"] ?? {});
+            const { repository } = await api.context.repository.get();
+            for (const [path, content] of Object.entries(files)) {
+                let current;
+                try {
+                    current = (await api.context.runtime.read({ path })).content;
+                }
+                catch {
+                    current = undefined; // new file — read 404s
+                }
+                if (current !== content) {
+                    await api.context.runtime.write({
+                        path,
+                        content,
+                        commitMessage: `cdk: sync ${path}`,
+                    });
+                }
+            }
+            return { uuid: repository.uuid };
+        },
+    };
+}
+// Tolerate a missing field (older/partial spec) by treating it as an empty list.
+function arr(value) {
+    return value === undefined || value === null ? [] : value;
+}
+function mapModelResources(value) {
+    return arr(value).map((m) => ({
+        kind: "model",
+        name: null,
+        // use the model uuid as the resource slug (a stable per-agent identifier)
+        slug: m.uuid,
+        description: null,
+        prompt: m.prompt,
+        integrationSlug: null,
+        modelUuid: m.uuid,
+        filter: null,
+        selectedColumnSlugs: m.columns,
+        limit: null,
+        isReadOnly: m.readOnly,
+    }));
+}
+// Agent's `tools` — rich refs (uuid token resolved + per-call options).
+function mapTools(value) {
+    return arr(value).map((t) => ({
+        kind: "tool",
+        name: t.name,
+        slug: t.uuid,
+        description: t.description,
+        isBulkAllowed: t.isBulkAllowed,
+        config: {},
+        toolUuid: t.uuid,
+        templateSlug: null,
+        waitUntilFinished: t.waitUntilFinished,
+    }));
+}
+// Agent's `subAgents` — rich refs (uuid token resolved + per-call options).
+function mapSubAgents(value) {
+    return arr(value).map((s) => ({
+        kind: "agent",
+        name: s.name,
+        slug: s.uuid,
+        description: s.description,
+        isBulkAllowed: s.isBulkAllowed,
+        config: {},
+        agentUuid: s.uuid,
+        templateSlug: null,
+        waitUntilFinished: s.waitUntilFinished,
+    }));
+}
+// connector actions have no waitUntilFinished — the rest of the options apply.
+function mapConnectorActions(value) {
+    return arr(value).map((a) => ({
+        kind: "connector",
+        name: a.name === undefined || a.name === null ? null : a.name,
+        slug: `${a.integration}_${a.actionSlug}`,
+        description: a.description === undefined || a.description === null
+            ? null
+            : a.description,
+        isBulkAllowed: a.isBulkAllowed === undefined ? false : a.isBulkAllowed,
+        config: a.config === undefined ? {} : a.config,
+        integrationSlug: a.integration,
+        connectorUuid: a.connectorUuid === undefined ? null : a.connectorUuid,
+        actionSlug: a.actionSlug,
+    }));
+}
+function mapToolTriggers(value) {
+    // triggers are optional on both tool.create and tool.update — omit the key
+    // entirely when there are none rather than sending an empty array.
+    const triggers = value;
+    if (triggers === undefined || triggers.length === 0)
+        return undefined;
+    return triggers.map((t) => ({
+        name: t.name === undefined ? t.cron : t.name,
+        description: t.description === undefined ? null : t.description,
+        type: "cron",
+        cron: t.cron,
+        data: t.data === undefined ? {} : t.data,
+    }));
+}
+function mapAgentTriggers(value) {
+    // triggers are optional on both agent.create and agent.update — omit the key
+    // entirely when there are none rather than sending an empty array.
+    const triggers = value;
+    if (triggers === undefined || triggers.length === 0)
+        return undefined;
+    return triggers.map((t) => {
+        if (t.type === "cron") {
+            return {
+                name: t.name === undefined ? t.text : t.name,
+                description: null,
+                type: "cron",
+                cron: t.cron,
+                text: t.text,
+            };
+        }
+        return {
+            name: t.name === undefined ? t.integration : t.name,
+            description: null,
+            type: "connector",
+            connectorUuid: t.connectorUuid === undefined ? null : t.connectorUuid,
+            integrationSlug: t.integration,
+            config: t.config === undefined ? {} : t.config,
+        };
+    });
+}

package/build/src/deploy/import.d.ts

@@ -0,0 +1,13 @@
+import type { Api } from "@cargo-ai/api";
+import type { ResourceKind, ResourceNode } from "../core.js";
+export type ImportResult = {
+    kind: ResourceKind;
+    outputs: Record<string, string>;
+};
+/**
+ * Import the live resource `uuid` as the code resource `id` (e.g. "agent:sdr").
+ * Loads the repo to confirm the id exists and capture its current hash, verifies
+ * the live resource is reachable, then writes/overwrites its state entry.
+ */
+export declare function importResource(root: string, api: Api, workspaceUuid: string, id: string, uuid: string, nodes?: readonly ResourceNode[]): Promise<ImportResult>;
+//# sourceMappingURL=import.d.ts.map

package/build/src/deploy/import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../../src/deploy/import.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAEzC,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAM7D,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC,CAAC;AA2CF;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,MAAM,EACrB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EAGZ,KAAK,CAAC,EAAE,SAAS,YAAY,EAAE,GAC9B,OAAO,CAAC,YAAY,CAAC,CAoCvB"}