@a5c-ai/babysitter-sdk 0.0.16

package/dist/storage/ulids.d.ts

@@ -0,0 +1,11 @@
+export type UlidFactory = () => string;
+export declare function nextUlid(): string;
+/**
+ * Overrides the ULID factory so tests can run with deterministic identifiers.
+ */
+export declare function setUlidFactoryForTests(factory: UlidFactory): void;
+/**
+ * Restores the default monotonic ULID factory.
+ */
+export declare function resetUlidFactory(): void;
+//# sourceMappingURL=ulids.d.ts.map

package/dist/storage/ulids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ulids.d.ts","sourceRoot":"","sources":["../../src/storage/ulids.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,WAAW,GAAG,MAAM,MAAM,CAAC;AAIvC,wBAAgB,QAAQ,WAEvB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,WAAW,QAK1D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,SAE/B"}

package/dist/storage/ulids.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextUlid = nextUlid;
+exports.setUlidFactoryForTests = setUlidFactoryForTests;
+exports.resetUlidFactory = resetUlidFactory;
+const ulid_1 = require("ulid");
+let activeFactory = (0, ulid_1.monotonicFactory)();
+function nextUlid() {
+    return activeFactory();
+}
+/**
+ * Overrides the ULID factory so tests can run with deterministic identifiers.
+ */
+function setUlidFactoryForTests(factory) {
+    if (typeof factory !== "function") {
+        throw new Error("setUlidFactoryForTests requires a function");
+    }
+    activeFactory = factory;
+}
+/**
+ * Restores the default monotonic ULID factory.
+ */
+function resetUlidFactory() {
+    activeFactory = (0, ulid_1.monotonicFactory)();
+}

package/dist/tasks/batching.d.ts

@@ -0,0 +1,29 @@
+import type { EffectAction } from "../runtime/types";
+import type { JsonRecord } from "../storage/types";
+export interface BatchedEffectSummary {
+    effectId: string;
+    invocationKey: string;
+    taskId?: string;
+    stepId?: string;
+    kind: string;
+    label?: string;
+    labels?: string[];
+    taskDefRef?: string;
+    inputsRef?: string;
+    requestedAt?: string;
+    metadata?: JsonRecord;
+}
+export interface ParallelBatch {
+    actions: EffectAction[];
+    summaries: BatchedEffectSummary[];
+}
+export interface ParallelPendingPayload {
+    effects: BatchedEffectSummary[];
+}
+/**
+ * Deduplicates EffectAction entries by effectId while preserving order and builds summaries.
+ */
+export declare function buildParallelBatch(actions: EffectAction[]): ParallelBatch;
+export declare function summarizeEffectAction(action: EffectAction): BatchedEffectSummary;
+export declare function toParallelPendingPayload(batch: ParallelBatch): ParallelPendingPayload;
+//# sourceMappingURL=batching.d.ts.map

package/dist/tasks/batching.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batching.d.ts","sourceRoot":"","sources":["../../src/tasks/batching.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAwB,MAAM,kBAAkB,CAAC;AAC3E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,UAAU,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,SAAS,EAAE,oBAAoB,EAAE,CAAC;CACnC;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,oBAAoB,EAAE,CAAC;CACjC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,aAAa,CAiBzE;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,YAAY,GAAG,oBAAoB,CAchF;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,aAAa,GAAG,sBAAsB,CAIrF"}

package/dist/tasks/batching.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildParallelBatch = buildParallelBatch;
+exports.summarizeEffectAction = summarizeEffectAction;
+exports.toParallelPendingPayload = toParallelPendingPayload;
+const crypto_1 = require("crypto");
+/**
+ * Deduplicates EffectAction entries by effectId while preserving order and builds summaries.
+ */
+function buildParallelBatch(actions) {
+    const seen = new Set();
+    const deduped = [];
+    for (const action of actions) {
+        if (seen.has(action.effectId))
+            continue;
+        seen.add(action.effectId);
+        deduped.push(action);
+    }
+    const annotated = assignParallelGroupHints(deduped);
+    const summaries = annotated.map(summarizeEffectAction);
+    return {
+        actions: annotated,
+        summaries,
+    };
+}
+function summarizeEffectAction(action) {
+    return {
+        effectId: action.effectId,
+        invocationKey: action.invocationKey,
+        taskId: action.taskId,
+        stepId: action.stepId,
+        kind: action.kind,
+        label: action.label,
+        labels: action.labels ? [...action.labels] : undefined,
+        taskDefRef: action.taskDefRef,
+        inputsRef: action.inputsRef,
+        requestedAt: action.requestedAt,
+        metadata: action.taskDef?.metadata,
+    };
+}
+function toParallelPendingPayload(batch) {
+    return {
+        effects: batch.summaries,
+    };
+}
+function assignParallelGroupHints(actions) {
+    if (actions.length <= 1) {
+        return actions;
+    }
+    const hash = (0, crypto_1.createHash)("sha1");
+    actions.forEach((action) => {
+        hash.update(action.invocationKey ?? action.effectId);
+        hash.update("|");
+    });
+    const parallelGroupId = hash.digest("hex").slice(0, 16);
+    return actions.map((action) => ({
+        ...action,
+        schedulerHints: mergeSchedulerHints(action.schedulerHints, { parallelGroupId }),
+    }));
+}
+function mergeSchedulerHints(base, extra) {
+    return {
+        ...(base ?? {}),
+        ...extra,
+    };
+}

package/dist/tasks/context.d.ts

@@ -0,0 +1,11 @@
+import { TaskBuildContext } from "./types";
+export interface CreateTaskBuildContextOptions {
+    runId: string;
+    runDir: string;
+    effectId: string;
+    invocationKey: string;
+    taskId: string;
+    label?: string;
+}
+export declare function createTaskBuildContext(options: CreateTaskBuildContextOptions): TaskBuildContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/tasks/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/tasks/context.ts"],"names":[],"mappings":"AAKA,OAAO,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAO7D,MAAM,WAAW,6BAA6B;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,6BAA6B,GAAG,gBAAgB,CAoC/F"}

package/dist/tasks/context.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskBuildContext = createTaskBuildContext;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const atomic_1 = require("../storage/atomic");
+const paths_1 = require("../storage/paths");
+const DEFAULT_TEXT_ENCODING = "utf8";
+const DEFAULT_JSON_EXTENSION = ".json";
+const MAX_BLOB_BASENAME_LENGTH = 128;
+const HASH_SUFFIX_LENGTH = 10;
+function createTaskBuildContext(options) {
+    const runId = mustBeNonEmpty(options.runId, "runId");
+    const runDir = path_1.default.resolve(mustBeNonEmpty(options.runDir, "runDir"));
+    const effectId = mustBeNonEmpty(options.effectId, "effectId");
+    const invocationKey = mustBeNonEmpty(options.invocationKey, "invocationKey");
+    const taskId = mustBeNonEmpty(options.taskId, "taskId");
+    const tasksRoot = (0, paths_1.getTasksDir)(runDir);
+    const taskDir = path_1.default.join(tasksRoot, effectId);
+    const normalizedLabel = normalizeLabel(options.label);
+    const labels = normalizedLabel ? [normalizedLabel] : [];
+    const ctx = {
+        effectId,
+        invocationKey,
+        taskId,
+        runId,
+        runDir,
+        taskDir,
+        tasksDir: tasksRoot,
+        label: normalizedLabel,
+        labels,
+        async createBlobRef(name, value, blobOptions) {
+            const prepared = prepareBlobContents(value, blobOptions);
+            const blobName = buildBlobFileName(name, prepared.defaultExtension, prepared.contents);
+            const blobDir = path_1.default.join(taskDir, "blobs");
+            await fs_1.promises.mkdir(blobDir, { recursive: true });
+            const blobPath = path_1.default.join(blobDir, blobName);
+            await (0, atomic_1.writeFileAtomic)(blobPath, prepared.contents);
+            return toRunRelative(runDir, blobPath);
+        },
+        toTaskRelativePath(relativePath) {
+            const normalized = normalizeTaskRelativePath(relativePath);
+            const absolute = path_1.default.join(taskDir, normalized);
+            return toRunRelative(runDir, absolute);
+        },
+    };
+    return Object.freeze(ctx);
+}
+function mustBeNonEmpty(value, field) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`TaskBuildContext requires a non-empty ${field}`);
+    }
+    return value.trim();
+}
+function normalizeLabel(label) {
+    if (!label)
+        return undefined;
+    const trimmed = label.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function buildBlobFileName(rawName, defaultExtension, contents) {
+    const safeName = sanitizeBlobName(rawName, defaultExtension);
+    const digest = hashBuffer(contents);
+    return appendDigestSuffix(safeName, digest);
+}
+function sanitizeBlobName(rawName, defaultExtension) {
+    if (typeof rawName !== "string") {
+        throw new Error("Blob name must be a non-empty string");
+    }
+    const trimmed = rawName.trim();
+    if (!trimmed.length) {
+        throw new Error("Blob name must be a non-empty string");
+    }
+    const normalized = trimmed.replace(/[\\/]+/g, "/");
+    const segments = normalized.split("/").filter(Boolean);
+    let safe = segments.join("-").replace(/[^a-zA-Z0-9._-]/g, "-");
+    safe = safe.replace(/-+/g, "-");
+    safe = safe.replace(/^[-.]+/, "").replace(/[-.]+$/, "");
+    if (!safe.length) {
+        throw new Error("Blob name must include alphanumeric characters");
+    }
+    if (defaultExtension && !safe.includes(".")) {
+        const ext = defaultExtension.startsWith(".") ? defaultExtension : `.${defaultExtension}`;
+        safe = `${safe}${ext}`;
+    }
+    return clampBlobName(safe);
+}
+function clampBlobName(name) {
+    if (name.length <= MAX_BLOB_BASENAME_LENGTH) {
+        return name;
+    }
+    const ext = path_1.default.posix.extname(name);
+    const base = ext ? name.slice(0, -ext.length) : name;
+    const available = Math.max(8, MAX_BLOB_BASENAME_LENGTH - ext.length - HASH_SUFFIX_LENGTH - 1);
+    const truncated = base.slice(0, available);
+    const suffix = hashString(name);
+    return ext ? `${truncated}-${suffix}${ext}` : `${truncated}-${suffix}`;
+}
+function appendDigestSuffix(name, digest) {
+    if (!digest)
+        return name;
+    const ext = path_1.default.posix.extname(name);
+    if (!ext) {
+        return `${name}-${digest}`;
+    }
+    return `${name.slice(0, -ext.length)}-${digest}${ext}`;
+}
+function normalizeTaskRelativePath(value) {
+    if (typeof value !== "string") {
+        throw new Error("Relative path must be a string");
+    }
+    const trimmed = value.trim();
+    if (!trimmed.length) {
+        throw new Error("Relative path must be non-empty");
+    }
+    if (path_1.default.isAbsolute(trimmed)) {
+        throw new Error("Task-relative paths must not be absolute");
+    }
+    const replaced = trimmed.replace(/\\/g, "/");
+    const segments = replaced.split("/").filter(Boolean);
+    if (!segments.length) {
+        throw new Error("Relative path must include a filename");
+    }
+    const normalized = [];
+    for (const segment of segments) {
+        if (segment === ".")
+            continue;
+        if (segment === "..") {
+            throw new Error("Task-relative paths cannot traverse above the task directory");
+        }
+        normalized.push(segment);
+    }
+    if (!normalized.length) {
+        throw new Error("Relative path must include a filename");
+    }
+    return normalized.join("/");
+}
+function toRunRelative(runDir, absolutePath) {
+    const relative = path_1.default.relative(runDir, absolutePath);
+    if (!relative || relative.startsWith("..") || path_1.default.isAbsolute(relative)) {
+        throw new Error(`Path ${absolutePath} is not inside run directory ${runDir}`);
+    }
+    return relative.split(path_1.default.sep).join("/");
+}
+function hashString(value) {
+    return crypto_1.default.createHash("sha1").update(value).digest("hex").slice(0, HASH_SUFFIX_LENGTH);
+}
+function hashBuffer(contents) {
+    return crypto_1.default.createHash("sha256").update(contents).digest("hex");
+}
+function prepareBlobContents(value, options) {
+    const treatAsJson = shouldSerializeAsJson(value, options);
+    if (typeof value === "string" && !treatAsJson) {
+        const encoding = options?.encoding ?? DEFAULT_TEXT_ENCODING;
+        return {
+            contents: Buffer.from(value, encoding),
+        };
+    }
+    if (Buffer.isBuffer(value) && !treatAsJson) {
+        return {
+            contents: value,
+        };
+    }
+    const normalizedValue = value === undefined ? null : value;
+    const serialized = JSON.stringify(normalizedValue, null, 2) ?? "null";
+    const withNewline = serialized.endsWith("\n") ? serialized : `${serialized}\n`;
+    return {
+        contents: Buffer.from(withNewline, DEFAULT_TEXT_ENCODING),
+        defaultExtension: DEFAULT_JSON_EXTENSION,
+    };
+}
+function shouldSerializeAsJson(value, options) {
+    if (options?.asJson !== undefined) {
+        return options.asJson;
+    }
+    return !(typeof value === "string" || Buffer.isBuffer(value));
+}

package/dist/tasks/defineTask.d.ts

@@ -0,0 +1,9 @@
+import { DefinedTask, TaskImpl } from "./types";
+export interface DefineTaskOptions {
+    description?: string;
+    labels?: string[];
+    kind?: string;
+    source?: string;
+}
+export declare function defineTask<TArgs = unknown, TResult = unknown>(id: string, impl: TaskImpl<TArgs, TResult>, options?: DefineTaskOptions): DefinedTask<TArgs, TResult>;
+//# sourceMappingURL=defineTask.d.ts.map

package/dist/tasks/defineTask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineTask.d.ts","sourceRoot":"","sources":["../../src/tasks/defineTask.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAA6B,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE3E,MAAM,WAAW,iBAAiB;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,UAAU,CAAC,KAAK,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,EAC3D,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,EAC9B,OAAO,GAAE,iBAAsB,GAC9B,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,CAoB7B"}

package/dist/tasks/defineTask.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineTask = defineTask;
+const registry_1 = require("./registry");
+function defineTask(id, impl, options = {}) {
+    const taskId = normalizeTaskId(id);
+    registerTaskId(taskId, options);
+    const defined = {
+        id: taskId,
+        async build(args, ctx) {
+            const taskDef = await Promise.resolve(impl(args, ctx));
+            const normalized = normalizeTaskDef(taskDef);
+            const mergedLabels = [...(options.labels ?? []), ...(normalized.labels ?? [])];
+            registry_1.globalTaskRegistry.recordDefinitionMetadata(taskId, {
+                kind: normalized.kind,
+                description: normalized.description ?? options.description,
+                labels: mergedLabels,
+            });
+            return normalized;
+        },
+    };
+    return Object.freeze(defined);
+}
+function registerTaskId(taskId, options) {
+    try {
+        registry_1.globalTaskRegistry.registerDefinition({
+            id: taskId,
+            kind: options.kind,
+            description: options.description,
+            labels: options.labels ?? [],
+            source: options.source,
+        });
+    }
+    catch (error) {
+        if (error instanceof registry_1.DuplicateTaskIdError) {
+            throw error;
+        }
+        throw new registry_1.DuplicateTaskIdError(taskId);
+    }
+}
+function normalizeTaskId(id) {
+    if (typeof id !== "string" || !id.trim()) {
+        throw new Error("defineTask requires a non-empty string id");
+    }
+    return id.trim();
+}
+function normalizeTaskDef(taskDef) {
+    if (!taskDef || typeof taskDef !== "object") {
+        throw new Error("Task implementations must return a TaskDef object");
+    }
+    const labels = Array.isArray(taskDef.labels)
+        ? taskDef.labels.filter((label) => typeof label === "string" && Boolean(label.trim()))
+        : undefined;
+    if (labels) {
+        taskDef.labels = Array.from(new Set(labels.map((label) => label.trim())));
+    }
+    return taskDef;
+}

package/dist/tasks/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./defineTask";
+export * from "./context";
+export * from "./serializer";
+export * from "./registry";
+export * from "./types";
+export * from "./kinds";
+export * from "./batching";
+//# sourceMappingURL=index.d.ts.map

package/dist/tasks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tasks/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC"}

package/dist/tasks/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./defineTask"), exports);
+__exportStar(require("./context"), exports);
+__exportStar(require("./serializer"), exports);
+__exportStar(require("./registry"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./kinds"), exports);
+__exportStar(require("./batching"), exports);

package/dist/tasks/kinds/index.d.ts

@@ -0,0 +1,7 @@
+import { JsonRecord } from "../../storage/types";
+import { BreakpointTaskDefinitionOptions, DefinedTask, NodeTaskDefinitionOptions, OrchestratorTaskDefinitionOptions, SleepTaskBuilderArgs, SleepTaskDefinitionOptions } from "../types";
+export declare function nodeTask<TArgs = unknown, TResult = unknown>(id: string, options: NodeTaskDefinitionOptions<TArgs>): DefinedTask<TArgs, TResult>;
+export declare function breakpointTask<TArgs = unknown, TResult = void>(id: string, options?: BreakpointTaskDefinitionOptions<TArgs>): DefinedTask<TArgs, TResult>;
+export declare function orchestratorTask<TArgs = JsonRecord, TResult = unknown>(id: string, options?: OrchestratorTaskDefinitionOptions<TArgs>): DefinedTask<TArgs, TResult>;
+export declare function sleepTask<TArgs extends SleepTaskBuilderArgs = SleepTaskBuilderArgs>(id?: string, options?: SleepTaskDefinitionOptions<TArgs>): DefinedTask<TArgs, void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/tasks/kinds/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tasks/kinds/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,EACL,+BAA+B,EAE/B,WAAW,EACX,yBAAyB,EAEzB,iCAAiC,EAEjC,oBAAoB,EACpB,0BAA0B,EAK3B,MAAM,UAAU,CAAC;AAUlB,wBAAgB,QAAQ,CAAC,KAAK,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,EACzD,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,yBAAyB,CAAC,KAAK,CAAC,GACxC,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,CAiD7B;AAED,wBAAgB,cAAc,CAAC,KAAK,GAAG,OAAO,EAAE,OAAO,GAAG,IAAI,EAC5D,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,+BAA+B,CAAC,KAAK,CAAM,GACnD,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,CA4B7B;AAED,wBAAgB,gBAAgB,CAAC,KAAK,GAAG,UAAU,EAAE,OAAO,GAAG,OAAO,EACpE,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,iCAAiC,CAAC,KAAK,CAAM,GACrD,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,CA8B7B;AAED,wBAAgB,SAAS,CAAC,KAAK,SAAS,oBAAoB,GAAG,oBAAoB,EACjF,EAAE,SAAwB,EAC1B,OAAO,GAAE,0BAA0B,CAAC,KAAK,CAAM,GAC9C,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,CAoC1B"}