@aigne/agent-runtime 1.12.0-beta.5

package/dist/program/agent-action.cjs

@@ -0,0 +1,496 @@
+const require_index = require('../providers/basic/ash/dist/index.cjs');
+const require_dot_path_resolver = require('./tool-discovery/dot-path-resolver.cjs');
+const require_guide_rails = require('../agent-runners/guide-rails.cjs');
+const require_system_prompt = require('../agent-runners/system-prompt.cjs');
+const require_retry = require('../agent-runners/retry.cjs');
+const require_result_contract = require('./result-contract.cjs');
+const require_runner_error = require('./runner-error.cjs');
+const require_agent_runner_registry = require('./agent-runner-registry.cjs');
+let ufo = require("ufo");
+
+//#region src/program/agent-action.ts
+const MAX_PAYLOAD_BYTES = 1024 * 1024;
+const BLOCKED_FIELDS = new Set([
+	"_system_append",
+	"_budget_override",
+	"_model_override",
+	"_parent_session",
+	"_parent_budget_remaining",
+	"_chain"
+]);
+function buildInputSchema(inputKey, override) {
+	if (override && typeof override === "object") return override;
+	return {
+		type: "object",
+		properties: { [inputKey]: {
+			type: "string",
+			description: `Input for the agent (key: ${inputKey})`
+		} },
+		required: [inputKey]
+	};
+}
+function sanitizeArgs(args) {
+	const sanitized = {};
+	for (const [key, value] of Object.entries(args)) if (!BLOCKED_FIELDS.has(key)) sanitized[key] = value;
+	return sanitized;
+}
+const SAFE_META_KEYS = new Set([
+	"run_id",
+	"rounds",
+	"tokens_used",
+	"sub_runs",
+	"scratch_path",
+	"mode",
+	"pipeline_steps",
+	"members_run",
+	"max_iterations_hit",
+	"warnings",
+	"session",
+	"parent_session",
+	"depth",
+	"chain",
+	"hook_events",
+	"hook_events_path",
+	"max_concurrency",
+	"member_run_ids",
+	"completed_steps",
+	"iterations",
+	"items_count",
+	"render",
+	"context"
+]);
+/**
+* B9 — accept only the documented shape: { template_vars: string[] }.
+* Anything else (primitives, arrays, foreign keys) is rejected so the
+* envelope can't leak arbitrary runner internals through _meta.
+*/
+function sanitizeRenderMeta(raw) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+	const vars = raw.template_vars;
+	if (!Array.isArray(vars)) return void 0;
+	return { template_vars: vars.filter((v) => typeof v === "string") };
+}
+/**
+* B9 — accept only the documented shape: { system: string }. Empty string is
+* allowed (ai-runner sets it to "" when no system prompt is configured).
+*/
+function sanitizeContextMeta(raw) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+	const sys = raw.system;
+	if (typeof sys !== "string") return void 0;
+	return { system: sys };
+}
+/**
+* B24 — strip any leading path so a full session path like
+* `/instance/.sessions/agent/deep-42` is recorded as `deep-42` in _meta.
+* Callers (MCP, LLM tool results) receive only the opaque id.
+*/
+function sessionBasename(value) {
+	const trimmed = value.replace(/\/+$/, "");
+	const idx = trimmed.lastIndexOf("/");
+	return idx >= 0 ? trimmed.slice(idx + 1) : trimmed;
+}
+/**
+* B23 — coerce any runner-reported count into a non-negative finite integer.
+*
+* The result-contract promises `rounds`/`tokens_used`/`sub_runs` are always
+* numbers. Runners have historically leaked strings (`"5"`), NaN, Infinity,
+* and negative values. Silent passthrough breaks downstream consumers that
+* e.g. render `_meta.tokens_used.toLocaleString()`.
+*/
+function coerceCount(raw) {
+	const n = typeof raw === "number" ? raw : typeof raw === "string" ? Number(raw) : NaN;
+	if (!Number.isFinite(n)) return 0;
+	return Math.max(0, Math.floor(n));
+}
+function shapeOutput(runnerOutput, options) {
+	if (!runnerOutput || typeof runnerOutput !== "object") {
+		const baseMeta = {
+			run_id: crypto.randomUUID(),
+			rounds: 0,
+			tokens_used: 0,
+			sub_runs: 0
+		};
+		const ctx0 = options?.context;
+		if (ctx0) {
+			if (typeof ctx0.session === "string" && ctx0.session.length > 0) baseMeta.session = sessionBasename(ctx0.session);
+			if (Array.isArray(ctx0.chain)) {
+				const cleaned = ctx0.chain.filter((s) => typeof s === "string" && s.length > 0);
+				if (cleaned.length > 0) baseMeta.chain = cleaned;
+				baseMeta.depth = cleaned.length;
+			} else if (ctx0.session !== void 0) baseMeta.depth = 0;
+		}
+		return {
+			result: runnerOutput ?? null,
+			_meta: baseMeta
+		};
+	}
+	const out = runnerOutput;
+	const warnings = [];
+	const runnerMeta = out._meta && typeof out._meta === "object" ? out._meta : {};
+	const data = out.data && typeof out.data === "object" ? out.data : {};
+	const hasStructuredShape = "data" in out || "result" in out || "_meta" in out || "success" in out || "error" in out;
+	const isFailureEnvelope = out.success === false;
+	let resultValue;
+	if (isFailureEnvelope) resultValue = data.result !== void 0 ? data.result : null;
+	else if (!hasStructuredShape) resultValue = runnerOutput;
+	else if (out.result !== void 0) resultValue = out.result;
+	else if (data.result !== void 0) resultValue = data.result;
+	else if (out.data !== void 0 && out.data !== null && typeof out.data === "object") {
+		const { _meta: _dataMeta, ...rest } = data;
+		resultValue = Object.keys(rest).length > 0 ? rest : null;
+	} else if (out.data !== void 0) resultValue = out.data;
+	else resultValue = null;
+	const resultIsEmpty = resultValue === void 0 || resultValue === null || typeof resultValue === "object" && Object.keys(resultValue).length === 0;
+	if (options?.outputKey && resultIsEmpty) {
+		warnings.push({
+			code: "OUTPUT_KEY_MISSING",
+			message: `Expected output key "${options.outputKey}" but runner returned no result`
+		});
+		resultValue = null;
+	}
+	if (resultValue != null && !require_result_contract.isJsonSafe(resultValue)) {
+		warnings.push({
+			code: "RESULT_NOT_JSON_SAFE",
+			message: "Result contains circular references or non-serializable values"
+		});
+		resultValue = null;
+	}
+	const runIdRaw = runnerMeta.run_id ?? data.run_id;
+	const meta = {
+		run_id: typeof runIdRaw === "string" && runIdRaw.length > 0 ? runIdRaw : crypto.randomUUID(),
+		rounds: coerceCount(runnerMeta.rounds ?? runnerMeta.iterations ?? data.rounds),
+		tokens_used: coerceCount(runnerMeta.tokens_used ?? data.total_tokens),
+		sub_runs: coerceCount(runnerMeta.sub_runs ?? data.sub_runs)
+	};
+	const rawScratch = runnerMeta.scratch_path ?? data.scratch_path;
+	if (typeof rawScratch === "string") meta.scratch_path = require_result_contract.sanitizeScratchPath(rawScratch);
+	for (const key of Object.keys(runnerMeta)) if (SAFE_META_KEYS.has(key) && !(key in meta)) if (key === "render") {
+		const cleaned = sanitizeRenderMeta(runnerMeta[key]);
+		if (cleaned) meta[key] = cleaned;
+	} else if (key === "context") {
+		const cleaned = sanitizeContextMeta(runnerMeta[key]);
+		if (cleaned) meta[key] = cleaned;
+	} else meta[key] = runnerMeta[key];
+	const ctx = options?.context;
+	if (ctx) {
+		if (typeof ctx.session === "string" && ctx.session.length > 0) meta.session = sessionBasename(ctx.session);
+		if (Array.isArray(ctx.chain)) {
+			const cleaned = ctx.chain.filter((s) => typeof s === "string" && s.length > 0);
+			if (cleaned.length > 0) meta.chain = cleaned;
+			meta.depth = cleaned.length;
+		} else if (ctx.session !== void 0) meta.depth = 0;
+	}
+	if (runnerMeta.env && typeof runnerMeta.env === "object") meta.env = require_result_contract.sanitizeMetaEnv(runnerMeta.env);
+	if (warnings.length > 0) meta.warnings = warnings;
+	return {
+		result: resultValue,
+		_meta: meta
+	};
+}
+function estimatePayloadSize(args) {
+	let size = 0;
+	for (const value of Object.values(args)) if (typeof value === "string") size += value.length;
+	else if (value instanceof Uint8Array) size += value.length;
+	else if (typeof value === "function" || typeof value === "symbol") {} else if (value !== null && value !== void 0) try {
+		const serialized = JSON.stringify(value);
+		if (typeof serialized === "string") size += serialized.length;
+	} catch {}
+	return size;
+}
+/**
+* B29 — Compile a statically-known tool catalog from `manifest.tools` so
+* `/.actions/run/.meta` can surface the LLM's tool surface without having to
+* invoke the agent.
+*
+* This is the dot-path resolver pass only — `.ash` frontmatter discovery and
+* skill-gated helpers require AFS I/O and happen later inside the runner. The
+* catalog returned here covers:
+*   - resolved bare-path declarations (`./knowledge/` → `<root>/knowledge/**`)
+*   - object-form declarations (passed through verbatim)
+*   - built-in `.actions/cancel` and `.actions/status` (auto-registered for
+*     every agent blocklet, so they must always appear)
+*
+* Invalid declarations (absolute paths, null bytes, …) surface as structured
+* warnings instead of silently dropping — one bad tool must not poison the
+* rest (mirrors the S13 "data loss prevention" contract).
+*/
+function compileStaticToolCatalog(manifest, mountPath, actionPrefix) {
+	const catalog = [];
+	const warnings = [];
+	const tools = manifest.tools ?? [];
+	for (const raw of tools) if (typeof raw === "string") try {
+		const [resolved] = require_dot_path_resolver.resolveDotPaths([raw], mountPath);
+		if (resolved) catalog.push(resolved);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		const code = msg.startsWith("TOOL_PATH_OUTSIDE_BLOCKLET") ? "TOOL_PATH_OUTSIDE_BLOCKLET" : "TOOL_PATH_INVALID";
+		warnings.push({
+			code,
+			path: raw,
+			message: msg
+		});
+	}
+	else if (raw && typeof raw === "object") {
+		const entry = raw;
+		if (typeof entry.path !== "string" || entry.path.length === 0) {
+			warnings.push({
+				code: "TOOL_PATH_INVALID",
+				message: "object tool entry missing 'path' field"
+			});
+			continue;
+		}
+		catalog.push({
+			path: entry.path,
+			ops: require_index.withQueryPairing(entry.ops ?? [
+				"read",
+				"list",
+				"search"
+			]),
+			...entry.maxDepth != null ? { maxDepth: entry.maxDepth } : {}
+		});
+	}
+	const cancelName = actionPrefix ? `${actionPrefix}-cancel` : "cancel";
+	const statusName = actionPrefix ? `${actionPrefix}-status` : "status";
+	catalog.push({
+		path: (0, ufo.joinURL)(mountPath, `.actions/${cancelName}`),
+		ops: ["exec"]
+	});
+	catalog.push({
+		path: (0, ufo.joinURL)(mountPath, `.actions/${statusName}`),
+		ops: ["exec"]
+	});
+	return {
+		catalog,
+		warnings
+	};
+}
+function createAgentActionHandlers(manifest, _mountPath, options) {
+	const inputKey = manifest.inputKey ?? "message";
+	const inputSchema = buildInputSchema(inputKey, manifest.inputSchema);
+	const actionPrefix = options?.actionPrefix;
+	const runName = actionPrefix ? `${actionPrefix}-run` : "run";
+	const cancelName = actionPrefix ? `${actionPrefix}-cancel` : "cancel";
+	const statusName = actionPrefix ? `${actionPrefix}-status` : "status";
+	const { catalog: toolCatalog, warnings: catalogWarnings } = compileStaticToolCatalog(manifest, _mountPath, actionPrefix);
+	const runEntry = {
+		id: runName,
+		path: `/.actions/${runName}`,
+		summary: `Run agent "${manifest.name}"`,
+		meta: {
+			kind: "afs:executable",
+			kinds: ["afs:executable", "afs:node"],
+			effect: "write",
+			tool_catalog: toolCatalog,
+			...catalogWarnings.length > 0 ? { warnings: catalogWarnings } : {}
+		},
+		actions: [{
+			name: runName,
+			description: `Execute the "${manifest.name}" agent with the given input`,
+			inputSchema,
+			effect: "write"
+		}]
+	};
+	const cancelEntry = {
+		id: cancelName,
+		path: `/.actions/${cancelName}`,
+		summary: `Cancel a running agent session for "${manifest.name}"`,
+		meta: {
+			kind: "afs:executable",
+			kinds: ["afs:executable", "afs:node"],
+			effect: "write"
+		},
+		actions: [{
+			name: cancelName,
+			effect: "write",
+			description: `Cancel the "${manifest.name}" agent run for a given session`,
+			inputSchema: {
+				type: "object",
+				properties: { session: {
+					type: "string",
+					description: "Session ID to cancel"
+				} },
+				required: ["session"]
+			}
+		}]
+	};
+	const statusEntry = {
+		id: statusName,
+		path: `/.actions/${statusName}`,
+		summary: `Get agent run status for "${manifest.name}"`,
+		meta: {
+			kind: "afs:executable",
+			kinds: ["afs:executable", "afs:node"],
+			effect: "read"
+		},
+		actions: [{
+			name: statusName,
+			effect: "read",
+			description: `Get the current status of a "${manifest.name}" agent run`,
+			inputSchema: {
+				type: "object",
+				properties: { session: {
+					type: "string",
+					description: "Session ID to check"
+				} }
+			}
+		}]
+	};
+	return {
+		run: {
+			entry: runEntry,
+			inputSchema,
+			handler: async (args, context) => {
+				const sanitized = sanitizeArgs(args);
+				if (estimatePayloadSize(sanitized) > MAX_PAYLOAD_BYTES) return {
+					success: false,
+					error: {
+						code: "PAYLOAD_TOO_LARGE",
+						message: "Input payload exceeds 1 MB limit"
+					}
+				};
+				const inputValue = sanitized[inputKey];
+				if (inputValue === void 0 || inputValue === null) return {
+					success: false,
+					error: {
+						code: "INPUT_SCHEMA_INVALID",
+						message: `Missing required field: ${inputKey}`,
+						details: { field: inputKey }
+					}
+				};
+				const expectedType = (inputSchema?.properties)?.[inputKey]?.type;
+				if ((expectedType === void 0 || expectedType === "string") && typeof inputValue !== "string") return {
+					success: false,
+					error: {
+						code: "INPUT_SCHEMA_INVALID",
+						message: `Field "${inputKey}" must be a string, got ${typeof inputValue}`,
+						details: { field: inputKey }
+					}
+				};
+				if (!context) return {
+					success: false,
+					error: {
+						code: "INTERNAL_ERROR",
+						message: "No runner context provided"
+					}
+				};
+				try {
+					const runner = require_agent_runner_registry.getRunnerForType(manifest.type);
+					const systemAppend = require_system_prompt.sanitizeSystemAppend(args._system_append);
+					const enrichedContext = {
+						...context,
+						session: typeof args.session === "string" ? args.session : context.session,
+						parentSession: args._parent_session ?? void 0,
+						chain: Array.isArray(args._chain) ? args._chain : void 0,
+						systemAppend
+					};
+					const result = await require_retry.withRetry(() => runner(sanitized, enrichedContext), manifest.retry, (r) => r?.success === false);
+					let effectiveResult = result;
+					if (result?.success !== false && manifest.guideRails && manifest.guideRails.length > 0) {
+						const decision = await require_guide_rails.runGuideRails(enrichedContext.afs, manifest.guideRails, sanitized, result?.data ?? result, { mountPath: enrichedContext.mountPath });
+						if (decision.abort) {
+							const shapedAbort = shapeOutput(null, {
+								outputKey: manifest.outputKey,
+								context: {
+									session: enrichedContext.session,
+									chain: enrichedContext.chain
+								}
+							});
+							return {
+								success: false,
+								error: {
+									code: "GUIDE_RAIL_ABORT",
+									message: decision.reason ?? "GuideRail aborted"
+								},
+								data: shapedAbort
+							};
+						}
+						if (decision.output !== void 0) effectiveResult = {
+							...result,
+							data: decision.output
+						};
+					}
+					const shaped = shapeOutput(effectiveResult, {
+						outputKey: manifest.outputKey,
+						context: {
+							session: enrichedContext.session,
+							chain: enrichedContext.chain
+						}
+					});
+					if (result?.success === false) return {
+						success: false,
+						error: require_runner_error.normalizeRunnerError(result?.error ?? {
+							code: "RUNNER_FAILED",
+							message: "Runner reported failure"
+						}),
+						data: shaped
+					};
+					return {
+						success: true,
+						data: shaped
+					};
+				} catch (err) {
+					const sessionFromArgs = typeof args.session === "string" ? args.session : context.session;
+					const chainFromArgs = Array.isArray(args._chain) ? args._chain : void 0;
+					const shapedOnError = shapeOutput(null, {
+						outputKey: manifest.outputKey,
+						context: {
+							session: sessionFromArgs,
+							chain: chainFromArgs
+						}
+					});
+					return {
+						success: false,
+						error: require_runner_error.normalizeRunnerError(err),
+						data: shapedOnError
+					};
+				}
+			},
+			sanitizeArgs,
+			shapeOutput
+		},
+		cancel: {
+			entry: cancelEntry,
+			inputSchema: cancelEntry.actions[0].inputSchema,
+			handler: async (args) => {
+				const session = args.session;
+				if (session) return {
+					success: false,
+					error: {
+						code: "SESSION_NOT_FOUND",
+						message: `Session "${session}" not found`
+					}
+				};
+				return {
+					success: true,
+					data: { cancelled: true }
+				};
+			},
+			sanitizeArgs,
+			shapeOutput
+		},
+		status: {
+			entry: statusEntry,
+			inputSchema: statusEntry.actions[0].inputSchema,
+			handler: async (args) => {
+				const session = args.session;
+				if (session) return {
+					success: false,
+					error: {
+						code: "SESSION_NOT_FOUND",
+						message: `Session "${session}" not found`
+					}
+				};
+				return {
+					success: true,
+					data: { state: "unknown" }
+				};
+			},
+			sanitizeArgs,
+			shapeOutput
+		}
+	};
+}
+
+//#endregion
+exports.createAgentActionHandlers = createAgentActionHandlers;

package/dist/program/agent-action.d.cts

@@ -0,0 +1,42 @@
+import { RunnerContext } from "./agent-runner-registry.cjs";
+import { AFSEntry, AFSExecResult, AgentManifest } from "@aigne/afs";
+
+//#region src/program/agent-action.d.ts
+interface AgentActionHandler {
+  entry: AFSEntry;
+  inputSchema: Record<string, unknown>;
+  handler: (args: Record<string, unknown>, context?: RunnerContext) => Promise<AFSExecResult>;
+  sanitizeArgs: (args: Record<string, unknown>) => Record<string, unknown>;
+  shapeOutput: (runnerOutput: unknown, options?: {
+    outputKey?: string;
+    context?: {
+      session?: string;
+      chain?: string[];
+    };
+  }) => {
+    result: any;
+    _meta: Record<string, unknown>;
+  };
+}
+interface AgentActionHandlers {
+  run: AgentActionHandler;
+  cancel: AgentActionHandler;
+  status: AgentActionHandler;
+}
+/**
+ * Options for `createAgentActionHandlers`.
+ *
+ * `actionPrefix` is used by the blocklet manager when registering nested
+ * agents under a single blocklet's runtime AFS. Without a prefix, every
+ * blocklet would collide on the unqualified `run`/`cancel`/`status` keys
+ * after the second nested manifest. With `actionPrefix: "s1"`, the
+ * registered names become `s1-run`/`s1-cancel`/`s1-status`, and any
+ * catalog references the LLM sees rewrite to match.
+ */
+interface CreateAgentActionHandlersOptions {
+  actionPrefix?: string;
+}
+declare function createAgentActionHandlers(manifest: AgentManifest, _mountPath: string, options?: CreateAgentActionHandlersOptions): AgentActionHandlers;
+//#endregion
+export { AgentActionHandler, AgentActionHandlers, createAgentActionHandlers };
+//# sourceMappingURL=agent-action.d.cts.map

package/dist/program/agent-action.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-action.d.cts","names":[],"sources":["../../src/program/agent-action.ts"],"mappings":";;;;UA6BiB,kBAAA;EACf,KAAA,EAAO,QAAA;EACP,WAAA,EAAa,MAAA;EACb,OAAA,GAAU,IAAA,EAAM,MAAA,mBAAyB,OAAA,GAAU,aAAA,KAAkB,OAAA,CAAQ,aAAA;EAC7E,YAAA,GAAe,IAAA,EAAM,MAAA,sBAA4B,MAAA;EACjD,WAAA,GACE,YAAA,WACA,OAAA;IACE,SAAA;IACA,OAAA;MAAY,OAAA;MAAkB,KAAA;IAAA;EAAA;IAE3B,MAAA;IAAa,KAAA,EAAO,MAAA;EAAA;AAAA;AAAA,UAGZ,mBAAA;EACf,GAAA,EAAK,kBAAA;EACL,MAAA,EAAQ,kBAAA;EACR,MAAA,EAAQ,kBAAA;AAAA;;;;;;;;;;;UA+WO,gCAAA;EACf,YAAA;AAAA;AAAA,iBAGc,yBAAA,CACd,QAAA,EAAU,aAAA,EACV,UAAA,UACA,OAAA,GAAU,gCAAA,GACT,mBAAA"}

package/dist/program/agent-action.d.mts

@@ -0,0 +1,42 @@
+import { RunnerContext } from "./agent-runner-registry.mjs";
+import { AFSEntry, AFSExecResult, AgentManifest } from "@aigne/afs";
+
+//#region src/program/agent-action.d.ts
+interface AgentActionHandler {
+  entry: AFSEntry;
+  inputSchema: Record<string, unknown>;
+  handler: (args: Record<string, unknown>, context?: RunnerContext) => Promise<AFSExecResult>;
+  sanitizeArgs: (args: Record<string, unknown>) => Record<string, unknown>;
+  shapeOutput: (runnerOutput: unknown, options?: {
+    outputKey?: string;
+    context?: {
+      session?: string;
+      chain?: string[];
+    };
+  }) => {
+    result: any;
+    _meta: Record<string, unknown>;
+  };
+}
+interface AgentActionHandlers {
+  run: AgentActionHandler;
+  cancel: AgentActionHandler;
+  status: AgentActionHandler;
+}
+/**
+ * Options for `createAgentActionHandlers`.
+ *
+ * `actionPrefix` is used by the blocklet manager when registering nested
+ * agents under a single blocklet's runtime AFS. Without a prefix, every
+ * blocklet would collide on the unqualified `run`/`cancel`/`status` keys
+ * after the second nested manifest. With `actionPrefix: "s1"`, the
+ * registered names become `s1-run`/`s1-cancel`/`s1-status`, and any
+ * catalog references the LLM sees rewrite to match.
+ */
+interface CreateAgentActionHandlersOptions {
+  actionPrefix?: string;
+}
+declare function createAgentActionHandlers(manifest: AgentManifest, _mountPath: string, options?: CreateAgentActionHandlersOptions): AgentActionHandlers;
+//#endregion
+export { AgentActionHandler, AgentActionHandlers, createAgentActionHandlers };
+//# sourceMappingURL=agent-action.d.mts.map

package/dist/program/agent-action.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-action.d.mts","names":[],"sources":["../../src/program/agent-action.ts"],"mappings":";;;;UA6BiB,kBAAA;EACf,KAAA,EAAO,QAAA;EACP,WAAA,EAAa,MAAA;EACb,OAAA,GAAU,IAAA,EAAM,MAAA,mBAAyB,OAAA,GAAU,aAAA,KAAkB,OAAA,CAAQ,aAAA;EAC7E,YAAA,GAAe,IAAA,EAAM,MAAA,sBAA4B,MAAA;EACjD,WAAA,GACE,YAAA,WACA,OAAA;IACE,SAAA;IACA,OAAA;MAAY,OAAA;MAAkB,KAAA;IAAA;EAAA;IAE3B,MAAA;IAAa,KAAA,EAAO,MAAA;EAAA;AAAA;AAAA,UAGZ,mBAAA;EACf,GAAA,EAAK,kBAAA;EACL,MAAA,EAAQ,kBAAA;EACR,MAAA,EAAQ,kBAAA;AAAA;;;;;;;;;;;UA+WO,gCAAA;EACf,YAAA;AAAA;AAAA,iBAGc,yBAAA,CACd,QAAA,EAAU,aAAA,EACV,UAAA,UACA,OAAA,GAAU,gCAAA,GACT,mBAAA"}