@shrkcrft/inspector 0.1.0-alpha.2

package/dist/agent-handoff.js

@@ -0,0 +1,470 @@
+/**
+ * Agent handoff packet.
+ *
+ * `brief` is the *pre-work* context for an agent. `handoff` is the
+ * *continue-from-here* context: it captures current task status, what was
+ * already done, what remains, and the single next safe command — so a
+ * different agent (or the same agent after a context reset) can pick up
+ * without redoing discovery.
+ *
+ * Read-only. Sources state from:
+ *  - a passed-in task string + inspection
+ *  - an existing dev session (sessionId)
+ *  - an existing feature bundle (bundleId)
+ *  - optionally a git ref (`since`) for changed-files surfacing
+ *
+ * Never writes (the CLI write step is the caller's responsibility).
+ */
+import * as nodePath from 'node:path';
+import { readFeatureBundle } from "./feature-bundle.js";
+import { scanDevSession, DevSessionPlanStatus } from "./dev-session.js";
+import { buildAgentBrief, BriefMode } from "./agent-brief.js";
+import { getChangedFiles } from "./git-helpers.js";
+import { buildTaskRiskReport } from "./task-risk.js";
+import { buildAgentContract } from "./agent-contract.js";
+import { buildTaskExecutionGraph } from "./execution-graph.js";
+import { simulatePlan } from "./plan-simulation.js";
+import { loadRepositoryMemory, memoryRiskForTask } from "./repo-memory.js";
+import { buildUncertaintyReport } from "./uncertainty-report.js";
+export const AGENT_HANDOFF_SCHEMA = 'sharkcraft.agent-handoff/v1';
+function tokensEstimate(s) {
+    // SharkCraft convention: ~4 chars per token, with a floor of 1.
+    return Math.max(1, Math.ceil(s.length / 4));
+}
+function formatList(items, bullet = '-') {
+    if (items.length === 0)
+        return '(none)';
+    return items.map((i) => `${bullet} ${i}`).join('\n');
+}
+function buildSafetyNote() {
+    return [
+        'Before any write step:',
+        '  - Generation: `shrk gen --dry-run --save-plan /tmp/plan.json`, then `shrk plan review`,',
+        '    then `shrk apply --verify-signature`.',
+        '  - MCP tools never write to disk. The CLI is the only write path.',
+        '  - Pack-contributed verification commands are NOT auto-run.',
+    ].join('\n');
+}
+function describeSession(load) {
+    const state = load.state;
+    const artifacts = [];
+    const approvals = [];
+    if (!state) {
+        return { status: 'legacy', next: `shrk dev status ${load.id}`, artifacts, approvals };
+    }
+    if (state.briefFile)
+        artifacts.push({ kind: 'brief', path: state.briefFile });
+    for (const a of state.appliedPlans ?? []) {
+        artifacts.push({ kind: 'applied-plan', path: a.file });
+    }
+    for (const v of state.validations ?? []) {
+        artifacts.push({ kind: 'validation', path: v.startedAt });
+    }
+    const next = state.nextAction ? state.nextAction : `shrk dev status ${state.id}`;
+    for (const p of state.plans ?? []) {
+        if (p.status === DevSessionPlanStatus.Saved || p.status === DevSessionPlanStatus.Reviewed) {
+            approvals.push(`Review + apply plan "${p.file}".`);
+        }
+    }
+    return { status: state.phase, next, artifacts, approvals };
+}
+function describeBundle(bundle) {
+    const artifacts = [];
+    for (const plan of bundle.plans ?? []) {
+        if (plan.file)
+            artifacts.push({ kind: 'plan', path: plan.file });
+    }
+    for (const v of bundle.validations ?? []) {
+        artifacts.push({ kind: 'validation', path: v.startedAt });
+    }
+    const next = bundle.nextAction ?? 'shrk bundle show ' + bundle.id;
+    const approvals = [];
+    for (const plan of bundle.plans ?? []) {
+        if (plan.status === 'saved' || plan.status === 'reviewed' || plan.status === 'intent') {
+            approvals.push(`Apply plan "${plan.name}" (${plan.file}).`);
+        }
+    }
+    return { status: bundle.status, next, artifacts, approvals };
+}
+function chunkBody(sectionId, title, body, order) {
+    const file = `${String(order).padStart(2, '0')}-${sectionId}.md`;
+    return {
+        file,
+        sectionId,
+        title,
+        body,
+        tokenEstimate: tokensEstimate(body),
+    };
+}
+export async function buildAgentHandoff(inspection, input) {
+    const projectRoot = inspection.projectRoot;
+    let session = null;
+    if (input.sessionId) {
+        session = scanDevSession(projectRoot, input.sessionId);
+    }
+    let bundle = null;
+    if (input.bundleId) {
+        bundle = readFeatureBundle(projectRoot, input.bundleId);
+    }
+    const sessionState = session?.state ?? null;
+    const task = input.task ?? sessionState?.task ?? bundle?.task ?? '(no task supplied)';
+    const knownContext = [];
+    const doNotTouch = [
+        'Do not bypass `shrk apply --verify-signature`.',
+        'Do not commit changes inside `node_modules/`, `dist/`, or `.sharkcraft/cache/`.',
+        'Do not modify generated bundle JSON by hand — re-run the generator instead.',
+    ];
+    const relevantRules = [];
+    const relevantFiles = [];
+    let status = 'pending';
+    let next = 'shrk doctor';
+    let approvals = [];
+    const artifacts = [];
+    if (session) {
+        const d = describeSession(session);
+        const sessionId = sessionState?.id ?? session.id;
+        status = `session ${sessionId} in phase ${d.status}`;
+        next = d.next;
+        approvals.push(...d.approvals);
+        artifacts.push(...d.artifacts);
+        knownContext.push(`Active dev session: ${sessionId}`);
+        if (sessionState?.briefFile) {
+            knownContext.push(`Brief file: ${sessionState.briefFile}`);
+            relevantFiles.push(sessionState.briefFile);
+        }
+        for (const plan of sessionState?.plans ?? []) {
+            relevantFiles.push(plan.file);
+        }
+    }
+    if (bundle) {
+        const d = describeBundle(bundle);
+        status = session ? `${status}; bundle ${bundle.id} (${d.status})` : `bundle ${bundle.id} (${d.status})`;
+        next = next === 'shrk doctor' ? d.next : next;
+        approvals.push(...d.approvals);
+        artifacts.push(...d.artifacts);
+        knownContext.push(`Active feature bundle: ${bundle.id} (${bundle.status})`);
+        for (const file of bundle.affectedFiles ?? [])
+            relevantFiles.push(file);
+    }
+    if (input.since) {
+        const changed = getChangedFiles(projectRoot, { since: input.since });
+        if (changed.length > 0) {
+            knownContext.push(`${changed.length} changed file(s) since ${input.since}`);
+            for (const f of changed)
+                relevantFiles.push(f);
+        }
+    }
+    // Pull the most relevant top-priority rules from the inspection so the
+    // handoff carries enough behavioural context.
+    for (const r of inspection.knowledgeEntries.slice(0, 10)) {
+        relevantRules.push(`${r.id}: ${r.title}`);
+    }
+    // Render a brief alongside for the chunked path so the agent has the same
+    // pre-work context as a fresh `shrk brief`.
+    let brief = null;
+    if (input.chunked) {
+        brief = await buildAgentBrief(inspection, {
+            ...(task !== '(no task supplied)' ? { task } : {}),
+            mode: BriefMode.Handoff,
+            files: [...new Set(relevantFiles)],
+            ...(input.sessionId ? { sessionId: input.sessionId } : {}),
+            ...(input.bundleId ? { bundleId: input.bundleId } : {}),
+            chunked: true,
+        });
+    }
+    const validationExpectations = [
+        'bun x tsc -p tsconfig.base.json --noEmit',
+        'bun test',
+        'shrk doctor',
+        'shrk check boundaries',
+    ];
+    const humanApprovalPoints = approvals.length > 0 ? approvals : [
+        'After plan generation, a human must run `shrk plan review` and `shrk apply --verify-signature`.',
+    ];
+    const safetyNote = buildSafetyNote();
+    const sourceKind = session && bundle ? 'session+bundle' : session ? 'session' : bundle ? 'bundle' : 'task-only';
+    // Compose the markdown body.
+    const lines = [];
+    lines.push(`# Agent handoff — ${task}`);
+    lines.push('');
+    lines.push(`Generated: ${new Date().toISOString()}`);
+    lines.push(`Project: ${projectRoot}`);
+    lines.push(`Source: ${sourceKind}`);
+    lines.push('');
+    lines.push('## Known context');
+    lines.push('');
+    lines.push(formatList(knownContext));
+    lines.push('');
+    lines.push('## Do NOT touch');
+    lines.push('');
+    lines.push(formatList(doNotTouch));
+    lines.push('');
+    lines.push('## Current status');
+    lines.push('');
+    lines.push(status);
+    lines.push('');
+    lines.push('## Next safe command');
+    lines.push('');
+    lines.push('```');
+    lines.push(next);
+    lines.push('```');
+    lines.push('');
+    lines.push('## Validation expectations');
+    lines.push('');
+    lines.push(formatList(validationExpectations));
+    lines.push('');
+    lines.push('## Human approval points');
+    lines.push('');
+    lines.push(formatList(humanApprovalPoints));
+    lines.push('');
+    lines.push('## Relevant files');
+    lines.push('');
+    lines.push(formatList(relevantFiles));
+    lines.push('');
+    lines.push('## Relevant rules');
+    lines.push('');
+    lines.push(formatList(relevantRules));
+    lines.push('');
+    lines.push('## Available artifacts');
+    lines.push('');
+    if (artifacts.length === 0)
+        lines.push('(none)');
+    else
+        for (const a of artifacts)
+            lines.push(`- [${a.kind}] ${a.path}`);
+    lines.push('');
+    lines.push('## Safety note');
+    lines.push('');
+    lines.push(safetyNote);
+    if (brief) {
+        lines.push('');
+        lines.push('## Pre-work brief (reference)');
+        lines.push('');
+        lines.push(brief.markdown);
+    }
+    const markdown = lines.join('\n');
+    const chunks = [];
+    if (input.chunked) {
+        chunks.push(chunkBody('00-overview', 'Overview', `# ${task}\n\nSource: ${sourceKind}\nStatus: ${status}\n`, 0));
+        chunks.push(chunkBody('next-command', 'Next safe command', `\`\`\`\n${next}\n\`\`\``, 1));
+        chunks.push(chunkBody('known-context', 'Known context', formatList(knownContext), 2));
+        chunks.push(chunkBody('do-not-touch', 'Do not touch', formatList(doNotTouch), 3));
+        chunks.push(chunkBody('validation', 'Validation expectations', formatList(validationExpectations), 4));
+        chunks.push(chunkBody('approvals', 'Human approval points', formatList(humanApprovalPoints), 5));
+        chunks.push(chunkBody('relevant-files', 'Relevant files', formatList(relevantFiles), 6));
+        chunks.push(chunkBody('relevant-rules', 'Relevant rules', formatList(relevantRules), 7));
+        chunks.push(chunkBody('safety', 'Safety note', safetyNote, 8));
+        if (brief) {
+            chunks.push(chunkBody('brief', 'Pre-work brief', brief.markdown, 9));
+        }
+    }
+    // Attach a task-risk summary if a task is provided. Best-effort.
+    let taskRiskSummary;
+    let taskRiskFull;
+    if (input.task && input.task.trim().length > 0) {
+        try {
+            const r = await buildTaskRiskReport(input.task, inspection, {
+                ...(input.since ? { since: input.since } : {}),
+                ...(input.includeMemory ? { includeMemory: true } : {}),
+            });
+            taskRiskFull = r;
+            taskRiskSummary = {
+                level: r.riskLevel,
+                score: r.score,
+                reasons: r.reasons.slice(0, 5).map((reason) => `[${reason.code}] ${reason.message}`),
+            };
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    // Contract, execution graph, plan simulation, memory.
+    let contract;
+    let contractSummary;
+    if (input.includeContract && input.task && input.task.trim().length > 0) {
+        try {
+            contract = await buildAgentContract(input.task, inspection, {
+                ...(input.role ? { role: input.role } : {}),
+                ...(input.mode ? { mode: input.mode } : {}),
+                ...(input.since ? { since: input.since } : {}),
+            });
+            const { computeContractHash } = await import("./agent-contract-gate.js");
+            contractSummary = {
+                role: contract.role,
+                mode: contract.mode,
+                forbiddenCommands: contract.forbiddenCommands.slice(0, 6),
+                requiredValidations: contract.requiredValidations,
+                requiredReviews: contract.requiredReviews,
+                humanApprovalGates: contract.humanApprovalGates,
+                recommendedNextCommand: contract.recommendedNextCommand,
+                contractHash: computeContractHash(contract),
+            };
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    let executionGraph;
+    let executionGraphSummary;
+    if (input.includeExecutionGraph && input.task && input.task.trim().length > 0) {
+        try {
+            executionGraph = await buildTaskExecutionGraph(input.task, inspection, {
+                ...(input.role ? { role: input.role } : {}),
+                ...(input.mode ? { mode: input.mode } : {}),
+                ...(input.since ? { since: input.since } : {}),
+            });
+            const approvalNodes = executionGraph.nodes
+                .filter((n) => n.kind === 'human-approval')
+                .map((n) => n.label);
+            executionGraphSummary = {
+                nodes: executionGraph.nodes.length,
+                edges: executionGraph.edges.length,
+                humanApprovalNodes: approvalNodes,
+            };
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    let planSimulation;
+    if (input.includePlanSimulation) {
+        try {
+            const planPath = input.includePlanSimulation;
+            const absPlan = nodePath.isAbsolute(planPath)
+                ? planPath
+                : nodePath.resolve(projectRoot, planPath);
+            planSimulation = await simulatePlan(inspection, absPlan, {
+                includeBoundaries: true,
+                includeImpact: true,
+                includeOwnership: true,
+            });
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    let memoryRisk;
+    if (input.includeMemory && input.task && input.task.trim().length > 0) {
+        try {
+            const idx = loadRepositoryMemory(projectRoot);
+            memoryRisk = memoryRiskForTask(idx, input.task);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    // Extend the markdown body with the included summaries.
+    let unifiedMarkdown = markdown;
+    if (contractSummary) {
+        unifiedMarkdown += '\n\n## Agent contract\n\n';
+        unifiedMarkdown += `- role: ${contractSummary.role}\n- mode: ${contractSummary.mode}\n- hash: \`${contractSummary.contractHash.slice(0, 16)}…\`\n`;
+        if (contractSummary.humanApprovalGates.length > 0) {
+            unifiedMarkdown += '\n### Human approval gates\n\n' + formatList(contractSummary.humanApprovalGates) + '\n';
+        }
+        if (contractSummary.forbiddenCommands.length > 0) {
+            unifiedMarkdown += '\n### Forbidden commands\n\n' + formatList(contractSummary.forbiddenCommands) + '\n';
+        }
+        if (contractSummary.requiredValidations.length > 0) {
+            unifiedMarkdown += '\n### Required validations\n\n' + formatList(contractSummary.requiredValidations) + '\n';
+        }
+        unifiedMarkdown += `\nRecommended next command: \`${contractSummary.recommendedNextCommand}\`\n`;
+    }
+    if (memoryRisk) {
+        unifiedMarkdown += '\n\n## Memory-driven warnings\n\n';
+        unifiedMarkdown += `- overlap: **${memoryRisk.recommendation}**\n`;
+        if (memoryRisk.matchedFiles.length > 0) {
+            unifiedMarkdown += `- top risky files:\n`;
+            for (const f of memoryRisk.matchedFiles.slice(0, 8))
+                unifiedMarkdown += `  - ${f.path} (touches=${f.touchCount}, conflicts=${f.conflictCount})\n`;
+        }
+    }
+    if (executionGraphSummary) {
+        unifiedMarkdown += '\n\n## Execution graph\n\n';
+        unifiedMarkdown += `- nodes: ${executionGraphSummary.nodes}\n- edges: ${executionGraphSummary.edges}\n`;
+        if (executionGraphSummary.humanApprovalNodes.length > 0) {
+            unifiedMarkdown += `- human approval: ${executionGraphSummary.humanApprovalNodes.join(' | ')}\n`;
+        }
+    }
+    if (planSimulation) {
+        unifiedMarkdown += '\n\n## Plan simulation\n\n';
+        unifiedMarkdown += `- source: \`${planSimulation.source}\`\n- readiness: **${planSimulation.applyReadiness}**\n- public API touched: ${planSimulation.publicApiTouched ? 'yes' : 'no'}\n- ownership review required: ${planSimulation.ownershipReviewRequired ? 'yes' : 'no'}\n`;
+    }
+    return {
+        schema: AGENT_HANDOFF_SCHEMA,
+        generatedAt: new Date().toISOString(),
+        projectRoot,
+        task,
+        knownContext,
+        doNotTouch,
+        relevantFiles,
+        relevantRules,
+        currentStatus: status,
+        nextSafeCommand: next,
+        validationExpectations,
+        humanApprovalPoints,
+        availableArtifacts: artifacts,
+        safetyNote,
+        markdown: unifiedMarkdown,
+        ...(taskRiskFull ? { taskRisk: taskRiskFull } : {}),
+        ...(contract ? { contract } : {}),
+        ...(contractSummary ? { contractSummary } : {}),
+        ...(executionGraph ? { executionGraph } : {}),
+        ...(executionGraphSummary ? { executionGraphSummary } : {}),
+        ...(planSimulation ? { planSimulation } : {}),
+        ...(memoryRisk ? { memoryRisk } : {}),
+        ...(chunks.length > 0 ? { chunks } : {}),
+        ...(taskRiskSummary ? { taskRiskSummary } : {}),
+        source: {
+            kind: sourceKind,
+            ...(input.sessionId ? { sessionId: input.sessionId } : {}),
+            ...(input.bundleId ? { bundleId: input.bundleId } : {}),
+        },
+        uncertainty: buildHandoffUncertainty({
+            taskRiskSummary,
+            relevantFiles,
+            knownContext,
+            sourceKind,
+        }),
+    };
+}
+function buildHandoffUncertainty(input) {
+    let confidence = 'medium';
+    const reasons = [];
+    const missing = [];
+    if (input.sourceKind === 'task-only') {
+        confidence = 'low';
+        reasons.push('Handoff derived from task only — no session or bundle context.');
+        missing.push({ id: 'no-session', message: 'No session context attached.' });
+        missing.push({ id: 'no-bundle', message: 'No bundle context attached.' });
+    }
+    if (input.taskRiskSummary && input.taskRiskSummary.level === 'high') {
+        confidence = 'low';
+        reasons.push(`Task risk is HIGH (score ${input.taskRiskSummary.score}).`);
+    }
+    if (input.relevantFiles.length === 0) {
+        missing.push({ id: 'no-relevant-files', message: 'No relevant files identified.' });
+        if (confidence !== 'low')
+            confidence = 'medium';
+    }
+    if (input.knownContext.length === 0) {
+        missing.push({ id: 'no-known-context', message: 'No known context paragraphs.' });
+    }
+    return buildUncertaintyReport({
+        confidence,
+        reasons,
+        missingSignals: missing,
+        suggestedCommands: [
+            'shrk task "<task>" --commands-first',
+            'shrk dev status',
+        ],
+        safeFallbackCommand: 'shrk start-here',
+    });
+}
+export function defaultHandoffOutputPath(projectRoot, task) {
+    const slug = task
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 40);
+    return nodePath.join(projectRoot, '.sharkcraft', 'handoffs', `${Date.now()}-${slug || 'handoff'}.md`);
+}

package/dist/agent-instructions.d.ts

@@ -0,0 +1,2 @@
+export declare const AGENT_INSTRUCTIONS: string;
+//# sourceMappingURL=agent-instructions.d.ts.map

package/dist/agent-instructions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-instructions.d.ts","sourceRoot":"","sources":["../src/agent-instructions.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,QAoBvB,CAAC"}

package/dist/agent-instructions.js

@@ -0,0 +1,21 @@
+export const AGENT_INSTRUCTIONS = `
+You are an AI agent integrated with SharkCraft.
+
+Default behavior:
+- Do not read every documentation file.
+- Use MCP tools to retrieve only the information you actually need.
+- For task context, call get_relevant_context with the current task and a tight maxTokens.
+- For rules, call get_relevant_rules — never list_rules unless you need an inventory.
+- For generation, list_templates → get_template → create_generation_plan (dry-run by default).
+- Respect path conventions (list_path_conventions, get_path_convention).
+
+Safety:
+- Never write files unless the user explicitly asks; always prefer dry-run first.
+- Never overwrite existing files unless the plan resolves all conflicts.
+- Don't modify files outside the project root.
+
+Quality:
+- Quote the knowledge entry id you used so the user can trace it.
+- If you skip a section, say so and explain why.
+- If a query returns nothing, refine the task description and retry, then ask the user.
+`.trim();

package/dist/agent-orchestration.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Agent orchestration planner.
+ *
+ * Given a task, produce a safe, read-only plan describing how an
+ * agent/human should proceed: phases, commands to suggest, MCP tools,
+ * expected artifacts, human-approval points, stop conditions.
+ *
+ * This is not execution. It does not apply, it does not write source.
+ *
+ * Modes:
+ * - conservative: more review/checkpoints; only drafts/plans suggested
+ * - balanced: dev session + plan review + apply hint
+ * - aggressive: still no auto-apply, but suggests bundle/dev flow faster
+ */
+import { type IChangeIntent } from './change-intent.js';
+import { type IRiskSignals } from './risk-signals.js';
+import { type ITaskRiskReport } from './task-risk.js';
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+export declare const AGENT_ORCHESTRATION_SCHEMA = "sharkcraft.agent-orchestration/v1";
+export declare enum OrchestrationMode {
+    Conservative = "conservative",
+    Balanced = "balanced",
+    Aggressive = "aggressive"
+}
+export interface IOrchestrationPhase {
+    id: string;
+    title: string;
+    purpose: string;
+    recommendedCommands: readonly string[];
+    mcpTools: readonly string[];
+    expectedArtifacts: readonly string[];
+    humanApprovalRequired: boolean;
+    stopConditions: readonly string[];
+    safetyNotes: readonly string[];
+}
+export interface IAgentOrchestrationPlan {
+    schema: typeof AGENT_ORCHESTRATION_SCHEMA;
+    generatedAt: string;
+    task: string;
+    intent: IChangeIntent;
+    mode: OrchestrationMode;
+    phases: readonly IOrchestrationPhase[];
+    firstCommand: string;
+    forbiddenActions: readonly string[];
+    validationCommands: readonly string[];
+    reviewCheckpoints: readonly string[];
+    risk?: IRiskSignals;
+    taskRisk?: ITaskRiskReport;
+    riskAware: boolean;
+}
+export interface IOrchestrationOptions {
+    mode?: OrchestrationMode;
+    bundle?: boolean;
+    session?: boolean;
+    /** When true, fold risk signals into the plan (extra phases / approvals when risk is high). */
+    riskAware?: boolean;
+}
+export declare function buildAgentOrchestrationPlan(task: string, inspection: ISharkcraftInspection, options?: IOrchestrationOptions): Promise<IAgentOrchestrationPlan>;
+export declare function renderOrchestrationText(plan: IAgentOrchestrationPlan): string;
+export declare function renderOrchestrationMarkdown(plan: IAgentOrchestrationPlan): string;
+//# sourceMappingURL=agent-orchestration.d.ts.map

package/dist/agent-orchestration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-orchestration.d.ts","sourceRoot":"","sources":["../src/agent-orchestration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAA0C,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAChG,OAAO,EAAiC,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACrF,OAAO,EAAsC,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC1F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAEvE,eAAO,MAAM,0BAA0B,sCAAsC,CAAC;AAE9E,oBAAY,iBAAiB;IAC3B,YAAY,iBAAiB;IAC7B,QAAQ,aAAa;IACrB,UAAU,eAAe;CAC1B;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,qBAAqB,EAAE,OAAO,CAAC;IAC/B,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,OAAO,0BAA0B,CAAC;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,aAAa,CAAC;IACtB,IAAI,EAAE,iBAAiB,CAAC;IACxB,MAAM,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACvC,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,CAAC,EAAE,iBAAiB,CAAC;IACzB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,+FAA+F;IAC/F,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AA6JD,wBAAsB,2BAA2B,CAC/C,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,qBAAqB,EACjC,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,uBAAuB,CAAC,CAiElC;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,uBAAuB,GAAG,MAAM,CAkB7E;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,uBAAuB,GAAG,MAAM,CA8BjF"}