@bolt-foundry/gambit 0.8.6-rc.2 → 0.8.6-rc.4

package/esm/src/server/workspace/schema.d.ts

@@ -0,0 +1,35 @@
+import type { LoadedDeck } from "@bolt-foundry/gambit-core";
+import type { ZodTypeAny } from "zod";
+import type { DeckToolDescription, NormalizedSchema, PersistedAssistantDeck, SchemaDescription } from "../../server_types.js";
+export declare const GAMBIT_BOT_SOURCE_DECK_PATH: string;
+export declare const GAMBIT_BOT_POLICY_DIR: string;
+export declare function ensureGambitPolicyInBotRoot(root: string): Promise<void>;
+export declare function describeDeckInputSchemaFromPath(deckPath: string, logger?: {
+    warn: (...args: Array<unknown>) => void;
+}): Promise<SchemaDescription>;
+export declare function mapDeckTools(actionDecks?: Array<{
+    name?: string;
+    label?: string;
+    description?: string;
+    path?: string;
+}>): Array<DeckToolDescription> | undefined;
+export declare function describeZodSchema(schema?: ZodTypeAny): SchemaDescription;
+export declare function schemaHasField(schema: NormalizedSchema | undefined, field: string): boolean;
+export declare function normalizeSchema(schema?: ZodTypeAny): NormalizedSchema | undefined;
+export declare function cloneValue<T>(value: T): T;
+export declare function resolveDeckPath(p: string): string;
+export declare function deriveInitialFromSchema(schema?: NormalizedSchema): unknown;
+export declare function findMissingRequiredFields(schema: NormalizedSchema | undefined, value: unknown, prefix?: Array<string>): Array<string>;
+export declare function buildInitFillPrompt(args: {
+    missing: Array<string>;
+    current: unknown;
+    schema: NormalizedSchema | undefined;
+}): string;
+export declare function unwrapRespondPayload(output: unknown): unknown;
+export declare function parseInitFillOutput(output: unknown): {
+    data?: unknown;
+    error?: string;
+};
+export declare function validateInitInput(schema: ZodTypeAny | undefined, value: unknown): any;
+export declare function buildPersistedAssistantDeck(deck: LoadedDeck): PersistedAssistantDeck;
+//# sourceMappingURL=schema.d.ts.map

package/esm/src/server/workspace/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/src/server/workspace/schema.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAEtC,OAAO,KAAK,EACV,mBAAmB,EACnB,gBAAgB,EAChB,sBAAsB,EACtB,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAO/B,eAAO,MAAM,2BAA2B,QAGhC,CAAC;AAMT,eAAO,MAAM,qBAAqB,QAE5B,CAAC;AAEP,wBAAsB,2BAA2B,CAAC,IAAI,EAAE,MAAM,iBAkB7D;AAED,wBAAsB,+BAA+B,CACnD,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE;IAAE,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI,CAAA;CAAY,GAC5D,OAAO,CAAC,iBAAiB,CAAC,CAW5B;AAED,wBAAgB,YAAY,CAC1B,WAAW,CAAC,EAAE,KAAK,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC,GACD,KAAK,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAoBxC;AAED,wBAAgB,iBAAiB,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,iBAAiB,CASxE;AAED,wBAAgB,cAAc,CAC5B,MAAM,EAAE,gBAAgB,GAAG,SAAS,EACpC,KAAK,EAAE,MAAM,GACZ,OAAO,CAGT;AAED,wBAAgB,eAAe,CAC7B,MAAM,CAAC,EAAE,UAAU,GAClB,gBAAgB,GAAG,SAAS,CAgE9B;AAmED,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAWzC;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CASjD;AA4BD,wBAAgB,uBAAuB,CACrC,MAAM,CAAC,EAAE,gBAAgB,GACxB,OAAO,CA0BT;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,gBAAgB,GAAG,SAAS,EACpC,KAAK,EAAE,OAAO,EACd,MAAM,GAAE,KAAK,CAAC,MAAM,CAAM,GACzB,KAAK,CAAC,MAAM,CAAC,CA6Cf;AAcD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACxC,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,gBAAgB,GAAG,SAAS,CAAC;CACtC,GAAG,MAAM,CAyBT;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAO7D;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,OAAO,GACd;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAsBpC;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,UAAU,GAAG,SAAS,EAC9B,KAAK,EAAE,OAAO,OAef;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,UAAU,GACf,sBAAsB,CAexB"}

package/esm/src/server/workspace/schema.js

@@ -0,0 +1,427 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import * as path from "../../../deps/jsr.io/@std/path/1.1.4/mod.js";
+import { copy, ensureDir, existsSync } from "../../../deps/jsr.io/@std/fs/1.0.23/mod.js";
+import { loadDeck } from "@bolt-foundry/gambit-core";
+import { resolveDefaultValue } from "../../server_helpers.js";
+const GAMBIT_BOT_SOURCE_DECK_URL = new URL("../../decks/gambit-bot/PROMPT.md", globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).url);
+export const GAMBIT_BOT_SOURCE_DECK_PATH = GAMBIT_BOT_SOURCE_DECK_URL.protocol === "file:"
+    ? path.fromFileUrl(GAMBIT_BOT_SOURCE_DECK_URL)
+    : "";
+const GAMBIT_BOT_SOURCE_DIR = GAMBIT_BOT_SOURCE_DECK_URL.protocol === "file:"
+    ? path.dirname(path.fromFileUrl(GAMBIT_BOT_SOURCE_DECK_URL))
+    : "";
+export const GAMBIT_BOT_POLICY_DIR = GAMBIT_BOT_SOURCE_DIR
+    ? path.join(GAMBIT_BOT_SOURCE_DIR, "policy")
+    : "";
+export async function ensureGambitPolicyInBotRoot(root) {
+    if (!GAMBIT_BOT_POLICY_DIR)
+        return;
+    try {
+        const info = await dntShim.Deno.stat(GAMBIT_BOT_POLICY_DIR);
+        if (!info.isDirectory)
+            return;
+    }
+    catch {
+        return;
+    }
+    const dest = path.join(root, ".gambit", "policy");
+    if (existsSync(dest))
+        return;
+    await ensureDir(path.dirname(dest));
+    try {
+        await copy(GAMBIT_BOT_POLICY_DIR, dest, { overwrite: false });
+    }
+    catch (err) {
+        if (!(err instanceof dntShim.Deno.errors.AlreadyExists)) {
+            throw err;
+        }
+    }
+}
+export async function describeDeckInputSchemaFromPath(deckPath, logger = console) {
+    try {
+        const deck = await loadDeck(deckPath);
+        const tools = mapDeckTools(deck.actionDecks);
+        const desc = describeZodSchema(deck.inputSchema);
+        return tools ? { ...desc, tools } : desc;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger.warn(`[sim] failed to load deck schema: ${message}`);
+        return { error: message };
+    }
+}
+export function mapDeckTools(actionDecks) {
+    if (!Array.isArray(actionDecks) || actionDecks.length === 0) {
+        return undefined;
+    }
+    const described = actionDecks
+        .filter((action) => Boolean(action?.name && typeof action.name === "string"))
+        .map((action) => ({
+        name: action.name,
+        label: typeof action.label === "string" ? action.label : undefined,
+        description: typeof action.description === "string"
+            ? action.description
+            : undefined,
+        path: action.path,
+    }));
+    return described.length > 0 ? described : undefined;
+}
+export function describeZodSchema(schema) {
+    try {
+        const normalized = normalizeSchema(schema);
+        const defaults = normalized ? materializeDefaults(normalized) : undefined;
+        return { schema: normalized, defaults };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { error: message };
+    }
+}
+export function schemaHasField(schema, field) {
+    return schema?.kind === "object" &&
+        Boolean(schema.fields && schema.fields[field]);
+}
+export function normalizeSchema(schema) {
+    if (!schema)
+        return undefined;
+    const unwrapped = unwrapSchema(schema);
+    const core = unwrapped.schema;
+    if (!core || typeof core !== "object")
+        return undefined;
+    const meta = {
+        optional: unwrapped.optional,
+        description: readDescription(schema) ?? readDescription(core),
+        example: readExample(schema) ?? readExample(core),
+        defaultValue: unwrapped.defaultValue,
+    };
+    const typeName = core._def?.typeName;
+    switch (typeName) {
+        case "ZodString":
+            return { kind: "string", ...meta };
+        case "ZodNumber":
+            return { kind: "number", ...meta };
+        case "ZodBoolean":
+            return { kind: "boolean", ...meta };
+        case "ZodEnum": {
+            const values = core._def.values;
+            return { kind: "enum", enumValues: [...values], ...meta };
+        }
+        case "ZodNativeEnum": {
+            const values = core._def
+                .values;
+            return { kind: "enum", enumValues: Object.values(values), ...meta };
+        }
+        case "ZodLiteral": {
+            const value = core._def.value;
+            const defaultValue = meta.defaultValue !== undefined
+                ? meta.defaultValue
+                : value;
+            const { defaultValue: _m, ...restMeta } = meta;
+            return {
+                kind: "enum",
+                enumValues: [value],
+                ...restMeta,
+                defaultValue,
+            };
+        }
+        case "ZodArray": {
+            const items = core._def.type;
+            return {
+                kind: "array",
+                items: normalizeSchema(items),
+                ...meta,
+            };
+        }
+        case "ZodObject": {
+            const fields = {};
+            const shape = core
+                ._def.shape();
+            for (const [key, child] of Object.entries(shape)) {
+                const normalized = normalizeSchema(child);
+                if (normalized)
+                    fields[key] = normalized;
+            }
+            return { kind: "object", fields, ...meta };
+        }
+        default:
+            return { kind: "unknown", ...meta };
+    }
+}
+function unwrapSchema(schema) {
+    let current = schema;
+    let optional = false;
+    let defaultValue;
+    while (current && typeof current === "object") {
+        const def = current
+            ._def;
+        const typeName = def?.typeName;
+        if (typeName === "ZodOptional" || typeName === "ZodNullable") {
+            optional = true;
+            current = def.innerType;
+            continue;
+        }
+        if (typeName === "ZodDefault") {
+            if (defaultValue === undefined) {
+                defaultValue = resolveDefaultValue(def.defaultValue);
+            }
+            current = def.innerType;
+            continue;
+        }
+        if (typeName === "ZodEffects") {
+            current = def.schema;
+            continue;
+        }
+        if (typeName === "ZodCatch") {
+            current = def.innerType;
+            continue;
+        }
+        if (typeName === "ZodBranded") {
+            current = def.type;
+            continue;
+        }
+        break;
+    }
+    return { schema: current, optional, defaultValue };
+}
+function readDescription(schema) {
+    const def = schema && typeof schema === "object"
+        ? schema._def
+        : undefined;
+    return typeof def?.description === "string" ? def.description : undefined;
+}
+function readExample(schema) {
+    const def = schema && typeof schema === "object"
+        ? schema._def
+        : undefined;
+    if (!def)
+        return undefined;
+    const direct = def.example ?? def.examples;
+    if (direct !== undefined)
+        return direct;
+    const openapi = def.openapi;
+    if (openapi?.example !== undefined)
+        return openapi.example;
+    return undefined;
+}
+export function cloneValue(value) {
+    try {
+        // @ts-ignore structuredClone is available in Deno
+        return structuredClone(value);
+    }
+    catch {
+        try {
+            return JSON.parse(JSON.stringify(value));
+        }
+        catch {
+            return value;
+        }
+    }
+}
+export function resolveDeckPath(p) {
+    const absolutePath = path.isAbsolute(p) ? p : path.resolve(p);
+    try {
+        const url = globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).resolve(path.toFileUrl(absolutePath).href);
+        if (url.startsWith("file:"))
+            return path.fromFileUrl(url);
+        return url;
+    }
+    catch {
+        return absolutePath;
+    }
+}
+function materializeDefaults(schema) {
+    if (!schema)
+        return undefined;
+    if (schema.defaultValue !== undefined)
+        return cloneValue(schema.defaultValue);
+    if (schema.example !== undefined)
+        return cloneValue(schema.example);
+    switch (schema.kind) {
+        case "object": {
+            const out = {};
+            for (const [key, child] of Object.entries(schema.fields ?? {})) {
+                const value = materializeDefaults(child);
+                if (value !== undefined)
+                    out[key] = value;
+            }
+            return Object.keys(out).length ? out : undefined;
+        }
+        case "array": {
+            if (schema.items) {
+                const item = materializeDefaults(schema.items);
+                if (item !== undefined)
+                    return [item];
+            }
+            return undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+export function deriveInitialFromSchema(schema) {
+    if (!schema)
+        return undefined;
+    if (schema.defaultValue !== undefined)
+        return cloneValue(schema.defaultValue);
+    if (schema.example !== undefined)
+        return cloneValue(schema.example);
+    switch (schema.kind) {
+        case "object": {
+            const out = {};
+            for (const [key, child] of Object.entries(schema.fields ?? {})) {
+                const value = deriveInitialFromSchema(child);
+                if (value !== undefined)
+                    out[key] = value;
+            }
+            return out;
+        }
+        case "array": {
+            if (schema.items) {
+                const item = deriveInitialFromSchema(schema.items);
+                if (item !== undefined)
+                    return [item];
+            }
+            return [];
+        }
+        case "boolean":
+            return false;
+        default:
+            return undefined;
+    }
+}
+export function findMissingRequiredFields(schema, value, prefix = []) {
+    if (!schema)
+        return [];
+    if (schema.optional)
+        return [];
+    if (schema.kind === "object" && schema.fields) {
+        if (value !== undefined && value !== null &&
+            (typeof value !== "object" || Array.isArray(value))) {
+            return [];
+        }
+        const asObj = value && typeof value === "object"
+            ? value
+            : undefined;
+        const missing = [];
+        for (const [key, child] of Object.entries(schema.fields)) {
+            missing.push(...findMissingRequiredFields(child, asObj ? asObj[key] : undefined, [...prefix, key]));
+        }
+        return missing;
+    }
+    const key = prefix.join(".") || "(root)";
+    if (value === undefined || value === null) {
+        return schema.defaultValue !== undefined ? [] : [key];
+    }
+    if (schema.kind === "string" || schema.kind === "enum") {
+        return typeof value === "string" && value.trim() === "" ? [key] : [];
+    }
+    if (schema.kind === "array") {
+        return Array.isArray(value) && value.length === 0 ? [key] : [];
+    }
+    if (schema.kind === "number") {
+        return typeof value === "number" && Number.isFinite(value) ? [] : [key];
+    }
+    if (schema.kind === "boolean") {
+        return typeof value === "boolean" ? [] : [key];
+    }
+    return [];
+}
+function getSchemaAtPath(schema, pathSegments) {
+    let current = schema;
+    for (const segment of pathSegments) {
+        if (!current || current.kind !== "object" || !current.fields)
+            return;
+        current = current.fields[segment];
+    }
+    return current;
+}
+export function buildInitFillPrompt(args) {
+    const schemaHints = args.missing.map((path) => {
+        const segments = path === "(root)" ? [] : path.split(".");
+        const leaf = getSchemaAtPath(args.schema, segments);
+        return {
+            path,
+            kind: leaf?.kind,
+            description: leaf?.description,
+            enumValues: leaf?.enumValues,
+        };
+    });
+    const payload = {
+        type: "gambit_test_bot_init_fill",
+        missing: args.missing,
+        current: args.current ?? null,
+        schemaHints,
+    };
+    return [
+        "You are filling missing required init fields for a Gambit Scenario run.",
+        "Return ONLY valid JSON that includes values for the missing fields.",
+        "Do not include any fields that are not listed as missing.",
+        "If the only missing path is '(root)', return the full init JSON value.",
+        "",
+        JSON.stringify(payload, null, 2),
+    ].join("\n");
+}
+export function unwrapRespondPayload(output) {
+    if (!output || typeof output !== "object")
+        return output;
+    const record = output;
+    if ("payload" in record) {
+        return record.payload;
+    }
+    return output;
+}
+export function parseInitFillOutput(output) {
+    if (output === null || output === undefined) {
+        return { error: "Persona returned empty init fill output." };
+    }
+    if (typeof output === "object") {
+        return { data: unwrapRespondPayload(output) };
+    }
+    if (typeof output === "string") {
+        const text = output.trim();
+        if (!text)
+            return { error: "Persona returned empty init fill output." };
+        try {
+            const parsed = JSON.parse(text);
+            return { data: unwrapRespondPayload(parsed) };
+        }
+        catch (err) {
+            return {
+                error: `Persona returned invalid JSON for init fill: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+    return { error: "Persona returned unsupported init fill output." };
+}
+export function validateInitInput(schema, value) {
+    if (!schema)
+        return value;
+    if (typeof schema.safeParse !== "function") {
+        throw new Error("Init schema missing safeParse");
+    }
+    const result = schema.safeParse(value);
+    if (!result.success) {
+        const issue = result.error.issues?.[0];
+        const message = issue
+            ? `${issue.path.join(".") || "(root)"}: ${issue.message}`
+            : result.error.message;
+        throw new Error(`Schema validation failed: ${message}`);
+    }
+    return result.data;
+}
+export function buildPersistedAssistantDeck(deck) {
+    const desc = describeZodSchema(deck.inputSchema);
+    const tools = mapDeckTools(deck.actionDecks);
+    const startMode = deck.startMode === "assistant" || deck.startMode === "user"
+        ? deck.startMode
+        : "assistant";
+    return {
+        deck: deck.path,
+        startMode,
+        modelParams: deck.modelParams ?? undefined,
+        inputSchema: desc.schema,
+        defaults: desc.defaults,
+        tools,
+        inputSchemaError: desc.error,
+    };
+}

package/esm/src/server/workspace/sessions.d.ts

@@ -0,0 +1,38 @@
+import type { SessionMeta } from "../../server_types.js";
+import type { WorkspaceRecord } from "../../server_workspace_runtime.js";
+import type { SavedState } from "@bolt-foundry/gambit-core";
+export declare const createWorkspaceSessionService: (deps: {
+    sessionsRoot: string;
+    workspaceRoot: string;
+    workspaceScaffoldEnabled: boolean;
+    activeWorkspaceOnboarding: boolean;
+    workspaceStateSchemaVersion: string;
+    getResolvedDeckPath: () => string;
+    deckSlugFromPath: (deckPath: string) => string;
+    randomId: (prefix: string) => string;
+    registerWorkspace: (record: WorkspaceRecord) => WorkspaceRecord;
+    resolveWorkspaceRecord: (workspaceId: string) => WorkspaceRecord | null | undefined;
+    readSessionState: (workspaceId: string) => SavedState | undefined;
+    persistSessionState: (state: SavedState) => SavedState;
+}) => {
+    buildWorkspaceMeta: (record: {
+        id: string;
+        rootDir: string;
+        rootDeckPath: string;
+    }, base?: Record<string, unknown>) => Record<string, unknown>;
+    createWorkspaceSession: (options?: {
+        onboarding?: boolean;
+    }) => Promise<WorkspaceRecord>;
+    ensureWorkspaceSession: (workspaceId: string) => WorkspaceRecord;
+    ensurePreconfiguredWorkspaceSession: (workspace?: {
+        id?: string;
+        rootDir?: string;
+        rootDeckPath?: string;
+    }) => void;
+    deleteSessionState: (sessionId: string) => boolean;
+    buildSessionMeta: (sessionId: string, state?: SavedState) => SessionMeta;
+    listSessions: () => Array<SessionMeta>;
+    getWorkspaceIdFromQuery: (url: URL) => string | undefined;
+    getWorkspaceIdFromBody: (body: Record<string, unknown> | null | undefined) => string | undefined;
+};
+//# sourceMappingURL=sessions.d.ts.map

package/esm/src/server/workspace/sessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../../../src/src/server/workspace/sessions.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAoB,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE5D,eAAO,MAAM,6BAA6B,GAAI,MAAM;IAClD,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,wBAAwB,EAAE,OAAO,CAAC;IAClC,yBAAyB,EAAE,OAAO,CAAC;IACnC,2BAA2B,EAAE,MAAM,CAAC;IACpC,mBAAmB,EAAE,MAAM,MAAM,CAAC;IAClC,gBAAgB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;IAC/C,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;IACrC,iBAAiB,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,eAAe,CAAC;IAChE,sBAAsB,EAAE,CACtB,WAAW,EAAE,MAAM,KAChB,eAAe,GAAG,IAAI,GAAG,SAAS,CAAC;IACxC,gBAAgB,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,UAAU,GAAG,SAAS,CAAC;IAClE,mBAAmB,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,UAAU,CAAC;CACxD;iCAEW;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,SACtD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;uCA0Bd;QAAE,UAAU,CAAC,EAAE,OAAO,CAAA;KAAE,KACjC,OAAO,CAAC,eAAe,CAAC;0CAuCkB,MAAM,KAAG,eAAe;sDAyBZ;QACvD,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB;oCAuBsC,MAAM,KAAG,OAAO;kCA0B1C,MAAM,UACT,UAAU,KACjB,WAAW;wBAgEW,KAAK,CAAC,WAAW,CAAC;mCAoBL,GAAG,KAAG,MAAM,GAAG,SAAS;mCAItD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,KAC/C,MAAM,GAAG,SAAS;CAgBtB,CAAC"}