@agentic-workflow-kit/orchestrator 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arye Kogan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/analysis/runAnalyzer.d.ts

@@ -0,0 +1,22 @@
+import type { TokenTotals } from '../types.js';
+interface AnalyzeOptions {
+    sessionRoots?: string[];
+}
+export interface WorkflowRunAnalysis {
+    runId: string;
+    status: string;
+    blockedReason: string | null;
+    children: AnalyzedChild[];
+    commandCounts: Record<string, number>;
+    subagentCounts: Record<string, number>;
+    tokenTotals: TokenTotals | null;
+}
+interface AnalyzedChild {
+    storyId: string;
+    ok: boolean;
+    sessionId: string | null;
+    sessionLogPath: string | null;
+}
+export declare function analyzeWorkflowRun(runDirectory: string, options?: AnalyzeOptions): Promise<WorkflowRunAnalysis>;
+export {};
+//# sourceMappingURL=runAnalyzer.d.ts.map

package/dist/analysis/runAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runAnalyzer.d.ts","sourceRoot":"","sources":["../../src/analysis/runAnalyzer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,UAAU,cAAc;IACtB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;CACjC;AAED,UAAU,aAAa;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,OAAO,CAAC;IACZ,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,wBAAsB,kBAAkB,CACtC,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,mBAAmB,CAAC,CA+C9B"}

package/dist/analysis/runAnalyzer.js

@@ -0,0 +1,177 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { isNodeError, isRecord } from '../internal/guards.js';
+import { addTokenTotals, emptyTokenTotals, mergeCounts } from '../metrics/aggregate.js';
+export async function analyzeWorkflowRun(runDirectory, options = {}) {
+    const state = await readJsonObject(path.join(runDirectory, 'state.json'));
+    const children = await readChildren(path.join(runDirectory, 'children'));
+    const sessionLogs = await findSessionLogs(options.sessionRoots ?? defaultSessionRoots());
+    const logsBySession = await mapSessionLogsByThread(sessionLogs);
+    const commandCounts = {};
+    const subagentCounts = {};
+    let tokenTotals = emptyTokenTotals();
+    let sawTokens = false;
+    const analyzedChildren = [];
+    for (const child of children) {
+        const sessionId = typeof child.sessionId === 'string'
+            ? child.sessionId
+            : typeof child.threadId === 'string'
+                ? child.threadId
+                : null;
+        const sessionLogPath = sessionId ? (logsBySession.get(sessionId) ?? null) : null;
+        analyzedChildren.push({
+            storyId: readString(child.storyId, 'child.storyId'),
+            ok: child.ok === true,
+            sessionId,
+            sessionLogPath,
+        });
+        if (!sessionLogPath)
+            continue;
+        const sessionMetrics = await analyzeSessionLog(sessionLogPath);
+        mergeCounts(commandCounts, sessionMetrics.commandCounts);
+        mergeCounts(subagentCounts, sessionMetrics.subagentCounts);
+        if (sessionMetrics.tokenTotals) {
+            sawTokens = true;
+            tokenTotals = addTokenTotals(tokenTotals, sessionMetrics.tokenTotals);
+        }
+    }
+    return {
+        runId: readString(state.runId, 'state.runId'),
+        status: readString(state.status, 'state.status'),
+        blockedReason: typeof state.blockedReason === 'string' ? state.blockedReason : null,
+        children: analyzedChildren,
+        commandCounts,
+        subagentCounts,
+        tokenTotals: sawTokens ? tokenTotals : null,
+    };
+}
+async function readChildren(childrenDirectory) {
+    let names;
+    try {
+        names = await readdir(childrenDirectory);
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    const childFiles = names
+        .filter((name) => name.endsWith('.json') && !name.endsWith('.raw.json') && !name.endsWith('.metrics.json'))
+        .sort();
+    return await Promise.all(childFiles.map((name) => readJsonObject(path.join(childrenDirectory, name))));
+}
+async function findSessionLogs(roots) {
+    const logs = [];
+    for (const root of roots) {
+        if (!(await pathExists(root)))
+            continue;
+        await walkJsonl(root, logs);
+    }
+    return logs;
+}
+async function walkJsonl(directory, logs) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    for (const entry of entries) {
+        const entryPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            await walkJsonl(entryPath, logs);
+        }
+        else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+            logs.push(entryPath);
+        }
+    }
+}
+async function mapSessionLogsByThread(sessionLogs) {
+    const byThread = new Map();
+    for (const sessionLog of sessionLogs) {
+        const content = await readFile(sessionLog, 'utf8');
+        for (const line of content.split('\n')) {
+            const entry = parseJsonLine(line);
+            if (entry?.type !== 'session_meta' || !isRecord(entry.payload))
+                continue;
+            const id = entry.payload.id;
+            if (typeof id === 'string' && !byThread.has(id)) {
+                byThread.set(id, sessionLog);
+            }
+        }
+    }
+    return byThread;
+}
+async function analyzeSessionLog(sessionLog) {
+    const commandCounts = {};
+    const subagentCounts = {};
+    let tokenTotals = null;
+    const content = await readFile(sessionLog, 'utf8');
+    for (const line of content.split('\n')) {
+        const entry = parseJsonLine(line);
+        if (!entry || !isRecord(entry.payload))
+            continue;
+        if (entry.type === 'response_item' && isRecord(entry.payload)) {
+            const payload = entry.payload;
+            if ((payload.type === 'function_call' || payload.type === 'custom_tool_call') &&
+                typeof payload.name === 'string') {
+                increment(commandCounts, payload.name);
+            }
+            if (payload.type === 'function_call' && payload.name === 'spawn_agent' && typeof payload.arguments === 'string') {
+                const parsedArgs = parseJsonLine(payload.arguments);
+                if (parsedArgs && typeof parsedArgs.agent_type === 'string') {
+                    increment(subagentCounts, parsedArgs.agent_type);
+                }
+            }
+        }
+        if (entry.type === 'event_msg' && entry.payload.type === 'token_count' && isRecord(entry.payload.info)) {
+            const usage = entry.payload.info.total_token_usage;
+            if (isRecord(usage)) {
+                tokenTotals = {
+                    inputTokens: readNumber(usage.input_tokens),
+                    cachedInputTokens: readNumber(usage.cached_input_tokens),
+                    outputTokens: readNumber(usage.output_tokens),
+                    reasoningOutputTokens: readNumber(usage.reasoning_output_tokens),
+                    totalTokens: readNumber(usage.total_tokens),
+                };
+            }
+        }
+    }
+    return { commandCounts, subagentCounts, tokenTotals };
+}
+function defaultSessionRoots() {
+    const home = process.env.HOME;
+    return home ? [path.join(home, '.codex', 'sessions'), path.join(home, '.codex', 'archived_sessions')] : [];
+}
+async function readJsonObject(filePath) {
+    const parsed = JSON.parse(await readFile(filePath, 'utf8'));
+    if (!isRecord(parsed))
+        throw new Error(`${filePath} must contain a JSON object`);
+    return parsed;
+}
+async function pathExists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parseJsonLine(line) {
+    if (line.trim().length === 0)
+        return null;
+    try {
+        const parsed = JSON.parse(line);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function increment(target, key) {
+    target[key] = (target[key] ?? 0) + 1;
+}
+function readString(value, name) {
+    if (typeof value !== 'string')
+        throw new Error(`${name} must be a string`);
+    return value;
+}
+function readNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}

package/dist/artifacts/FileArtifactStore.d.ts

@@ -0,0 +1,9 @@
+import type { ArtifactStore, RunEvent } from '../types.js';
+export declare class FileArtifactStore implements ArtifactStore {
+    private readonly root;
+    constructor(root: string);
+    writeJson(relativePath: string, value: unknown): Promise<void>;
+    writeText(relativePath: string, value: string): Promise<void>;
+    appendEvent(event: RunEvent): Promise<void>;
+}
+//# sourceMappingURL=FileArtifactStore.d.ts.map

package/dist/artifacts/FileArtifactStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileArtifactStore.d.ts","sourceRoot":"","sources":["../../src/artifacts/FileArtifactStore.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE3D,qBAAa,iBAAkB,YAAW,aAAa;IACzC,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,MAAM;IAEnC,SAAS,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9D,SAAS,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAM7D,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CAKlD"}

package/dist/artifacts/FileArtifactStore.js

@@ -0,0 +1,21 @@
+import { appendFile, mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+export class FileArtifactStore {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    async writeJson(relativePath, value) {
+        await this.writeText(relativePath, `${JSON.stringify(value, null, 2)}\n`);
+    }
+    async writeText(relativePath, value) {
+        const filePath = path.join(this.root, relativePath);
+        await mkdir(path.dirname(filePath), { recursive: true });
+        await writeFile(filePath, value);
+    }
+    async appendEvent(event) {
+        const filePath = path.join(this.root, 'events.ndjson');
+        await mkdir(path.dirname(filePath), { recursive: true });
+        await appendFile(filePath, `${JSON.stringify(event)}\n`);
+    }
+}

package/dist/cli/args.d.ts

@@ -0,0 +1,5 @@
+import type { CliOverrides, WorkflowCommand } from '../types.js';
+export declare function parseCommand(argv: string[]): WorkflowCommand;
+export declare function getHelpText(): string;
+export declare function resolveInvocationCwd(overrides: Pick<CliOverrides, 'cwd'>): string;
+//# sourceMappingURL=args.d.ts.map

package/dist/cli/args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../src/cli/args.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAkB,YAAY,EAAe,eAAe,EAAE,MAAM,aAAa,CAAC;AAK9F,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,eAAe,CAkC5D;AAED,wBAAgB,WAAW,IAAI,MAAM,CAEpC;AAiJD,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,GAAG,MAAM,CAGjF"}

package/dist/cli/args.js

@@ -0,0 +1,213 @@
+import path from 'node:path';
+import process from 'node:process';
+import { Command, CommanderError, InvalidArgumentError, Option } from 'commander';
+const APPROVAL_POLICIES = new Set(['untrusted', 'on-failure', 'on-request', 'never']);
+const SANDBOX_MODES = new Set(['read-only', 'workspace-write', 'danger-full-access']);
+export function parseCommand(argv) {
+    const args = argv.filter((arg) => arg !== '--');
+    if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+        return { kind: 'help' };
+    }
+    if (args[0].startsWith('-')) {
+        throw new Error(`Unknown command: ${args[0]}`);
+    }
+    if (args[0] === 'mcp' && args[1] !== 'check') {
+        throw new Error('Expected `mcp check`');
+    }
+    if (args[0] === 'run-story' && (!args[1] || args[1].startsWith('-'))) {
+        throw new Error('run-story requires a story id');
+    }
+    if (args[0] === 'watch-run' && (!args[1] || args[1].startsWith('-'))) {
+        throw new Error('watch-run requires a run directory');
+    }
+    if (args[0] === 'analyze-run' && (!args[1] || args[1].startsWith('-'))) {
+        throw new Error('analyze-run requires a run directory');
+    }
+    let parsed;
+    const program = buildProgram((command) => {
+        parsed = command;
+    });
+    try {
+        program.parse(args, { from: 'user' });
+    }
+    catch (error) {
+        throw mapCommanderError(error);
+    }
+    if (parsed)
+        return parsed;
+    throw new Error(`Unknown command: ${args[0]}`);
+}
+export function getHelpText() {
+    return buildProgram(() => undefined).helpInformation();
+}
+function buildProgram(setParsed) {
+    const program = new Command('agentic-workflow-kit')
+        .exitOverride()
+        .configureOutput({ writeOut: () => undefined, writeErr: () => undefined })
+        .helpOption(false)
+        .allowUnknownOption(false)
+        .allowExcessArguments(false);
+    withOptions(program.command('list-tracks')).action((options) => {
+        setParsed({ kind: 'list-tracks', overrides: toOverrides(options) });
+    });
+    withOptions(program.command('list-stories')).action((options) => {
+        setParsed({ kind: 'list-stories', overrides: toOverrides(options) });
+    });
+    withOptions(program.command('list-eligible')).action((options) => {
+        setParsed({ kind: 'list-eligible', overrides: toOverrides(options) });
+    });
+    withOptions(program.command('run-story').argument('<storyId>')).action((storyId, options) => {
+        setParsed({ kind: 'run-story', storyId, overrides: toOverrides(options) });
+    });
+    withOptions(program.command('run-eligible')).action((options) => {
+        setParsed({ kind: 'run-eligible', overrides: toOverrides(options) });
+    });
+    withOptions(program.command('watch-run').argument('<runPath>')).action((runPath, options) => {
+        setParsed({ kind: 'watch-run', runPath, overrides: toOverrides(options) });
+    });
+    withOptions(program.command('analyze-run').argument('<runPath>')).action((runPath, options) => {
+        setParsed({ kind: 'analyze-run', runPath, overrides: toOverrides(options) });
+    });
+    const mcp = program.command('mcp').allowExcessArguments(false);
+    withOptions(mcp.command('check')).action((options) => {
+        setParsed({ kind: 'mcp-check', overrides: toOverrides(options) });
+    });
+    return program;
+}
+function withOptions(command) {
+    return command
+        .allowUnknownOption(false)
+        .allowExcessArguments(false)
+        .option('--config <path>')
+        .option('--json')
+        .option('--force')
+        .option('--dry-run')
+        .option('--watch')
+        .addOption(new Option('--max-parallel <n>').argParser(parsePositiveInteger))
+        .addOption(new Option('--child-timeout-ms <n>').argParser(parseChildTimeoutMs))
+        .option('--track <id>')
+        .option('--tracks-dir <path>')
+        .option('--model <model>')
+        .option('--reasoning <effort>')
+        .addOption(new Option('--approval-policy <policy>').argParser(parseApprovalPolicy))
+        .addOption(new Option('--sandbox <mode>').argParser(parseSandbox))
+        .option('--cwd <path>')
+        .option('--session-root <path>');
+}
+function toOverrides(options) {
+    const overrides = {};
+    if (options.config !== undefined)
+        overrides.configPath = options.config;
+    if (options.json)
+        overrides.json = true;
+    if (options.force)
+        overrides.force = true;
+    if (options.dryRun)
+        overrides.dryRun = true;
+    if (options.watch)
+        overrides.watch = true;
+    if (options.maxParallel !== undefined)
+        overrides.maxParallel = options.maxParallel;
+    if (options.childTimeoutMs !== undefined)
+        overrides.childTimeoutMs = options.childTimeoutMs;
+    if (options.track !== undefined)
+        overrides.track = options.track;
+    if (options.tracksDir !== undefined)
+        overrides.tracksDir = options.tracksDir;
+    if (options.model !== undefined)
+        overrides.model = options.model;
+    if (options.reasoning !== undefined)
+        overrides.reasoning = options.reasoning;
+    if (options.approvalPolicy !== undefined)
+        overrides.approvalPolicy = options.approvalPolicy;
+    if (options.sandbox !== undefined)
+        overrides.sandbox = options.sandbox;
+    if (options.cwd !== undefined)
+        overrides.cwd = options.cwd;
+    if (options.sessionRoot !== undefined)
+        overrides.sessionRoot = options.sessionRoot;
+    return overrides;
+}
+function parseApprovalPolicy(value) {
+    if (!APPROVAL_POLICIES.has(value)) {
+        throw new InvalidArgumentError('--approval-policy must be one of untrusted, on-failure, on-request, never');
+    }
+    return value;
+}
+function parseSandbox(value) {
+    if (!SANDBOX_MODES.has(value)) {
+        throw new InvalidArgumentError('--sandbox must be one of read-only, workspace-write, danger-full-access');
+    }
+    return value;
+}
+function parsePositiveInteger(value) {
+    if (value === '') {
+        throw new InvalidArgumentError('--max-parallel requires a value');
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) || parsed < 1 || String(parsed) !== value) {
+        throw new InvalidArgumentError('--max-parallel must be a positive integer');
+    }
+    return parsed;
+}
+function parseChildTimeoutMs(value) {
+    return parsePositiveIntegerFlag(value, '--child-timeout-ms');
+}
+function parsePositiveIntegerFlag(value, flag) {
+    if (value === '') {
+        throw new InvalidArgumentError(`${flag} requires a value`);
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) || parsed < 1 || String(parsed) !== value) {
+        throw new InvalidArgumentError(`${flag} must be a positive integer`);
+    }
+    return parsed;
+}
+export function resolveInvocationCwd(overrides) {
+    if (overrides.cwd)
+        return path.resolve(overrides.cwd);
+    return process.env.INIT_CWD ? path.resolve(process.env.INIT_CWD) : process.cwd();
+}
+function mapCommanderError(error) {
+    if (!(error instanceof CommanderError)) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    const message = error.message;
+    const unknownOption = message.match(/unknown option '([^']+)'/);
+    if (unknownOption)
+        return new Error(`Unknown argument: ${unknownOption[1]}`);
+    const unknownCommand = message.match(/unknown command '([^']+)'/);
+    if (unknownCommand)
+        return new Error(`Unknown command: ${unknownCommand[1]}`);
+    const missingOptionValue = message.match(/option '([^']+)' argument missing/);
+    if (missingOptionValue) {
+        const flag = missingOptionValue[1].split(/\s+/)[0];
+        return new Error(`${flag} requires a value`);
+    }
+    const excessArgument = message.match(/too many arguments .* got \d+: ([^.]+)\./);
+    if (excessArgument) {
+        const extra = excessArgument[1].split(',').at(-1)?.trim() ?? excessArgument[1];
+        return new Error(`Unknown argument: ${extra}`);
+    }
+    if (message.includes("missing required argument 'storyId'"))
+        return new Error('run-story requires a story id');
+    if (message.includes('--max-parallel requires a value')) {
+        return new Error('--max-parallel requires a value');
+    }
+    if (message.includes('--max-parallel must be a positive integer')) {
+        return new Error('--max-parallel must be a positive integer');
+    }
+    if (message.includes('--child-timeout-ms requires a value')) {
+        return new Error('--child-timeout-ms requires a value');
+    }
+    if (message.includes('--child-timeout-ms must be a positive integer')) {
+        return new Error('--child-timeout-ms must be a positive integer');
+    }
+    if (message.includes('--approval-policy must be one of')) {
+        return new Error('--approval-policy must be one of untrusted, on-failure, on-request, never');
+    }
+    if (message.includes('--sandbox must be one of')) {
+        return new Error('--sandbox must be one of read-only, workspace-write, danger-full-access');
+    }
+    return new Error(message.replace(/^error: /, ''));
+}

package/dist/cli.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { type CodexMcpStoryRunnerOptions } from './drivers/codex-mcp/CodexMcpStoryRunner.js';
+export interface RunCliOptions {
+    stdout?: (line: string) => void;
+    createCodexMcpClient?: CodexMcpStoryRunnerOptions['createClient'];
+}
+export declare function runCli(argv?: string[], options?: RunCliOptions): Promise<void>;
+export declare function isDirectCliExecution(entrypoint?: string, moduleUrl?: string): boolean;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAaA,OAAO,EAAuB,KAAK,0BAA0B,EAAE,MAAM,4CAA4C,CAAC;AAQlH,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,oBAAoB,CAAC,EAAE,0BAA0B,CAAC,cAAc,CAAC,CAAC;CACnE;AAED,wBAAsB,MAAM,CAAC,IAAI,WAAwB,EAAE,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAwGrG;AA2MD,wBAAgB,oBAAoB,CAAC,UAAU,SAAkB,EAAE,SAAS,SAAkB,GAAG,OAAO,CAOvG"}