sandbox0 0.1.0

package/dist/sandbox.js

@@ -0,0 +1,398 @@
+import { split } from "shlex";
+import { models } from "./apispec_compat";
+import { APIError } from "./errors";
+import { WebSocketClient } from "./ws_client";
+/**
+ * ContextStream provides a duplex stream interface for sandbox context communication.
+ *
+ * Uses Web Streams API for:
+ * - Native backpressure control
+ * - Standardized error handling
+ * - Composability with other streams
+ *
+ * @example
+ * ```typescript
+ * const stream = await sandbox.runStream("python");
+ *
+ * // Option 1: Use async generator (convenient for simple cases)
+ * for await (const output of stream.outputs()) {
+ *   console.log(output.data);
+ * }
+ *
+ * // Option 2: Use ReadableStream directly (for advanced use)
+ * const reader = stream.readable.getReader();
+ * while (true) {
+ *   const { done, value } = await reader.read();
+ *   if (done) break;
+ *   console.log(value.data);
+ * }
+ *
+ * // Option 3: Use WritableStream for input with backpressure
+ * const writer = stream.writable.getWriter();
+ * await writer.write({ type: "input", data: "print(1)\n" });
+ * await writer.close();
+ * ```
+ */
+export class ContextStream {
+    readable;
+    writable;
+    socket;
+    _contextId;
+    _sandboxId;
+    constructor(socket, sandboxId, contextId) {
+        this.socket = socket;
+        this._sandboxId = sandboxId;
+        this._contextId = contextId;
+        // Create ReadableStream for outputs with backpressure
+        this.readable = new ReadableStream({
+            start: (controller) => {
+                socket.onMessage((data) => {
+                    const payload = parseWsMessage(data);
+                    if (!payload)
+                        return;
+                    controller.enqueue({
+                        sandboxId: this._sandboxId,
+                        contextId: this._contextId,
+                        source: String(payload.source ?? ""),
+                        data: String(payload.data ?? ""),
+                    });
+                });
+                socket.onError((err) => {
+                    controller.error(err instanceof Error ? err : new Error("websocket error"));
+                });
+                socket.onClose(() => {
+                    try {
+                        controller.close();
+                    }
+                    catch {
+                        // Controller may already be closed due to error
+                    }
+                });
+            },
+        });
+        // Create WritableStream for inputs with backpressure
+        this.writable = new WritableStream({
+            write: (chunk) => {
+                const normalized = normalizeStreamInput(chunk);
+                socket.send(JSON.stringify(normalized));
+            },
+            close: () => {
+                socket.close();
+            },
+            abort: () => {
+                socket.close();
+            },
+        });
+    }
+    get id() {
+        return this._contextId;
+    }
+    /**
+     * Send input data.
+     */
+    sendInput(data, requestId) {
+        const normalized = normalizeStreamInput({ type: "input", data, requestId });
+        this.socket.send(JSON.stringify(normalized));
+    }
+    /**
+     * Resize PTY.
+     */
+    sendResize(rows, cols) {
+        const normalized = normalizeStreamInput({ type: "resize", rows, cols });
+        this.socket.send(JSON.stringify(normalized));
+    }
+    /**
+     * Send a signal.
+     */
+    sendSignal(signal) {
+        const normalized = normalizeStreamInput({ type: "signal", signal });
+        this.socket.send(JSON.stringify(normalized));
+    }
+    /**
+     * Async generator for consuming outputs.
+     */
+    async *outputs() {
+        const reader = this.readable.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    return;
+                yield value;
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    /**
+     * Close the stream connection.
+     */
+    close() {
+        this.socket.close();
+    }
+}
+/**
+ * FileWatchStream provides a stream interface for file system watch events.
+ *
+ * Uses Web Streams API for native backpressure control and error handling.
+ *
+ * @example
+ * ```typescript
+ * const watcher = await sandbox.watchFiles("/workspace");
+ *
+ * // Option 1: Use async generator
+ * for await (const event of watcher.events()) {
+ *   console.log(event.path, event.event);
+ * }
+ *
+ * // Option 2: Use ReadableStream directly
+ * const reader = watcher.readable.getReader();
+ * while (true) {
+ *   const { done, value } = await reader.read();
+ *   if (done) break;
+ *   console.log(value.path, value.event);
+ * }
+ * ```
+ */
+export class FileWatchStream {
+    readable;
+    socket;
+    watchId;
+    constructor(socket) {
+        this.socket = socket;
+        this.readable = new ReadableStream({
+            start: (controller) => {
+                socket.onMessage((data) => {
+                    const payload = parseWsMessage(data);
+                    if (!payload)
+                        return;
+                    controller.enqueue({
+                        type: String(payload.type ?? ""),
+                        watchId: payload.watch_id ?? payload.watchId,
+                        event: payload.event,
+                        path: payload.path,
+                        error: payload.error,
+                    });
+                });
+                socket.onError((err) => {
+                    controller.error(err instanceof Error ? err : new Error("websocket error"));
+                });
+                socket.onClose(() => {
+                    try {
+                        controller.close();
+                    }
+                    catch {
+                        // Controller may already be closed due to error
+                    }
+                });
+            },
+        });
+    }
+    /**
+     * Async generator for consuming events (convenience method).
+     */
+    async *events() {
+        const reader = this.readable.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    return;
+                yield value;
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    /**
+     * Unsubscribe from the watch and close the connection.
+     */
+    unsubscribe(watchId) {
+        this.socket.send(JSON.stringify({ action: "unsubscribe", watch_id: watchId }));
+        this.close();
+    }
+    /**
+     * Close the stream connection.
+     */
+    close() {
+        this.socket.close();
+    }
+}
+export class Sandbox {
+    id;
+    template;
+    clusterId;
+    podName;
+    status;
+    client;
+    replContextByLang = new Map();
+    constructor(params) {
+        this.id = params.id;
+        this.client = params.client;
+        this.template = params.template ?? "";
+        this.clusterId = params.clusterId;
+        this.podName = params.podName ?? "";
+        this.status = params.status ?? "";
+    }
+    async run(language, input, options) {
+        if (!input.trim()) {
+            throw new APIError({
+                statusCode: 0,
+                code: "invalid_argument",
+                message: "input cannot be empty",
+            });
+        }
+        const contextId = await this.ensureReplContext(language, options);
+        const execResp = await this.contextExec(contextId, normalizeReplInput(input));
+        return {
+            sandboxId: this.id,
+            contextId,
+            outputRaw: execResp.outputRaw ?? "",
+        };
+    }
+    async cmd(command, options) {
+        if (!command.trim()) {
+            throw new APIError({
+                statusCode: 0,
+                code: "invalid_argument",
+                message: "command cannot be empty",
+            });
+        }
+        const cmdArgs = options?.command ?? parseCommand(command);
+        if (cmdArgs.length === 0) {
+            throw new APIError({
+                statusCode: 0,
+                code: "invalid_argument",
+                message: "command cannot be empty",
+            });
+        }
+        const waitUntilDone = options?.wait ?? true;
+        const request = {
+            type: models.ProcessType.Cmd,
+            cmd: { command: cmdArgs },
+            waitUntilDone,
+            cwd: options?.cwd,
+            envVars: options?.envVars,
+            ptySize: buildPty(options?.ptyRows, options?.ptyCols),
+            idleTimeoutSec: options?.idleTimeoutSec,
+            ttlSec: options?.ttlSec,
+        };
+        const contextResp = await this.createContext(request);
+        return {
+            sandboxId: this.id,
+            contextId: contextResp.id,
+            outputRaw: contextResp.outputRaw ?? "",
+        };
+    }
+    async connectWsContext(contextId) {
+        const wsUrl = this.client.websocketUrl(`/api/v1/sandboxes/${this.id}/contexts/${contextId}/ws`);
+        const headers = await this.client.wsHeaders();
+        const socket = new WebSocketClient(wsUrl, { headers });
+        return new ContextStream(socket, this.id, contextId);
+    }
+    async ensureReplContext(language, options) {
+        if (options?.contextId) {
+            return options.contextId;
+        }
+        const normalized = language.trim() || "python";
+        const cached = this.replContextByLang.get(normalized);
+        if (cached) {
+            return cached;
+        }
+        const request = {
+            type: models.ProcessType.Repl,
+            repl: { language: normalized },
+            cwd: options?.cwd,
+            envVars: options?.envVars,
+            ptySize: buildPty(options?.ptyRows, options?.ptyCols),
+            idleTimeoutSec: options?.idleTimeoutSec,
+            ttlSec: options?.ttlSec,
+        };
+        const response = await this.createContext(request);
+        this.replContextByLang.set(normalized, response.id);
+        return response.id;
+    }
+}
+function buildPty(rows, cols) {
+    if (rows === undefined || cols === undefined) {
+        return undefined;
+    }
+    if (rows <= 0 || cols <= 0) {
+        throw new APIError({
+            statusCode: 0,
+            code: "invalid_argument",
+            message: "pty rows and cols must be > 0",
+        });
+    }
+    return { rows, cols };
+}
+function parseCommand(input) {
+    return split(input);
+}
+function normalizeReplInput(input) {
+    // Ensure REPL input is terminated so the backend executes the final line.
+    return input.endsWith("\n") ? input : `${input}\n`;
+}
+function normalizeStreamInput(input) {
+    const normalized = {
+        type: input.type ?? "input",
+        data: input.data,
+        rows: input.rows,
+        cols: input.cols,
+        signal: input.signal,
+        requestId: input.requestId,
+    };
+    if (normalized.type === "input" && !normalized.requestId) {
+        normalized.requestId = generateRequestId();
+    }
+    if (normalized.type === "resize") {
+        if (!normalized.rows || !normalized.cols) {
+            throw new APIError({
+                statusCode: 0,
+                code: "invalid_argument",
+                message: "resize rows and cols must be > 0",
+            });
+        }
+    }
+    if (normalized.type === "signal") {
+        if (!normalized.signal?.trim()) {
+            throw new APIError({
+                statusCode: 0,
+                code: "invalid_argument",
+                message: "signal is required",
+            });
+        }
+    }
+    return normalized;
+}
+function parseWsMessage(data) {
+    try {
+        let text;
+        if (typeof data === "string") {
+            text = data;
+        }
+        else if (Buffer.isBuffer(data)) {
+            text = data.toString("utf-8");
+        }
+        else if (Array.isArray(data)) {
+            text = Buffer.concat(data).toString("utf-8");
+        }
+        else if (data instanceof ArrayBuffer) {
+            text = Buffer.from(data).toString("utf-8");
+        }
+        else {
+            text = Buffer.from(data).toString("utf-8");
+        }
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+let requestCounter = 0;
+function generateRequestId() {
+    requestCounter += 1;
+    return `req-${Date.now()}-${requestCounter}`;
+}

package/dist/sandbox_contexts.d.ts

@@ -0,0 +1,16 @@
+import type { ContextExecResponse, ContextResponse, ContextStatsResponse, CreateContextRequest, SuccessDeletedResponse, SuccessResizedResponse, SuccessSignaledResponse, SuccessWrittenResponse } from "./apispec/src/models/index";
+declare module "./sandbox" {
+    interface Sandbox {
+        listContexts(): Promise<ContextResponse[]>;
+        createContext(request: CreateContextRequest): Promise<ContextResponse>;
+        getContext(contextId: string): Promise<ContextResponse>;
+        deleteContext(contextId: string): Promise<SuccessDeletedResponse>;
+        restartContext(contextId: string): Promise<ContextResponse>;
+        contextInput(contextId: string, input: string): Promise<SuccessWrittenResponse>;
+        contextExec(contextId: string, input: string): Promise<ContextExecResponse>;
+        contextResize(contextId: string, rows: number, cols: number): Promise<SuccessResizedResponse>;
+        contextSignal(contextId: string, signal: string): Promise<SuccessSignaledResponse>;
+        contextStats(contextId: string): Promise<ContextStatsResponse>;
+    }
+}
+//# sourceMappingURL=sandbox_contexts.d.ts.map

package/dist/sandbox_contexts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox_contexts.d.ts","sourceRoot":"","sources":["../src/sandbox_contexts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EAGpB,sBAAsB,EACtB,sBAAsB,EACtB,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,4BAA4B,CAAC;AAUpC,OAAO,QAAQ,WAAW,CAAC;IACzB,UAAU,OAAO;QACf,YAAY,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;QAC3C,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;QACvE,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;QACxD,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;QAClE,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;QAC5D,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;QAChF,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;QAC5E,aAAa,CACX,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,sBAAsB,CAAC,CAAC;QACnC,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;QACnF,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;KAChE;CACF"}

package/dist/sandbox_contexts.js

@@ -0,0 +1,95 @@
+import { APIError, wrapApiCall } from "./errors";
+import { ensureData, ensureModel } from "./response";
+import { Sandbox } from "./sandbox";
+function getClient(sandbox) {
+    return sandbox.client;
+}
+Sandbox.prototype.listContexts = async function () {
+    const client = getClient(this);
+    const response = await wrapApiCall(() => client.apispec.contexts.apiV1SandboxesIdContextsGet({ id: this.id }));
+    const data = ensureData(response, "list contexts returned empty response");
+    return data.contexts ?? [];
+};
+Sandbox.prototype.createContext = async function (request) {
+    const client = getClient(this);
+    const response = await wrapApiCall(() => client.apispec.contexts.apiV1SandboxesIdContextsPost({
+        id: this.id,
+        createContextRequest: request,
+    }));
+    return ensureData(response, "create context returned empty response");
+};
+Sandbox.prototype.getContext = async function (contextId) {
+    const client = getClient(this);
+    const response = await wrapApiCall(() => client.apispec.contexts.apiV1SandboxesIdContextsCtxIdGet({
+        id: this.id,
+        ctxId: contextId,
+    }));
+    return ensureData(response, "get context returned empty response");
+};
+Sandbox.prototype.deleteContext = async function (contextId) {
+    const client = getClient(this);
+    const response = await wrapApiCall(() => client.apispec.contexts.apiV1SandboxesIdContextsCtxIdDelete({
+        id: this.id,
+        ctxId: contextId,
+    }));
+    return ensureModel(response, "delete context returned empty response");
+};
+Sandbox.prototype.restartContext = async function (contextId) {
+    const client = getClient(this);
+    const response = await wrapApiCall(() => client.apispec.contexts.apiV1SandboxesIdContextsCtxIdRestartPost({
+        id: this.id,
+        ctxId: contextId,
+    }));
+    return ensureData(response, "restart context returned empty response");
+};
+Sandbox.prototype.contextInput = async function (contextId, input) {
+    const client = getClient(this);
+    const response = await wrapApiCall(() => client.apispec.contexts.apiV1SandboxesIdContextsCtxIdInputPost({
+        id: this.id,
+        ctxId: contextId,
+        contextInputRequest: { data: input },
+    }));
+    return ensureModel(response, "context input returned empty response");
+};
+Sandbox.prototype.contextExec = async function (contextId, input) {
+    const client = getClient(this);
+    const response = await wrapApiCall(() => client.apispec.contexts.apiV1SandboxesIdContextsCtxIdExecPost({
+        id: this.id,
+        ctxId: contextId,
+        contextInputRequest: { data: input },
+    }));
+    return ensureData(response, "context exec returned empty response");
+};
+Sandbox.prototype.contextResize = async function (contextId, rows, cols) {
+    if (rows <= 0 || cols <= 0) {
+        throw new APIError({
+            statusCode: 0,
+            code: "invalid_argument",
+            message: "rows and cols must be > 0",
+        });
+    }
+    const client = getClient(this);
+    const response = await wrapApiCall(() => client.apispec.contexts.apiV1SandboxesIdContextsCtxIdResizePost({
+        id: this.id,
+        ctxId: contextId,
+        resizeContextRequest: { rows, cols },
+    }));
+    return ensureModel(response, "context resize returned empty response");
+};
+Sandbox.prototype.contextSignal = async function (contextId, signal) {
+    const client = getClient(this);
+    const response = await wrapApiCall(() => client.apispec.contexts.apiV1SandboxesIdContextsCtxIdSignalPost({
+        id: this.id,
+        ctxId: contextId,
+        signalContextRequest: { signal },
+    }));
+    return ensureModel(response, "context signal returned empty response");
+};
+Sandbox.prototype.contextStats = async function (contextId) {
+    const client = getClient(this);
+    const response = await wrapApiCall(() => client.apispec.contexts.apiV1SandboxesIdContextsCtxIdStatsGet({
+        id: this.id,
+        ctxId: contextId,
+    }));
+    return ensureData(response, "context stats returned empty response");
+};

package/dist/sandbox_exposed_ports.d.ts

@@ -0,0 +1,11 @@
+import type { ExposedPort, ExposedPortsResponse } from "./models";
+declare module "./sandbox" {
+    interface Sandbox {
+        getExposedPorts(): Promise<ExposedPortsResponse>;
+        updateExposedPorts(ports: ExposedPort[]): Promise<ExposedPortsResponse>;
+        exposePort(port: number, resume: boolean): Promise<ExposedPortsResponse>;
+        unexposePort(port: number): Promise<ExposedPortsResponse>;
+        clearExposedPorts(): Promise<void>;
+    }
+}
+//# sourceMappingURL=sandbox_exposed_ports.d.ts.map

package/dist/sandbox_exposed_ports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox_exposed_ports.d.ts","sourceRoot":"","sources":["../src/sandbox_exposed_ports.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAOlE,OAAO,QAAQ,WAAW,CAAC;IACzB,UAAU,OAAO;QACf,eAAe,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAAC;QACjD,kBAAkB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;QACxE,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;QACzE,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;QAC1D,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;KACpC;CACF"}

package/dist/sandbox_exposed_ports.js

@@ -0,0 +1,66 @@
+import { wrapApiCall } from "./errors";
+import { ensureData } from "./response";
+import { Sandbox } from "./sandbox";
+function getClient(sandbox) {
+    return sandbox.client;
+}
+Sandbox.prototype.getExposedPorts = async function () {
+    const client = getClient(this);
+    const response = await wrapApiCall(() => client.apispec.sandboxes.apiV1SandboxesIdExposedPortsGet({ id: this.id }));
+    const data = ensureData(response, "get exposed ports returned empty response");
+    return toExposedPortsResponse(data);
+};
+Sandbox.prototype.updateExposedPorts = async function (ports) {
+    const client = getClient(this);
+    const request = {
+        ports: ports.map((port) => ({ port: port.port, resume: port.resume })),
+    };
+    const response = await wrapApiCall(() => client.apispec.sandboxes.apiV1SandboxesIdExposedPortsPut({
+        id: this.id,
+        updateExposedPortsRequest: request,
+    }));
+    const data = ensureData(response, "update exposed ports returned empty response");
+    return toExposedPortsResponse(data);
+};
+Sandbox.prototype.exposePort = async function (port, resume) {
+    const current = await this.getExposedPorts();
+    const updated = [];
+    let replaced = false;
+    for (const item of current.ports) {
+        if (item.port === port) {
+            updated.push({ ...item, resume });
+            replaced = true;
+        }
+        else {
+            updated.push(item);
+        }
+    }
+    if (!replaced) {
+        updated.push({ port, resume });
+    }
+    return this.updateExposedPorts(updated);
+};
+Sandbox.prototype.unexposePort = async function (port) {
+    const client = getClient(this);
+    const response = await wrapApiCall(() => client.apispec.sandboxes.apiV1SandboxesIdExposedPortsPortDelete({
+        id: this.id,
+        port,
+    }));
+    const data = ensureData(response, "unexpose port returned empty response");
+    return toExposedPortsResponse(data);
+};
+Sandbox.prototype.clearExposedPorts = async function () {
+    const client = getClient(this);
+    await wrapApiCall(() => client.apispec.sandboxes.apiV1SandboxesIdExposedPortsDelete({ id: this.id }));
+};
+function toExposedPortsResponse(data) {
+    const ports = (data.exposedPorts ?? []).map((item) => ({
+        port: item.port,
+        resume: item.resume,
+        publicUrl: item.publicUrl ?? undefined,
+    }));
+    return {
+        ports,
+        exposureDomain: data.exposureDomain ?? undefined,
+    };
+}

package/dist/sandbox_files.d.ts

@@ -0,0 +1,14 @@
+import type { FileInfo, SuccessCreatedResponse, SuccessDeletedResponse, SuccessMovedResponse, SuccessWrittenResponse } from "./apispec/src/models/index";
+declare module "./sandbox" {
+    interface Sandbox {
+        readFile(path: string): Promise<Uint8Array>;
+        statFile(path: string): Promise<FileInfo>;
+        listFiles(path: string): Promise<FileInfo[]>;
+        writeFile(path: string, data: Uint8Array | string): Promise<SuccessWrittenResponse>;
+        mkdir(path: string, recursive?: boolean): Promise<SuccessCreatedResponse>;
+        deleteFile(path: string): Promise<SuccessDeletedResponse>;
+        moveFile(source: string, destination: string): Promise<SuccessMovedResponse>;
+        watchFiles(path: string, recursive?: boolean): Promise<FileWatchStream>;
+    }
+}
+//# sourceMappingURL=sandbox_files.d.ts.map

package/dist/sandbox_files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox_files.d.ts","sourceRoot":"","sources":["../src/sandbox_files.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,QAAQ,EAER,sBAAsB,EACtB,sBAAsB,EAEtB,oBAAoB,EACpB,sBAAsB,EACvB,MAAM,4BAA4B,CAAC;AAYpC,OAAO,QAAQ,WAAW,CAAC;IACzB,UAAU,OAAO;QACf,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;QAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC1C,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC7C,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;QACpF,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;QAC1E,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;QAC1D,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;QAC7E,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;KACzE;CACF"}